# VisioForge Documentation and Website Content

**Author:** VisioForge
**License:** CC-BY-4.0 (https://creativecommons.org/licenses/by/4.0/)
**Generated:** 2026-09-01 13:58:00 UTC (ce6e9447def)
**MCP Server:** https://mcp.visioforge.com/mcp (public, no auth — prefer for structured queries)
**Content Sources:** 1362 help documentation pages + 66 website pages

---

# Help Documentation

## Delphi ActiveX SDK Setup - Installation and Configuration
**URL:** https://www.visioforge.com/help/docs/delphi/general/
**Description:** Install and configure TVFMediaPlayer, TVFVideoCapture, and TVFVideoEdit components in Delphi. Covers 64-bit package setup, .otares errors, and IDE integration.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL

# Delphi/ActiveX Libraries for Multimedia Development

Welcome to our developer documentation hub for Delphi/ActiveX multimedia libraries. This resource provides in-depth technical information, code examples, and implementation guides for developers working with our specialized components.

## Core Library Benefits

Our libraries empower Delphi developers to create sophisticated multimedia applications with minimal coding effort. The components are engineered for maximum performance and reliability in professional development environments. Key advantages include:

- Simplified implementation of complex multimedia features
- Optimized performance for resource-intensive operations
- Cross-version compatibility with multiple Delphi releases
- Extensive customization options for specialized requirements

## Documentation Organization

### Technical Reference Materials

Each library section contains detailed API references, implementation examples, and recommended practices. Navigate to the specific library documentation for complete information about:

- Component properties and attributes
- Method signatures and parameters
- Event handlers and callback functions
- Type definitions and constants

### Code Examples and Tutorials

Our documentation includes practical code snippets and complete implementation examples to accelerate your development process. These examples demonstrate effective techniques for common multimedia programming scenarios.

## Installation Troubleshooting Guide

When integrating our libraries into your development environment, you might encounter these known technical issues:

### 64-bit Architecture Compatibility

Delphi's 64-bit compilation environment requires special configuration in some cases:

- [Resolving Delphi 64-bit package installation problems](install-64bit/)
- Handling memory alignment requirements in 64-bit environments
- Addressing pointer size differences between architectures

### Resource File Management

Proper resource handling is essential for stable operation:

- [Fixing Delphi package installation issues with .otares files](install-otares/)
- Resolving resource locking during development
- Managing resource file paths in deployed applications

## Getting Started

To begin implementing our libraries in your projects, follow the library-specific installation guides and review the sample applications. Our documentation provides step-by-step instructions to help you achieve optimal results.

---END OF PAGE---


## Install VisioForge SDK on Delphi 64-bit — Setup Guide
**URL:** https://www.visioforge.com/help/docs/delphi/general/install-64bit/
**Description:** Fix 64-bit BPL loading issues in Delphi IDE. Covers design-time vs runtime packages, library path configuration for x86/x64, and common error solutions.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL

# Mastering Delphi 64-bit Package Installation

## Introduction to 64-bit Development in Delphi

The evolution to 64-bit computing represents a significant advancement for Delphi developers, opening doors to enhanced performance, expanded memory addressing capabilities, and improved resource utilization. Since the introduction of 64-bit support in Delphi XE2, developers have gained the powerful ability to compile native 64-bit Windows applications. This capability enables software to harness modern hardware architectures, access substantially larger memory spaces, and deliver optimized performance for data-intensive operations.

However, this technological progression introduces a distinctive set of complexities, particularly regarding the installation and management of component packages (`.bpl` files). Many Delphi developers encounter perplexing obstacles when attempting to integrate 64-bit packages into their development workflow, leading to frustration and lost productivity.

This in-depth guide explores these challenges thoroughly and provides meticulously detailed, actionable solutions. The fundamental issue originates from a critical architectural characteristic: **the Delphi Integrated Development Environment (IDE) remains a 32-bit application**, even in the most recent releases. This architectural discrepancy between the 32-bit IDE and the 64-bit compilation target creates numerous misunderstandings and technical difficulties related to package management.

Understanding this architectural limitation constitutes the essential first step toward establishing a seamless development experience. We will thoroughly examine why the 32-bit IDE requires 32-bit design-time packages, explore proper project configuration techniques for both 32-bit and 64-bit targets, clarify the critical function of runtime packages, and outline extensive testing methodologies to ensure your applications perform flawlessly across both architectural environments.

## The Architectural Limitation: Why the 32-bit IDE Requires 32-bit Design-Time Packages

### Understanding the IDE's Architecture

The Delphi IDE serves as the principal environment for visual component design, code editing, debugging operations, and comprehensive project management. When designers place components onto forms using the Form Designer, modify properties through the Object Inspector, or utilize specialized component editors, the IDE must load and execute code contained within the component's design-time package.

Because `bds.exe` (the Delphi IDE executable) operates as a 32-bit process, it functions exclusively within the 32-bit memory address space and must adhere to the constraints of 32-bit execution environments. The IDE physically cannot load or execute 64-bit code directly—this represents a hardware and operating system limitation, not merely a software restriction. Any attempt to load a 64-bit DLL (or in Delphi terminology, a 64-bit `.bpl` package) into a 32-bit process will result in immediate failure, typically manifesting as error messages like "Can't load package %s" or obscure operating system error codes.

### Critical Design-Time Requirements

For the IDE to function properly during design activities—enabling visual component manipulation, property configuration, and utilization of design-time features—it *must* load the **32-bit (x86)** version of component packages. This requirement is non-negotiable due to the fundamental architecture of the IDE and operating system memory management principles.

This architectural limitation frequently leads to confusion among developers, creating misconceptions that only 32-bit packages are necessary, or generating questions about why separate 64-bit packages exist if the IDE cannot utilize them. The critical distinction lies in understanding the separation between **design time** operations (occurring within the 32-bit IDE) and **compile/run time** processes (where applications can target either 32-bit or 64-bit architectures).

## Step-by-Step Implementation: Installing 32-bit Design-Time Packages

### Essential First Step: Installing 32-bit Components

Based on the architectural explanation above, the mandatory initial step always involves installing the 32-bit version of component packages into the Delphi IDE. This process establishes the foundation for all subsequent development activities.

1. **Acquire Necessary Package Files:** Ensure you possess both 32-bit and 64-bit compiled package files (`.bpl` and `.dcp`). The 32-bit files typically carry identifier suffixes such as `_x86`, `_Win32`, or may lack platform specifiers in older Delphi versions. Conversely, 64-bit packages normally include `_x64` or `_Win64` designations. These files typically generate automatically when building component library projects targeting both Win32 and Win64 platforms. When using third-party components, reputable vendors should supply both architectural versions.
2. **Launch Development Environment:** Start the Delphi IDE with appropriate user permissions.
3. **Access Package Installation Interface:** Navigate through the menu system to `Component > Install Packages...`.
4. **Initiate Package Addition:** Click the "Add..." button to begin the installation process.
5. **Locate 32-bit Package Files:** Browse to the directory containing your **32-bit** compiled package files (`.bpl`). Carefully select the 32-bit `.bpl` file and click "Open" to proceed.
6. **Complete Installation Process:** The package should appear in the "Design packages" list, typically enabled by default. Confirm the installation by clicking "OK".

### Verification and Troubleshooting

The IDE will attempt to load the 32-bit package. When successful, your components should appear in the Tool Palette, enabling immediate use in the Form Designer. If the IDE fails to load the package, verify that you selected the correct 32-bit `.bpl` file and ensure that all dependency packages required by your target package are properly installed and accessible.

**Critical Warning:** Never attempt to install 64-bit `.bpl` files using the `Component > Install Packages...` menu option. Such attempts will invariably fail because the 32-bit IDE architecture cannot load 64-bit code modules.

## Advanced Configuration: Setting Project Library Paths for Dual Platform Development

### Configuring Compiler Search Paths

While the IDE utilizes 32-bit packages during design-time operations, the Delphi compiler requires precise information about where to locate appropriate files (`.dcu`, `.dcp`, `.obj`) for your specific target platform during compilation (either 32-bit or 64-bit). These settings are configured through project options, specifically within the library path configuration section. Importantly, these settings must be established separately for each target platform.

1. **Access Project Configuration:** Navigate to `Project > Options...` in the IDE menu.
2. **Select Appropriate Platform:** It is absolutely crucial to configure paths separately for each target platform. Utilize the "Target Platform" dropdown menu located at the top of the Project Options dialog. Begin configuration with the "32-bit Windows" selection.
3. **Navigate to Library Configuration Section:** In the options tree displayed on the left side, select `Delphi Compiler > Library` to access path settings.
4. **Configure 32-bit Library Paths:** Within the "Library path" field, click the ellipsis (...) button to open the path editor. Add the directory containing your compiled **32-bit** units (`.dcu` files) and the **32-bit** package's `.dcp` file for the components you've installed. Ensure this path specifically references the 32-bit output directory of your component library.
5. **Switch to 64-bit Configuration:** Change the "Target Platform" dropdown selection to "64-bit Windows". Notice that the "Library path" field might display different content or appear empty.
6. **Configure 64-bit Library Paths:** Repeat the previous path configuration process, but this time add directories containing your compiled **64-bit** units (`.dcu` files) and the **64-bit** package's `.dcp` file. This path *must* differ from the 32-bit path and correctly reference the 64-bit output directory.
7. **Review Additional Path Settings:** While the Library path configuration is essential for locating `.dcu` and `.dcp` files, also examine the `Browsing path` settings (used by code insight features) and verify the `DCP output directory` location is properly configured if you are building packages yourself. Configure these paths for both 32-bit and 64-bit platforms as well.
8. **Save Configuration Changes:** Click "OK" to preserve the project options settings.

### Avoiding Common Configuration Errors

**Frequent Mistake:** Many developers forget to switch the "Target Platform" dropdown *before* setting the path for that platform. Configuring the 64-bit path while "32-bit Windows" remains selected (or vice-versa) represents a common source of compilation errors later in the development process.

By correctly establishing these platform-specific library paths, you provide the compiler with precise information about where to locate necessary `.dcu` and `.dcp` files for the architecture currently under construction.

## Runtime Package Management Strategies

### Deciding on Linking Approaches

Beyond instructing the compiler where to find units during compilation, you must determine how your final executable will link against component libraries. This critical decision is controlled through the "Runtime Packages" settings section.

You have two principal options:

1. **Static Linking Approach:** If you leave the "Link with runtime packages" option unchecked (or remove all packages from the list), the compiler will directly incorporate necessary code and resources from your components into the final `.exe` file. This approach produces larger executable files but eliminates the requirement to distribute separate `.bpl` files alongside your application.
2. **Dynamic Linking (Runtime Packages) Approach:** If you enable "Link with runtime packages" and specify required packages, the compiler will *not* embed component code into your `.exe`. Instead, your application will dynamically load necessary `.bpl` files during execution. This strategy creates smaller executable files but requires deploying corresponding 32-bit or 64-bit `.bpl` files with your application distribution.

### Detailed Configuration Process

1. **Access Project Options:** Navigate to `Project > Options...` in the IDE menu.
2. **Select Target Platform:** Choose either "32-bit Windows" or "64-bit Windows" from the platform dropdown.
3. **Navigate to Package Settings:** Select `Packages > Runtime Packages` in the options navigation tree.
4. **Configure Linking Method:** Enable or disable the "Link with runtime packages" option based on your preferred linking approach determined earlier.
5. **Specify Required Packages:** When utilizing runtime packages, ensure the list contains the correct base names of packages your application requires (e.g., `MyComponentPackage`). Do *not* include platform suffixes or file extensions in these entries. Delphi automatically appends appropriate platform identifiers and loads the correct `_x86.bpl` or `_x64.bpl` files (or equivalent naming based on Delphi version/settings) during runtime.
6. **Configure Secondary Platform:** Switch the "Target Platform" selection and configure runtime package settings identically for the alternative platform. Typically, the decision to use or not use runtime packages remains consistent across both platforms, but package lists might differ if utilizing platform-specific libraries.
7. **Preserve Configuration:** Click "OK" to save the settings.

### Deployment Considerations

**Critical Deployment Requirement:** If you choose dynamic linking with runtime packages, remember that you *must* distribute the correct architectural version (32-bit or 64-bit) of those `.bpl` files with your application. The 32-bit executable requires 32-bit `.bpl` files, while the 64-bit executable needs 64-bit `.bpl` files. Place these files either in the same directory as the `.exe` or in locations accessible through the system's PATH environment variable.

## Comprehensive Testing and Verification Methodologies

### Multi-platform Verification

Configuration alone cannot guarantee success. Thorough testing becomes essential to confirm that everything functions as expected across both target platforms.

1. **Multi-platform Compilation:** Build your project explicitly for both "32-bit Windows" and "64-bit Windows" target platforms. Address any compiler errors that emerge during this process. Errors occurring during compilation frequently indicate incorrectly configured library paths (detailed in Step 2).
2. **32-bit Execution Testing:** Execute the compiled 32-bit application. Thoroughly test all functionality that depends on the components in question. Specifically look for:
3. Proper visual appearance and interactive behavior of components.
4. Absence of exceptions during component instantiation or method invocation.
5. If using runtime packages, verify the application launches without "Package XYZ not found" error messages.
6. **64-bit Execution Testing:** Execute the compiled 64-bit application. Perform identical tests as conducted with the 32-bit version. Pay particular attention to:
7. Any behavioral differences compared to the 32-bit version.
8. Runtime errors such as Access Violations, which might indicate underlying 64-bit compatibility issues in the component code or application logic (e.g., incorrect pointer arithmetic, integer size assumptions).
9. For runtime packages, check again for missing package errors, ensuring 64-bit `.bpl` files are properly accessible.
10. **Edge Case Evaluation:** Include testing scenarios that explore boundary conditions, particularly regarding memory usage if that represents a motivation for transitioning to 64-bit. Load extensive datasets and perform complex operations involving the components to stress-test the implementation.

### Interpreting Test Results

Any discrepancies or errors encountered during runtime on one platform but not the other strongly suggest either a problem in package configuration (Steps 2 or 3) or potential 64-bit compatibility issues within the component or application code itself. Such issues require careful diagnosis and targeted resolution.

## Advanced Troubleshooting Guide

### Resolving Common Installation Issues

- **"Package XYZ.bpl can't be installed because it is not a design time package."**: This error typically indicates an attempt to install a package via `Component > Install Packages` that lacks necessary design-time registrations or configuration flags. Verify that the package project is correctly configured as a design-time package or combined design-time & runtime package.
- **"Can't load package XYZ.bpl. %1 is not a valid Windows application." / "The specified module could not be found."**: This almost certainly indicates an attempt to install a **64-bit** BPL into the 32-bit IDE via `Component > Install Packages`. Remember to install only 32-bit BPL files through this interface. The "module not found" variant may also occur if the package has dependencies that aren't properly installed or cannot be located.
- **[Compiler Error] F1026 File not found: 'ComponentUnit.dcu'**: This error occurs during compilation (not at design time). It indicates the compiler cannot locate the required `.dcu` file for the currently selected target platform. Carefully review your `Project Options > Delphi Compiler > Library > Library path` settings for the *specific platform* you are currently compiling (Step 2). Ensure the path correctly references the appropriate directory (32-bit or 64-bit) containing the necessary `.dcu` files.
- **[Linker Error] E2202 Required package 'XYZ' not found**: Similar to F1026, but occurring during the linking phase. This frequently indicates the `.dcp` file for the package cannot be found. Verify the Library Path (Step 2) includes the directory containing the correct platform's `.dcp` file. Additionally, ensure the package name appears correctly in `Project Options > Packages > Runtime Packages` if utilizing dynamic linking (Step 3).
- **Runtime Error: "Package XYZ not found"**: This indicates your application was compiled to use runtime packages, but the required `.bpl` file (matching the application's architecture) cannot be located during application startup. Ensure the correct 32-bit or 64-bit `.bpl` files are deployed alongside your `.exe` file (as described in Step 3).
- **Runtime Access Violations (AVs) only in 64-bit:** This typically indicates 64-bit compatibility issues in the code (either in your application or the component implementation). Common sources include:
- Pointer arithmetic assuming `SizeOf(Pointer)=4` (valid only in 32-bit code).
- Incorrect use of `Integer` instead of `NativeInt`/`NativeUInt` for handles or pointer-sized values.
- Direct calls to Windows API functions using incorrect data types for 64-bit environments.
- Data structure alignment issues.

Debugging the 64-bit application becomes necessary to identify the specific cause of these violations.

## Working with Third-Party Component Packages

### Best Practices for External Components

The principles outlined throughout this guide apply equally to third-party components. Reputable component vendors typically provide:

1. Detailed instructions for proper installation procedures.
2. Separate 32-bit and 64-bit compiled `.bpl`, `.dcp`, and `.dcu` files.
3. An installation utility that handles file placement in appropriate locations and potentially automates the installation of 32-bit design-time packages into the IDE.

If an installer is provided, utilize it as your first approach. However, always validate project options (Library Paths, Runtime Packages) afterward, as installers may not perfectly configure paths for every possible project configuration or Delphi version. If you receive only raw library files without an installer, follow Steps 1-3 manually, carefully identifying and configuring paths for both 32-bit and 64-bit versions supplied by the vendor. When encountering issues, consult the vendor's documentation or contact their technical support team for assistance.

## Summary and Recommendations

### Key Implementation Strategies

Successfully managing Delphi packages for both 32-bit and 64-bit development fundamentally depends on understanding the 32-bit nature of the IDE and meticulously configuring project options for each target platform independently. Always install the 32-bit package for design-time use, then carefully establish platform-specific Library Paths and Runtime Package settings to ensure the compiler and your final application can locate and utilize the correct files for the target architecture.

While this approach introduces additional complexity compared to purely 32-bit development, the structured methodology enables you to leverage the substantial benefits of 64-bit compilation while maintaining a fully functional design-time experience within the familiar Delphi IDE environment. Consistent testing across both platforms represents the final, crucial verification step to guarantee robust, reliable applications that perform optimally in both 32-bit and 64-bit environments.

---

Need additional information? Please [contact support](https://support.visioforge.com/) for assistance with specific scenarios or component issues.

---END OF PAGE---


## Fix .otares File Errors in Delphi SDK Packages Guide
**URL:** https://www.visioforge.com/help/docs/delphi/general/install-otares/
**Description:** Resolve missing .otares file errors in Delphi - troubleshoot resource issues, fix compilation errors, and restore package functionality.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL

# Fixing .otares File Errors in Delphi Packages

## How to Solve the .otares File Not Found Error in Delphi

When working with Delphi packages, developers frequently encounter the frustrating .otares file not found error that can completely halt your development workflow. This practical guide explains the problem, identifies common causes, and provides tested solutions to get your projects back on track.

### What is an .otares File?

To effectively troubleshoot this issue, you need to understand the role of .otares files in Delphi:

- Resource files specific to Delphi development environments
- Contain compiled resources including images, icons, and binary assets
- Generated during package compilation processes
- Critical for packages with visual components or resource-dependent features

### Typical Error Messages

You'll likely encounter these errors during compilation or installation:

```
[dcc32 Error] E1026 File not found: 'Package_Name.otares'
[dcc32 Error] E1026 Could not locate resource file 'Component_Package.otares'
[dcc32 Error] Package compilation failed due to missing .otares file
```

### When This Issue Typically Occurs

These errors commonly appear when:

1. Installing third-party component packages
2. Upgrading to newer Delphi versions
3. Moving projects between development machines
4. Collaborating with team members on shared projects

### Why .otares File Errors Happen

Several factors can trigger these errors:

1. **Missing Resource Files**: The .otares file isn't in the expected location
2. **Incorrect Path References**: Package configuration references wrong location
3. **Version Compatibility Issues**: Resource file compiled for different Delphi version
4. **Corrupted Resources**: The file exists but is damaged
5. **Permission Problems**: Environment lacks access rights to the resource location

### Step-by-Step Solution Guide

Follow these practical steps to resolve .otares-related issues:

1. **Find and Examine the .dpk File**
2. Navigate to your package's source directory
3. Open the .dpk file in Delphi IDE or text editor
4. Review all resource references
5. Focus on `$R` directives
6. **Identify Problematic Resource Directives**
7. Search for lines starting with `$R` or `{$R}`
8. These lines specify resource file inclusions
9. Example of problematic directives:

```
{$R 'Component_Package.otares'}
{$R '.\resources\ComponentResources.otares'}
```

1. **Apply the Fix**

**Comment out the problematic resource reference:**

```
// Original line
{$R 'Component_Package.otares'}

// Modified version
// {$R 'Component_Package.otares'}
```

1. **Rebuild the Package**
2. Save all changes to the .dpk file
3. Restart the Delphi IDE to ensure changes are recognized
4. Clean the project (Project → Clean)
5. Rebuild the package (Project → Build)
6. If successful, install the package

### Advanced Solutions for Persistent Issues

When basic fixes don't work, try these advanced approaches:

1. **Recreate Resource Files**
2. Locate the original source files
3. Use Resource Compiler to rebuild the .otares file
4. Update package references to the new file
5. **Check Package Dependencies**
6. Look for circular dependencies
7. Verify installation order is correct
8. Ensure version compatibility
9. **Verify Environment Configuration**
10. Check BDSCOMMONDIR setting
11. Verify PATH variables for resource locations
12. Confirm library paths in IDE options

---

For personalized assistance with this issue, [contact our support team](https://support.visioforge.com/) and our technical experts will guide you through resolving your specific package installation problems.

---END OF PAGE---


## Delphi and ActiveX Video SDK - Playback, Capture, Editing
**URL:** https://www.visioforge.com/help/docs/delphi/
**Description:** VCL components and ActiveX controls for video playback, capture, screen recording, and editing in Delphi and C++ Builder.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Streaming, Editing
**API:** TVFMediaPlayer, TVFVideoCapture, TVFVideoEdit

# All-in-One Media Framework

A set of Delphi/ActiveX libraries for video processing, playback, and capture called All-in-One Media Framework. These libraries help developers create professional video editing, playback, and capture applications with minimal effort and maximum performance.

The framework provides a comprehensive solution for media handling in Delphi applications, offering high-performance video processing capabilities that would otherwise require extensive low-level programming. Developers can implement complex video workflows with simple component-based architecture.

You can find the following library documentation here:

## Libraries

- [TVFMediaPlayer](mediaplayer/) - Full-featured media player component with playlist support, frame-accurate seeking, and advanced playback controls
- [TVFVideoCapture](videocapture/) - Powerful video capture component supporting webcams, capture cards, IP cameras, and screen recording
- [TVFVideoEdit](videoedit/) - Professional video editing component with timeline support, transitions, filters, and output to multiple formats

## Implementation Examples

The framework includes numerous examples demonstrating how to implement common media tasks:

- Video players with custom controls and visualizations
- Multi-camera recording applications
- Video editing software with timeline support
- Format conversion utilities
- Streaming media applications

## General Information

ActiveX packages can be used in multiple programming languages and development environments including Visual C++, Visual Basic, and C++ Builder. These components extend your software capabilities, accelerating development and improving performance. With ActiveX integration, you can incorporate existing software components into your projects, boosting efficiency and functionality.

Our framework is compatible with all Delphi versions from Delphi 6 to Delphi 11 and beyond, making it suitable for both legacy projects and new development. The components maintain a consistent API across different Delphi versions, simplifying migration between different IDE versions.

## Technical Specifications

- **Supported Media Formats**: MP4, AVI, MOV, MKV, MPEG, WMV and many others
- **Audio Support**: AAC, MP3, PCM, WMA and other popular audio codecs
- **Video Codecs**: H.264, H.265/HEVC, MPEG-4, VP9, AV1 and more
- **Capture Sources**: Webcams, HDMI capture cards, IP cameras, screen capture
- **Hardware Acceleration**: NVIDIA NVENC, Intel Quick Sync, AMD AMF

## x64 Support Limitations

With Delphi XE2 and later, you can develop 64-bit applications. Our framework fully supports these 64-bit applications, allowing you to leverage modern computing power and handle larger memory requirements. 64-bit support enables processing of higher resolution videos and more complex editing operations that would be impossible in 32-bit environments.

Microsoft Visual Basic 6 does not support 64-bit applications. If you're using Visual Basic 6, you'll need to use the 32-bit version of our framework due to VB6's inherent limitations. While 32-bit applications can access up to 4GB of memory with proper configuration, for demanding video applications, we recommend using Delphi or other development environments with 64-bit support.

## Development Best Practices

When integrating the framework into your applications, consider these best practices:

- Initialize components at design time when possible for better IDE integration
- Use hardware acceleration for demanding operations like encoding and decoding
- Implement proper error handling for media operations
- Consider memory management for large media files
- Test with various media sources to ensure compatibility

---

For more information about the framework, visit the [All-in-One Media Framework (Delphi/ActiveX)](https://www.visioforge.com/all-in-one-media-framework) product page.

---END OF PAGE---


## TVFMediaPlayer Delphi Changelog - Version History v3 to v10
**URL:** https://www.visioforge.com/help/docs/delphi/mediaplayer/changelog/
**Description:** TVFMediaPlayer changelog - track version history from 3.0 to 10.0 with 4K support, encryption, effects, streaming, and performance updates.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, DirectShow, Windows, VCL, Playback, Streaming
**API:** TVFMediaPlayer

# TVFMediaPlayer Library Changelog

This document details the evolution of the TVFMediaPlayer library, chronicling the significant features, enhancements, optimizations, and bug fixes introduced across various versions. It serves as a comprehensive reference for developers tracking the library's progress and understanding the capabilities added over time.

## Version 10.0: Enhanced Media Handling and Customization

Version 10.0 represents a significant step forward, focusing on improved media introspection, logging, customization, and compatibility.

### Core Enhancements

- **Enhanced Media Information Reader:** This version significantly boosts the capabilities of the media information reader. It enables faster, more accurate extraction of metadata from an extensive array of media file types. Developers gain reliable access to critical details like duration, resolution, codec specifics, bitrates, and embedded tags, which streamlines media management and enhances the display capabilities within applications.
- **Improved Logging Capabilities:** Logging has been substantially refined, offering developers more granular control. Configuration options now include distinct log levels (Debug, Info, Warning, Error) and flexible output destinations such as files, the console, or custom endpoints. This facilitates more effective issue diagnosis during development and robust monitoring of application behavior in production, ultimately leading to quicker troubleshooting and increased application stability.
- **Standard Metadata Tag Support:** A cornerstone of this release is the introduction of comprehensive support for reading standard metadata tags embedded within popular video and audio containers. This includes formats like MP4, WMV, MP3, AAC, M4A, and Ogg Vorbis. Applications utilizing TVFMediaPlayer can now seamlessly extract and leverage common tags such as title, artist, album, genre, year, and cover art, thereby enriching the user experience by providing valuable context for the media being played.

### Capture and Effects Improvements

- **Configurable Auto-Split Filenames:** The new `SeparateCapture_Filename_Mask` property provides fine-grained control over filenames when using the auto-split capture feature based on duration or size. This allows for customized naming conventions, improving organization and workflow for segmented recordings.
- **JSON Settings Serialization:** Configuration settings for the media player can now be easily serialized to and deserialized from the widely-used JSON format. This simplifies saving and loading player configurations, enabling persistent settings and easier integration with configuration management systems.
- **Custom Video Effects Pipeline:** Flexibility in video processing is enhanced with the ability to insert custom video effects using third-party filters identified by their CLSID. These filters can be strategically placed either before or after the main effects filter or sample grabber, allowing for sophisticated, tailored video manipulation pipelines.
- **Optimized Video Effects:** Video effects processing has been optimized to take full advantage of the latest generations of Intel CPUs, resulting in smoother playback and lower resource consumption when applying effects.

### Source and Compatibility Fixes

- **MP3 Splitter for Playback Issues:** An MP3 splitter has been integrated to specifically address and resolve playback inconsistencies encountered with certain non-standard or problematic MP3 files, ensuring broader compatibility.
- **Updated VLC Source Filter:** The underlying VLC source filter has been updated to libVLC version 2.2.2.0. This update brings notable improvements, particularly in handling RTMP and HTTPS streams, and resolves previously identified memory leaks, contributing to enhanced stability and broader streaming protocol support.
- **Pan and Blur Effect Fixes:** Specific issues related to the Pan effect in x64 builds and the Blur effect have been addressed and resolved, ensuring consistent visual effect behavior across different architectures.
- **FFMPEG Source Memory Leak Resolved:** A memory leak associated with the FFMPEG source component has been identified and fixed, improving long-term stability and resource management during playback.

## Version 9.2: Engine Updates and Reader Enhancements

This interim release focused on updating core components and further refining the media information capabilities.

- **Updated VLC Engine:** The integrated VLC engine was updated to libVLC version 2.2.1.0, incorporating upstream fixes and improvements from the VLC project for better stability and format compatibility.
- **Enhanced Media Information Reader:** Building upon previous improvements, the media information reader received further enhancements for broader file support and more accurate metadata extraction.
- **Updated FFMPEG Engine:** The FFMPEG engine components were updated, ensuring compatibility with newer codecs and formats while incorporating performance optimizations.

## Version 9.1: Advanced Security Integration

Version 9.1 introduced robust security features through integration with the Video Encryption SDK.

- **Video Encryption SDK v9 Support:** This version added compatibility with the Video Encryption SDK v9. This enables developers to implement strong AES-256 encryption for their video content, using either separate key files or embedded binary data as keys, significantly enhancing content protection capabilities.

## Version 9.0: Audio Enhancements and Logo Flexibility

Version 9.0 brought significant improvements to audio handling and visual branding options.

- **Animated GIF Logo Support:** The capability to use image logos was expanded to include support for animated GIFs, allowing for more dynamic and engaging visual branding within the video playback interface.
- **Audio Enhancements:** A suite of audio enhancement features was introduced, including audio normalization to ensure consistent volume levels, automatic gain control (AGC) to dynamically adjust volume, and manual gain controls for precise audio level adjustments.
- **Percentage-Based Audio Volume:** The API for controlling audio volume was modernized to use a percentage-based system (0-100%), providing a more intuitive and standardized way to manage audio levels compared to previous methods.

## Version 8.6: Decoder Expansion and API Additions

This release focused on expanding codec support, adding flexibility through custom filters, and refining the API.

- **H264 CPU/Intel QuickSync Decoder:** A highly optimized H264 video decoder was added, leveraging both CPU resources and Intel QuickSync hardware acceleration where available. This significantly improves performance for decoding one of the most common video codecs.
- **Custom DirectShow Video Filter Support:** Developers gained the ability to integrate their own custom DirectShow video filters into the playback graph, allowing for highly specialized video processing tasks.
- **`OnNewFilePlaybackStarted` Event:** A new event, `OnNewFilePlaybackStarted`, was introduced. This event fires specifically when a new file begins playing within a playlist context, enabling applications to react precisely to transitions between media items.
- **Updated Decoders:** The Ogg Vorbis audio decoder and WebM video decoders were updated to their latest versions, ensuring compatibility and performance improvements.
- **Frame Grabber API Update:** The API for grabbing individual video frames was updated, potentially offering improved performance or flexibility.
- **Bug Fixes:** Various unspecified bug fixes were implemented to improve overall stability and reliability.

## Version 8.5: Rotation, 4K Readiness, and Rendering Options

Version 8.5 introduced innovative video manipulation features and prepared the engine for ultra-high-definition content.

- **On-the-Fly Video Rotation:** A new video effect was added, enabling real-time rotation of the video stream during playback (e.g., 90, 180, 270 degrees).
- **Updated FFMPEG Source:** The FFMPEG source component was updated, likely incorporating support for newer formats or improving performance.
- **4K-Ready Video Effects:** Existing video effects were optimized and tested to ensure they perform efficiently with 4K resolution video content.
- **VMR-9/EVR Zoom Shift Bug Fix:** A specific bug related to unexpected image shifting when using zoom with the VMR-9 or EVR video renderers was corrected.
- **Direct2D Video Renderer (Beta):** A new video renderer based on Direct2D was introduced as a beta feature. This renderer included support for live video rotation and aimed to leverage modern graphics APIs for potentially improved performance and quality.
- **Bug Fixes:** Included various general bug fixes to enhance stability.

## Version 8.4: Decoder Updates and Stability

This was primarily a maintenance release focused on updating core components.

- **Updated FFMPEG Decoder:** The FFMPEG decoder components were updated, likely incorporating fixes and improvements from the FFMPEG project.
- **Bug Fixes:** Addressed various unspecified bugs for improved stability.

## Version 8.3: Stability Release

This release focused solely on addressing bugs identified in previous versions.

- **Bug Fixes:** Implemented various fixes to enhance the overall reliability and stability of the library.

## Version 8.0: Introducing the VLC Engine

Version 8.0 marked a significant architectural addition by integrating the powerful VLC engine.

- **VLC Engine Integration:** The renowned VLC engine was integrated as an alternative playback backend for video and audio files. This brought VLC's extensive format support and robust streaming capabilities to TVFMediaPlayer applications.
- **Bug Fixes:** Included various general bug fixes.

## Version 7.x Series: Effects, Encryption, and Playlists

The Version 7 series introduced key features related to playback control, security, and visual effects.

### Version 7.20

- **Reverse Playback:** Added the capability to play video files in reverse, opening up creative possibilities and specialized application use cases.
- **Bug Fixes:** Addressed various bugs.

### Version 7.12

- **Video Encryption Support:** Initial support for video encryption was added, providing basic content protection mechanisms.
- **Bug Fixes:** Included general stability improvements.

### Version 7.7

- **Fade-In/Fade-Out Effect:** A common and useful video transition effect, fade-in/fade-out, was added to the available video effects.
- **Playlist Support:** Functionality for creating and managing playlists was introduced, allowing sequences of media files to be played automatically.
- **Bug Fixes:** Addressed various issues.

### Version 7.5

- **Improved Chroma Key:** The chroma key (green screen) effect was enhanced for better quality and more precise control.
- **Enhanced Text Logo:** The feature for overlaying text logos onto the video was improved.
- **Modified Video Effects API:** The API for applying video effects underwent modifications, potentially for improved usability or to accommodate new features.
- **Bug Fixes:** Included various stability fixes.

### Version 7.0

- **Windows 8 RTM Support:** Ensured compatibility with the release version of Windows 8.
- **Enhanced Video Effects:** Further improvements were made to the quality and performance of existing video effects.
- **New FFMPEG Playback Engine:** Introduced a new playback engine based on FFMPEG components, offering an alternative to the default DirectShow-based playback and expanding format compatibility.

## Version 6.x Series: Windows 8 Compatibility and Optimizations

The Version 6 series focused on adapting to the then-new Windows 8 operating system and improving performance.

### Version 6.3

- **Windows 8 Customer Preview Support:** Added compatibility for the pre-release Customer Preview version of Windows 8.
- **Improved Video Effects:** Continued refinement of video effect performance and quality.

### Version 6.0

- **Enhanced OpenCL Support:** Improved utilization of OpenCL for GPU acceleration tasks, potentially boosting performance for effects or decoding on compatible hardware.
- **Windows 8 Developer Preview Support:** Added early support for the Developer Preview version of Windows 8.
- **Improved Video Effects:** General enhancements to the video effects subsystem.

## Version 3.x Series: Early Features and Optimizations

The Version 3 series laid groundwork features and focused on CPU-specific optimizations.

### Version 3.9

- **New Installers:** Introduced a new main installer and separate redistributable installers for easier deployment.
- **Minor Bug Fixes:** Addressed minor outstanding issues.

### Version 3.7

- **Improved Video Effects:** Enhancements made to the video effects features.
- **New Demo Applications:** Added new demo applications to showcase library capabilities.
- **Netbook CPU Optimizations:** Included specific performance optimizations tailored for Intel Core II/Atom and AMD netbook processors.
- **Minor Bug Fixes:** General stability improvements.

### Version 3.5

- **Improved Video Effects:** Continued work on enhancing video effects.
- **Intel Core i7 Optimizations:** Added new performance optimizations specifically for the then-new Intel Core i7 CPU architecture.

### Version 3.0

- **Motion Detection:** Introduced a motion detection feature, enabling applications to react to changes within the video stream.
- **Chroma Key:** Added initial chroma key (green screen) functionality.
- **MMS/WMV Source Support:** Included support for streaming using the MMS protocol and playing WMV (Windows Media Video) files.
- **CPU Optimizations:** Added performance optimizations targeted at Intel Atom and Core i3/i5/i7 processors.
- **Direct Stream Processing:** Enabled the capability to directly access and process decoded video and audio stream data, offering advanced manipulation possibilities.

---END OF PAGE---


## TVFMediaPlayer Deployment Guide — Delphi and ActiveX
**URL:** https://www.visioforge.com/help/docs/delphi/mediaplayer/deployment/
**Description:** Deploy TVFMediaPlayer apps with silent installers or manual setup. Covers codec packages, DirectShow filters, VC++ redistributables, and dependencies.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, DirectShow, Windows, VCL, Playback, IP Camera
**API:** TVFMediaPlayer

# Deployment Guide for TVFMediaPlayer

Deploying applications built with the TVFMediaPlayer library requires ensuring that all necessary components are correctly installed and configured on the target machine. This guide provides detailed instructions for both automated and manual deployment methods, catering to different scenarios and technical requirements. Whether you prefer the simplicity of silent installers or the granular control of manual setup, this document covers the essential steps to successfully deploy your Delphi or ActiveX media player application.

## Understanding Deployment Requirements

Before deploying your application, it's crucial to understand the dependencies of the TVFMediaPlayer library. The library relies on several core components, including base runtimes, specific codecs (like FFMPEG or VLC for certain sources), and Microsoft Visual C++ Redistributables. The deployment method you choose will determine how these dependencies are handled.

### Core Components

- **Base Library:** Contains the essential engine and DirectShow filters for basic playback functionality.
- **Codec Packages:** Optional but often necessary for supporting a wide range of media formats and network streams (e.g., IP cameras). FFMPEG and VLC are common choices provided.
- **Runtime Dependencies:** Microsoft Visual C++ Redistributable packages are required for the core library components to function correctly.

Choosing the right deployment strategy depends on factors like user privileges on the target machine, the need for unattended installation, and the specific features of your application (e.g., which media sources it needs to support).

## Method 1: Automated Installation (Admin Rights Required)

Using the provided silent installers is the most straightforward method for deploying the TVFMediaPlayer library components. These installers handle the registration of necessary files and ensure all dependencies are correctly placed. This method requires administrative privileges on the target machine as it involves system-level changes like registering COM components and potentially modifying the system PATH.

### Available Installers

VisioForge provides separate installers for the base library and optional codec packages, with versions for both Delphi and ActiveX, and for x86 and x64 architectures.

#### Base Package (Mandatory)

This package installs the core TVFMediaPlayer components and essential DirectShow filters. It's always required, regardless of the media sources your application uses. Choose the installer corresponding to your development environment (Delphi or ActiveX) and target architecture (x86 or x64).

- **Delphi:**
- [x86 Installer](https://files.visioforge.com/redists_delphi/redist_media_player_base_delphi.exe)
- [x64 Installer](https://files.visioforge.com/redists_delphi/redist_media_player_base_delphi_x64.exe)
- **ActiveX:**
- [x86 Installer](https://files.visioforge.com/redists_delphi/redist_media_player_base_ax.exe)
- [x64 Installer](https://files.visioforge.com/redists_delphi/redist_media_player_base_ax_x64.exe)

#### FFMPEG Package (Optional - For File/IP Camera Sources)

If your application needs to play local files or stream from IP cameras using the FFMPEG engine, you must deploy this package. FFMPEG provides a wide range of codec support.

- **FFMPEG:**
- [x86 Installer](https://files.visioforge.com/redists_delphi/redist_media_player_ffmpeg.exe)
- *Note: An x64 FFMPEG installer link was not explicitly provided in the original source; assume x86 covers most needs or consult VisioForge documentation for x64 specifics if required.*

#### VLC Source Package (Optional - For File/IP Camera Sources)

As an alternative or addition to FFMPEG, you can use the VLC engine for file and IP camera sources. This requires deploying the VLC package. Ensure you select the correct architecture.

- **VLC:**
- [x86 Installer](https://files.visioforge.com/redists_net/redist_dotnet_vlc_x86.exe)
- [x64 Installer](https://files.visioforge.com/redists_net/redist_dotnet_vlc_x64.exe)

### Installer Usage

These installers are designed for silent execution, making them suitable for inclusion in larger application setup routines or for deployment via scripts. Run the executable(s) with administrator privileges on the target machine.

```
# Example: Running the base Delphi x86 installer silently
redist_media_player_base_delphi.exe /S
```

*(Note: The exact silent switch might vary; consult the installer documentation or use standard switches like `/S`, `/silent`, or `/q` if `/S` doesn't work).*

## Method 2: Manual Installation (Admin Rights Recommended)

Manual installation offers more control but requires careful execution of each step. This method is suitable when automated installers cannot be used, or when deploying to environments with specific restrictions. While some steps might be achievable without full admin rights, registering COM components typically requires elevation.

### Prerequisites

Before copying library files, ensure the necessary runtime dependencies are present on the target system.

#### Install VC++ 2010 SP1 Redistributable

The TVFMediaPlayer library relies on the Microsoft Visual C++ 2010 SP1 runtime. Install the appropriate version (x86 or x64) for your application's target architecture.

- **VC++ 2010 SP1:**
- [x86 Redistributable](https://files.visioforge.com/shared/vcredist_2010_x86.exe)
- [x64 Redistributable](https://files.visioforge.com/shared/vcredist_2010_x64.exe)

Run these installers before proceeding with the library file deployment.

### Deploying Core Library Files

Follow these steps to manually install the base library components:

1. **Copy Core DLLs:** Locate the `Redist\Filters` folder within your TVFMediaPlayer installation directory. Copy all the DLL files from this folder to a deployment directory on the target machine. A common practice is to place these DLLs in the same folder as your application's executable.
2. **Register DirectShow Filters:** The core functionality relies on several DirectShow filters (`.ax` files). These must be registered with the Windows operating system using Component Object Model (COM) registration.
   - **Identify Filters:** The key filters to register are:
     - `VisioForge_Audio_Effects_4.ax`
     - `VisioForge_Dump.ax`
     - `VisioForge_RGB2YUV.ax`
     - `VisioForge_Video_Effects_Pro.ax`
     - `VisioForge_YUV2RGB.ax`
     - *(Note: Other `.ax` files might be present; register all `.ax` files found in the `Redist\Filters` directory).*
   - **Registration Method:** Use the `regsvr32.exe` command-line tool, which is part of Windows. Open an Command Prompt **as Administrator** and run the command for each `.ax` file.

     ```
     # Example: Registering a filter (run from the directory containing the .ax file)
     regsvr32.exe VisioForge_Video_Effects_Pro.ax
     ```

     Alternatively, VisioForge provides a utility `reg_special.exe` in the redistributables. Copy this utility to the folder containing the `.ax` files and run it with administrator privileges to register all filters in that directory automatically. Refer to Microsoft's documentation for troubleshooting `regsvr32.exe` errors: [How to use the Regsvr32 tool](https://support.microsoft.com/en-us/topic/how-to-use-the-regsvr32-tool-and-troubleshoot-regsvr32-error-messages-a98d960a-7392-e6fe-d90a-3f4e0cb543e5). 3. **Update System PATH (Optional but Recommended):** If the filter DLLs and `.ax` files are placed in a directory separate from your application's executable, you must add the path to this directory to the system's `PATH` environment variable. This allows the operating system and your application to locate these essential files. Failure to do this can result in "DLL not found" or filter registration errors.

### Deploying Optional Packages Manually

#### FFMPEG Deployment

1. **Copy Files:** Copy the entire contents of the `Redist\FFMPEG` folder from your TVFMediaPlayer installation to a deployment directory on the target machine (e.g., a subfolder within your application's installation directory).
2. **Update System PATH:** Add the full path to the folder where you copied the FFMPEG files to the Windows system `PATH` environment variable. This is crucial for the library to find and load the FFMPEG components.

#### VLC Deployment (Example: x86)

1. **Copy Files:** Copy the entire contents of the `Redist\VLC` folder (specifically the x86 version if applicable) to a deployment directory.
2. **Register VLC Filter:** Locate the `.ax` file within the copied VLC files (e.g., `axvlc.dll` or similar, though the original text only generically mentions ".ax file") and register it using `regsvr32.exe` with administrator privileges.
3. **Set Environment Variable:** Create a new system environment variable named `VLC_PLUGIN_PATH`. Set its value to the full path of the `plugins` subfolder within the directory where you copied the VLC files (e.g., `C:\YourApp\VLC\plugins`). This tells the VLC engine where to find its necessary plugin modules.

## Verification and Troubleshooting

After deployment, thoroughly test your application on the target machine.

- Check basic playback functionality.
- Test any specific features that rely on optional packages (FFMPEG or VLC), such as playing various file formats or connecting to IP cameras.
- If errors occur, double-check:
- Admin rights during installation/registration.
- Correct installation of VC++ Redistributables.
- Successful registration of all `.ax` files (check `regsvr32.exe` output).
- Accurate configuration of `PATH` and `VLC_PLUGIN_PATH` environment variables.
- Correct architecture (x86/x64) match between your application, the library components, and runtime dependencies.

---

Need further assistance? Contact [VisioForge Support](https://support.visioforge.com/). Explore more examples on our [GitHub](https://github.com/visioforge/).

---END OF PAGE---


## Play Multiple Video Streams with Delphi SDK Player
**URL:** https://www.visioforge.com/help/docs/delphi/mediaplayer/file-multiple-video-streams/
**Description:** Handle multiple video streams in files - select camera angles, switch resolutions, and manage tracks with code examples for Delphi, C++, and VB6.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, DirectShow, C++, Windows, VCL, Playback, MKV
**API:** TVFMediaPlayer, CVFMediaPlayer

# Playing Video Files with Multiple Video Streams

## Understanding Multiple Video Streams

### What Are Multiple Video Streams?

Multiple video streams refer to different video tracks contained within a single media file. These streams can vary in several ways:

- Different camera angles of the same scene
- Alternate versions with varying resolutions or bitrates
- Primary and secondary content (such as picture-in-picture)
- Different aspect ratios or formats of the same content
- Versions with or without special effects or graphics

### Supported File Formats

Many popular container formats support multiple video streams, including:

- **Matroska (MKV)**: Widely recognized for its flexibility and robust support for multiple streams
- **MP4/MPEG-4**: Common in both professional and consumer applications
- **AVI**: Although older, still widely used in some contexts
- **WebM**: Popular for web-based applications
- **TS/MTS**: Used in broadcast applications and consumer video cameras

Each format has its own characteristics and limitations regarding how it handles multiple video streams, but the `TVFMediaPlayer` component provides a unified approach to working with them.

## Implementing Multiple Video Stream Playback

### Setting Up the Media Player

The first step is to properly initialize the `TVFMediaPlayer` object. This involves creating the instance, configuring basic properties, and preparing it for playback.

Snippets are fragments of one procedure

The Pascal snippets in the three sub-sections below are excerpts from a single procedure (`TForm1.SetupAndPlayMultiStream`), split for narrative clarity. The full pasteable listing is at the [end of this section](#complete-pascal-listing).

```
// Excerpt — see "Complete Pascal listing" below for the full procedure.
procedure TForm1.SetupAndPlayMultiStream;
var
  MediaPlayer1: TVFMediaPlayer;
begin
  MediaPlayer1 := TVFMediaPlayer.Create(Self);

  // Set container size and position if needed
  MediaPlayer1.Parent := Panel1; // Assuming Panel1 is your container
  MediaPlayer1.Align := alClient;

  // Configure initial state
  MediaPlayer1.DoubleBuffered := True;
  MediaPlayer1.AutoPlay := False; // We'll control playback explicitly
  // ... continued below
end;
```

### Configuring the Media Source

Next, we need to specify the media file and configure how it should be loaded:

```
// Excerpt — body of TForm1.SetupAndPlayMultiStream (continued).
  // Set the file name - use full path for reliability
  MediaPlayer1.FilenameOrURL := 'C:\Videos\multistream-video.mkv';

  // Enable audio playback (default DirectSound audio renderer will be used)
  MediaPlayer1.Audio_Play := True;

  // Configure audio settings if needed
  MediaPlayer1.Audio_Volume := 85; // Set volume to 85%

  // Set the source mode to DirectShow
  // Other options include SM_File_FFMPEG or SM_File_VLC
  MediaPlayer1.Source_Mode := SM_File_DS;
```

### Selecting and Switching Video Streams

The key to working with multiple video streams is the `Source_VideoStreamIndex` property. This zero-based index allows you to select which video stream should be rendered:

```
// Excerpt — body of TForm1.SetupAndPlayMultiStream (final part).
  // Set video stream index to 1 (second stream, as index is zero-based)
  MediaPlayer1.Source_VideoStreamIndex := 1;

  // Start playback
  MediaPlayer1.Play();
end;
```

### Complete Pascal listing

The three excerpts above merged into one self-contained, copy-pasteable procedure:

```
procedure TForm1.SetupAndPlayMultiStream;
var
  MediaPlayer1: TVFMediaPlayer;
begin
  MediaPlayer1 := TVFMediaPlayer.Create(Self);

  // Container + initial state
  MediaPlayer1.Parent := Panel1;
  MediaPlayer1.Align := alClient;
  MediaPlayer1.DoubleBuffered := True;
  MediaPlayer1.AutoPlay := False;

  // Source + audio configuration
  MediaPlayer1.FilenameOrURL := 'C:\Videos\multistream-video.mkv';
  MediaPlayer1.Audio_Play := True;
  MediaPlayer1.Audio_Volume := 85;
  MediaPlayer1.Source_Mode := SM_File_DS;

  // Pick a non-default video stream and start playback
  MediaPlayer1.Source_VideoStreamIndex := 1;
  MediaPlayer1.Play();
end;
```

## C++ MFC Implementation

### Setting Up the Media Player

Here's how to implement multiple video stream playback using C++ with MFC:

```
// In your header file (MyDlg.h)
private:
    CVFMediaPlayer* m_pMediaPlayer;

// In your implementation file (MyDlg.cpp)
BOOL CMyDlg::OnInitDialog()
{
    CDialog::OnInitDialog();

    // Create the MediaPlayer instance
    m_pMediaPlayer = new CVFMediaPlayer();

    // Initialize the control
    CWnd* pContainer = GetDlgItem(IDC_PLAYER_CONTAINER); // Your container control
    m_pMediaPlayer->Create(NULL, NULL, WS_CHILD | WS_VISIBLE,
                          CRect(0, 0, 0, 0), pContainer, 1001);

    // Configure display settings — CWnd::GetClientRect(LPRECT) returns void
    // and fills the rect by reference, so we must declare a CRect first.
    CRect rc;
    pContainer->GetClientRect(&rc);
    m_pMediaPlayer->SetWindowPos(NULL, 0, 0, rc.Width(), rc.Height(), SWP_NOZORDER);
    m_pMediaPlayer->PutDoubleBuffered(TRUE);
    m_pMediaPlayer->PutAutoPlay(FALSE);

    return TRUE;
}
```

### Configuring the Media Source

```
void CMyDlg::PlayMultiStreamVideo()
{
    // Set the file path and configure source
    m_pMediaPlayer->PutFilenameOrURL(_T("C:\\Videos\\multistream-video.mkv"));

    // Configure audio
    m_pMediaPlayer->PutAudio_Play(TRUE);
    m_pMediaPlayer->PutAudio_Volume(85);

    // Set source mode to DirectShow
    m_pMediaPlayer->PutSource_Mode(SM_File_DS);

    // Select the second video stream (index 1)
    m_pMediaPlayer->PutSource_VideoStreamIndex(1);

    // Start playback
    m_pMediaPlayer->Play();
}

// Don't forget to clean up
void CMyDlg::OnDestroy()
{
    if (m_pMediaPlayer != NULL)
    {
        m_pMediaPlayer->DestroyWindow();
        delete m_pMediaPlayer;
        m_pMediaPlayer = NULL;
    }

    CDialog::OnDestroy();
}
```

## VB6 Implementation

Here's how to implement multiple video stream playback in Visual Basic 6:

```
' Declare the MediaPlayer object at form level
Private WithEvents MediaPlayer1 As TVFMediaPlayer

Private Sub Form_Load()
    ' Create the MediaPlayer instance
    Set MediaPlayer1 = New TVFMediaPlayer

    ' Set container properties
    MediaPlayer1.CreateControl
    MediaPlayer1.Parent = Frame1 ' Assuming Frame1 is your container
    MediaPlayer1.Left = 0
    MediaPlayer1.Top = 0
    MediaPlayer1.Width = Frame1.ScaleWidth
    MediaPlayer1.Height = Frame1.ScaleHeight

    ' Configure initial state
    MediaPlayer1.DoubleBuffered = True
    MediaPlayer1.AutoPlay = False
End Sub

Private Sub btnPlay_Click()
    ' Set the file name - use full path for reliability
    MediaPlayer1.FilenameOrURL = "C:\Videos\multistream-video.mkv"

    ' Enable audio playback
    MediaPlayer1.Audio_Play = True
    MediaPlayer1.Audio_Volume = 85 ' Set volume to 85%

    ' Set the source mode to DirectShow
    MediaPlayer1.Source_Mode = SM_File_DS

    ' Select the second video stream (index 1)
    MediaPlayer1.Source_VideoStreamIndex = 1

    ' Start playback
    MediaPlayer1.Play
End Sub

Private Sub Form_Unload(Cancel As Integer)
    ' Clean up resources
    Set MediaPlayer1 = Nothing
End Sub
```

## Conclusion

The ability to play video files with multiple streams opens up numerous possibilities for creating rich, interactive multimedia experiences. The `TVFMediaPlayer` component provides a straightforward approach to implementing this functionality, with flexible options to suit different application requirements.

By following the techniques outlined in this guide, you can effectively incorporate multiple video stream support into your applications, enhancing user experience and expanding the capabilities of your multimedia projects.

---

Please get in touch with [support](https://support.visioforge.com/) if you need assistance with this functionality. Visit our [GitHub](https://github.com/visioforge/) page for additional code samples and implementation examples.

---END OF PAGE---


## Media Player SDK for Delphi - TVFMediaPlayer Guide
**URL:** https://www.visioforge.com/help/docs/delphi/mediaplayer/
**Description:** Embed video and audio playback in Delphi apps with TVFMediaPlayer, including playback controls, seeking, volume, frame capture, audio tracks, and fullscreen.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, DirectShow, Windows, VCL, Playback, Streaming
**API:** TVFMediaPlayer

# Media Player SDK for Delphi

[Media Player SDK Delphi](https://www.visioforge.com/all-in-one-media-framework)

This page covers using Media Player SDK with Delphi to build multimedia playback applications around the `TVFMediaPlayer` VCL component.

## Main Component

### TVFMediaPlayer

`TVFMediaPlayer` is a `TCustomPanel` descendant that exposes the full playback API. Drop it on a form at design time, or create it programmatically and attach it to a host panel.

```
var
  MediaPlayer1: TVFMediaPlayer;
begin
  MediaPlayer1 := TVFMediaPlayer.Create(Self);
  MediaPlayer1.Parent := Panel1;
  MediaPlayer1.Align := alClient;
end;
```

## Basic Playback

### Play a File

Set `FilenameOrURL` to the input path (or network URL), pick a source engine via `Source_Mode`, then call `Play`.

```
procedure TForm1.PlayFile(const Filename: WideString);
begin
  MediaPlayer1.FilenameOrURL := Filename;
  MediaPlayer1.Source_Mode := SM_File_FFMPEG; // SM_File_DS, SM_File_VLC, SM_File_LAV
  MediaPlayer1.Audio_Play := True;
  MediaPlayer1.Play;
end;
```

### Playback Controls

`Play` returns `True` on success. `Pause`, `Resume`, and `Stop` are procedures.

```
procedure TForm1.btnPlayClick(Sender: TObject);
begin
  MediaPlayer1.Play;
end;

procedure TForm1.btnPauseClick(Sender: TObject);
begin
  MediaPlayer1.Pause;
end;

procedure TForm1.btnResumeClick(Sender: TObject);
begin
  MediaPlayer1.Resume;
end;

procedure TForm1.btnStopClick(Sender: TObject);
begin
  MediaPlayer1.Stop;
end;
```

The current state is exposed by the read-only `Status` property (`ST_PLAY`, `ST_PAUSE`, `ST_FREE`).

```
if MediaPlayer1.Status = ST_PLAY then
  StatusBar1.SimpleText := 'Playing';
```

## Seeking

Position is expressed in milliseconds. `Position_Get_Time` returns the current position, `Position_Set_Time` seeks to an absolute position, and `Info_Video_DurationMSec(0)` returns the total duration of the first video stream.

```
procedure TForm1.SeekTo(PositionMs: Integer);
begin
  MediaPlayer1.Position_Set_Time(PositionMs);
end;

function TForm1.GetDurationMs: Integer;
begin
  Result := MediaPlayer1.Info_Video_DurationMSec(0);
end;

function TForm1.GetPositionMs: Integer;
begin
  Result := MediaPlayer1.Position_Get_Time;
end;
```

Frame-accurate seeking is also available via `Position_Get_Frame` and `Position_Set_Frame`.

## Audio Control

`TVFMediaPlayer` supports up to eight independent audio output streams. Volume and balance are addressed by zero-based stream index.

```
procedure TForm1.SetVolume(StreamIndex, Volume: Integer);
begin
  // Volume range: 0..100 (SDK scales internally)
  MediaPlayer1.Audio_Volume_Set(StreamIndex, Volume);
end;

function TForm1.GetVolume(StreamIndex: Integer): Integer;
begin
  Result := MediaPlayer1.Audio_Volume_Get(StreamIndex);
end;

procedure TForm1.SetBalance(StreamIndex, Balance: Integer);
begin
  // Balance range: -100 (left) to +100 (right)
  MediaPlayer1.Audio_Balance_Set(StreamIndex, Balance);
end;
```

To mute audio, set the volume to zero and restore the previous value on unmute, or toggle `Audio_Play` before starting playback.

```
procedure TForm1.Mute;
begin
  FSavedVolume := MediaPlayer1.Audio_Volume_Get(0);
  MediaPlayer1.Audio_Volume_Set(0, 0);
end;

procedure TForm1.Unmute;
begin
  MediaPlayer1.Audio_Volume_Set(0, FSavedVolume);
end;
```

## Playback Speed

`SetSpeed` accepts a multiplier between 0.01 and 100.0.

```
procedure TForm1.SetPlaybackSpeed(Rate: Double);
begin
  // Rate: 0.5 (half speed) to 2.0 (double speed)
  MediaPlayer1.SetSpeed(Rate);
end;
```

## Network URL Playback

The same `FilenameOrURL` property accepts network URLs. Pick the engine that best supports the protocol — `SM_File_VLC` and `SM_File_FFMPEG` cover the broadest set of streaming sources; `SM_MMS_WMV_DS` is dedicated to MMS/WMV streams.

```
procedure TForm1.PlayURL(const URL: WideString);
begin
  MediaPlayer1.FilenameOrURL := URL;
  MediaPlayer1.Source_Mode := SM_File_FFMPEG;
  MediaPlayer1.Play;
end;

procedure TForm1.PlayRTSP;
begin
  MediaPlayer1.FilenameOrURL := 'rtsp://192.168.1.100:554/stream';
  MediaPlayer1.Source_Mode := SM_File_FFMPEG;
  MediaPlayer1.Play;
end;

procedure TForm1.PlayHLS;
begin
  MediaPlayer1.FilenameOrURL := 'https://server.example.com/playlist.m3u8';
  MediaPlayer1.Source_Mode := SM_File_FFMPEG;
  MediaPlayer1.Play;
end;
```

## Frame Capture

`Frame_Save` writes the current frame to disk in the chosen image format. `Frame_GetCurrent` fills a `TBitmap` you supply.

```
procedure TForm1.CaptureFrame;
begin
  // Frame_Save(Filename, Format, Quality)
  MediaPlayer1.Frame_Save('C:\Snapshots\frame.jpg', IM_JPEG, 85);
end;

procedure TForm1.CaptureFrameToBitmap;
var
  Bitmap: TBitmap;
begin
  Bitmap := TBitmap.Create;
  try
    MediaPlayer1.Frame_GetCurrent(Bitmap);
    Image1.Picture.Assign(Bitmap);
  finally
    Bitmap.Free;
  end;
end;
```

Optionally resize the saved frame by configuring `Frame_Save_Resize`, `Frame_Save_Resize_Width`, and `Frame_Save_Resize_Height` before the call.

## Audio and Subtitle Tracks

The `Info_Audio_*` and `Info_Text_*` helpers enumerate streams discovered inside the source file. Audio streams are enabled or disabled individually with `Audio_SetStream`.

```
procedure TForm1.PopulateAudioTracks;
var
  i: Integer;
begin
  cbAudioTracks.Items.Clear;
  for i := 0 to MediaPlayer1.Info_Audio_Streams_Count - 1 do
    cbAudioTracks.Items.Add(MediaPlayer1.Info_Audio_Codec(i));
end;

procedure TForm1.SelectAudioTrack(Index: Integer);
var
  i: Integer;
begin
  // Enable the chosen track and disable the others
  for i := 0 to MediaPlayer1.Info_Audio_Streams_Count - 1 do
    MediaPlayer1.Audio_SetStream(i, i = Index);
end;

procedure TForm1.PopulateSubtitles;
var
  i: Integer;
begin
  cbSubtitles.Items.Clear;
  for i := 0 to MediaPlayer1.Info_Text_Streams_Count - 1 do
    cbSubtitles.Items.Add(MediaPlayer1.Info_Text_Name(i));
end;
```

`Info_Text_Language(i)` and `Info_Text_Codec(i)` are also available for richer subtitle metadata.

## Fullscreen Mode

Toggle fullscreen via the `Screen_VR_FullScreen` property. This works with the configured video renderer.

```
procedure TForm1.ToggleFullscreen;
begin
  MediaPlayer1.Screen_VR_FullScreen := not MediaPlayer1.Screen_VR_FullScreen;
end;
```

## Events

`TVFMediaPlayer` exposes three core playback events. `OnStart` and `OnStop` take no parameters; `OnError` receives the error text.

```
procedure TForm1.MediaPlayer1Start;
begin
  StatusBar1.SimpleText := 'Playing';
end;

procedure TForm1.MediaPlayer1Stop;
begin
  StatusBar1.SimpleText := 'Stopped';
end;

procedure TForm1.MediaPlayer1Error(ErrorText: WideString);
begin
  ShowMessage('Error: ' + ErrorText);
end;
```

To track position updates, poll `Position_Get_Time` from a `TTimer` while `Status = ST_PLAY`:

```
procedure TForm1.PositionTimerTick(Sender: TObject);
var
  Position, Duration: Integer;
begin
  if MediaPlayer1.Status <> ST_PLAY then
    Exit;

  Position := MediaPlayer1.Position_Get_Time;
  Duration := MediaPlayer1.Info_Video_DurationMSec(0);
  if Duration > 0 then
  begin
    TrackBar1.Max := Duration;
    TrackBar1.Position := Position;
  end;
  LabelPosition.Caption := Format('%d:%.2d / %d:%.2d',
    [Position div 60000, (Position div 1000) mod 60,
     Duration div 60000, (Duration div 1000) mod 60]);
end;
```

## Supported Formats

| Type | Formats |
| --- | --- |
| Video | MP4, AVI, MKV, MOV, WMV, FLV, WebM |
| Audio | MP3, AAC, FLAC, WAV, OGG, WMA |
| Streaming | RTSP, RTMP, HTTP, HLS, DASH |

Format coverage depends on the selected `Source_Mode` — the FFmpeg and VLC engines cover the broadest range out of the box; DirectShow (`SM_File_DS`) relies on the codecs installed on the system.

## Resources and Further Information

To explore the capabilities and usage of the `TVFMediaPlayer` library in more depth, see the following official resources:

- **Product page:** [VisioForge Media Player SDK](https://www.visioforge.com/all-in-one-media-framework)
- **API reference:** [Delphi Media Player API Reference](https://api.visioforge.org/delphi/media_player_sdk/index.html)
- **Changelog:** [Recent updates and fixes](changelog/)
- **Installation guide:** [Setting up the library](install/)
- **Deployment:** [Distributing your application](deployment/)
- **License agreement:** [End User License Agreement](../../eula/)

## Tutorials and Code Samples

Practical examples demonstrating how to implement specific features:

- [How to play a video file with multiple video streams?](file-multiple-video-streams/)
- *(More tutorials will be added here as they become available)*

---END OF PAGE---


## Install TVFMediaPlayer ActiveX Control in C++ Builder
**URL:** https://www.visioforge.com/help/docs/delphi/mediaplayer/install/builder/
**Description:** Install TVFMediaPlayer in C++ Builder - step-by-step guide for versions 5, 6, 2006, and later with prerequisites, setup, and troubleshooting.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, DirectShow, Windows, VCL, Playback, Streaming, MP4
**API:** TVFMediaPlayer

# Installing TVFMediaPlayer in C++ Builder

Welcome to the detailed guide for integrating the powerful TVFMediaPlayer library into your Embarcadero C++ Builder development environment. This document covers the installation process for legacy versions like C++ Builder 5 and 6, as well as modern versions from 2006 onwards. We will explore the necessary prerequisites, step-by-step installation procedures for different IDE versions, considerations for 32-bit (x86) and 64-bit (x64) architectures, and common troubleshooting steps.

## Introduction to TVFMediaPlayer and VisioForge Media Framework

TVFMediaPlayer is a versatile multimedia component developed by VisioForge. It's part of the larger VisioForge Media Framework, designed to provide developers with a robust set of tools for handling audio and video playback, capture, processing, and streaming within their applications. TVFMediaPlayer specifically focuses on playback capabilities, supporting a wide array of formats and offering extensive control over media rendering.

The component is delivered as an ActiveX control, making it easily integrable into environments that support COM technology, such as C++ Builder. Utilizing ActiveX allows for visual design-time integration and straightforward programmatic access to the player's features.

## Prerequisites

Before proceeding with the installation, ensure your development environment meets the following requirements:

1. **Supported C++ Builder Version:** You need a working installation of Embarcadero C++ Builder. This guide covers:
   - C++ Builder 5
   - C++ Builder 6
   - C++ Builder 2006
   - C++ Builder 2007, 2009, 2010, XE series (XE to XE8), 10.x series (Seattle, Berlin, Tokyo, Rio, Sydney), 11.x (Alexandria), and later versions. While the core process remains similar for newer versions, minor UI variations might exist.
2. **Operating System:** A compatible Windows operating system (Windows 7 or later, including Windows 8, 10, 11, and corresponding Server versions). Ensure your OS matches the target architecture (32-bit or 64-bit) of your C++ Builder projects.
3. **Administrative Privileges:** The installation of the VisioForge Media Framework and the registration of ActiveX controls typically require administrative privileges on your machine. Ensure you are running the installer and C++ Builder with sufficient permissions, especially if User Account Control (UAC) is enabled.
4. **Dependencies:** The VisioForge installer usually bundles necessary runtime dependencies (like specific DirectX or Media Foundation components). However, keeping your Windows system updated is generally recommended.

## Step 1: Download the All-in-One Media Framework

The TVFMediaPlayer component is distributed as part of the VisioForge All-in-One Media Framework SDK. You must download the correct version:

- **Target:** Download the **ActiveX** version of the SDK. Do not download the .NET or VCL versions, as they are intended for different development environments.
- **Source:** Obtain the installer directly from the official VisioForge website. Navigate to the [product page](https://www.visioforge.com/all-in-one-media-framework) and locate the download link for the ActiveX SDK. Ensure you are downloading the latest stable release unless you have specific requirements for an older version.

## Step 2: Install the VisioForge Media Framework

Once the download is complete, proceed with the installation:

1. **Locate the Installer:** Find the downloaded executable file.
2. **Run as Administrator:** Right-click the installer file and select "Run as administrator". This is crucial for ensuring the ActiveX controls are correctly registered in the Windows Registry.
3. **Follow the Wizard:** The installation wizard will guide you through the process.
   - Accept the license agreement.
   - Choose the installation directory (the default location is usually suitable).
   - Select the components to install. Ensure that the core framework and the MediaPlayer components are selected. Typically, the default selection is sufficient.
   - The installer will copy the necessary files (DLLs, AX files, etc.) and register the ActiveX controls on your system.
4. **Completion:** Once the installation finishes, click "Finish". The TVFMediaPlayer ActiveX control is now available on your system, ready to be imported into the C++ Builder IDE.

## Step 3: Import the TVFMediaPlayer ActiveX Control into C++ Builder

The method for importing the ActiveX control differs slightly between older and newer versions of C++ Builder.

### A. For C++ Builder 5 and 6

These classic versions have a straightforward import mechanism:

1. **Launch C++ Builder:** Open your C++ Builder 5 or 6 IDE.
2. **Open or Create a Project:** You can import the control into an existing project or a new one. The import process adds the component to the IDE's palette, making it available for all projects.
3. **Import ActiveX Control:** Navigate to the main menu and select `Component` → `Import ActiveX Controls...`.
4. **Select the Control:** A dialog box will appear listing all registered ActiveX controls on your system. Scroll through the list and find `VisioForge Media Player` (it might also be listed as `VFMediaPlayer Class` or similar, depending on registry details). Check the box next to it.
5. **Install:** Click the `Install...` button.
6. **Package Creation/Selection:** C++ Builder will prompt you to install the component into a package. You can choose an existing package (like `dclusr.dpk`) or create a new one. For simplicity, adding it to the default user package is often sufficient. Click `OK`.
7. **Confirmation:** A confirmation dialog will ask if you want to rebuild the package. Click `Yes`.
8. **Compilation and Installation:** C++ Builder will compile the package containing the wrapper code for the ActiveX control. Upon successful compilation, a message will confirm the installation. Click `OK`.
9. **Component Palette:** The TVFMediaPlayer component should now appear on the C++ Builder Component Palette, likely under a tab named `ActiveX` or `VisioForge`. You can now drag and drop it onto your forms like any other standard VCL component.

### B. For C++ Builder 2006 and Later (including XE, 10.x, 11.x)

Modern C++ Builder versions use a more structured component import process, typically involving creating or using a dedicated design-time package:

1. **Launch C++ Builder:** Open your C++ Builder IDE (2006 or newer).
2. **Create a New Package:** It's generally best practice to install third-party components into their own package.

   - Go to `File` → `New` → `Other...`.
   - In the `New Items` dialog, navigate to `C++Builder Projects` (or similar category) and select `Package`. Click `OK`.
3. **Import Component:** With the new package project active (e.g., `Package1.cbproj`), go to the main menu and select `Component` → `Import Component...`.
4. **Select Import Type:** In the `Import Component` wizard, choose the `Import ActiveX Control` option and click `Next >`.
5. **Select the Control:** Similar to the older versions, find `VisioForge Media Player` in the list of registered controls, select it, and click `Next >`.
6. **Component Details:** The wizard will display details about the control. You can typically accept the defaults for `Palette Page` (e.g., `ActiveX`), `Unit Dir Name`, and `Search Path`. Click `Next >`. *Note: Some developers prefer to create a dedicated "VisioForge" palette page.*
7. **Package Selection:** Choose the action `Add unit to <PackageName>.cbproj` (where `<PackageName>` is the name of the package you created in step 2). Click `Finish`.

   *Self-Correction: The screenshot reference 'mpbcb2006\_5.webp' seems misplaced in the original document's flow. It likely referred to saving or build options, which are handled next.*
8. **Save the Package:** C++ Builder will generate the necessary wrapper unit (e.g., `VFMediaPlayerLib_TLB.cpp` / `.h`). Save the package project (`.cbproj`) and the associated files when prompted. Choose a meaningful name and location for your package (e.g., `VisioForgeMediaPlayerPkg`).
9. **Compile and Install the Package:**

   - In the `Project Manager` pane, right-click on the package project's `.bpl` file (e.g., `VisioForgeMediaPlayerPkg.bpl`).
   - Select `Compile` to ensure the wrapper code builds correctly.
   - After a successful compilation, right-click the `.bpl` file again and select `Install`.
10. **Confirmation:** The IDE will install the package, making the TVFMediaPlayer component available on the specified Component Palette page (e.g., `ActiveX`).

## Step 4: Using the TVFMediaPlayer Component

After successful installation, you can use the component in your C++ Builder applications:

1. **Design-Time:** Open a form in the Form Designer. Locate the `TVFMediaPlayer` component on the Component Palette (usually on the `ActiveX` or `VisioForge` tab). Click and drop it onto your form. You can resize and position it as needed. Use the Object Inspector to configure its basic properties.
2. **Run-Time:** Access the component's methods and properties programmatically in your C++ code. For example, to load and play a file:

   ```
   // Assuming MediaPlayer1 is the name of the TVFMediaPlayer component on your form
   MediaPlayer1->FilenameOrURL = "C:\\path\\to\\your\\video.mp4";
   MediaPlayer1->Play();
   ```
3. **Event Handling:** Use the Object Inspector's `Events` tab to assign handlers to various player events (e.g., `OnPlay`, `OnStop`, `OnError`).

## Architecture Considerations (x86 vs. x64)

The VisioForge Media Framework provides both 32-bit (x86) and 64-bit (x64) versions of its libraries and ActiveX controls. It's crucial to match the component architecture with your C++ Builder project's target platform:

- **32-bit Projects (Win32 Target Platform):** Use the x86 version of the TVFMediaPlayer ActiveX control. The standard installation typically registers the x86 version correctly. When importing/installing the component package (especially in modern IDEs), ensure you are building and installing the package for the Win32 platform.
- **64-bit Projects (Win64 Target Platform):** Use the x64 version of the TVFMediaPlayer ActiveX control. The VisioForge installer should register both versions.
- **IDE Design-Time:** Importantly, the C++ Builder IDE itself is often a 32-bit application (even in recent versions). This means that for visual form design, the IDE needs to load the **x86** version of the ActiveX control.
- **Compilation/Runtime:** When you compile your project for the Win64 target platform, the application will require the **x64** version of the control at runtime.
- **Package Management:** In modern C++ Builder versions, you might need to: 1. Create and install a design-time package targeting Win32 (using the x86 control) for use in the IDE. 2. Ensure the corresponding runtime package (or necessary library files) for Win64 are correctly configured in your project's build settings and deployed with your 64-bit application. Consult the VisioForge documentation and C++ Builder's platform management features for specifics. Some developers manage separate packages for Win32 and Win64 targets.

**Recommendation:** While legacy C++ Builder versions are covered, VisioForge strongly recommends using modern versions of C++ Builder (XE series or later). These versions offer better support for 64-bit development, improved IDE features, and compatibility with current Windows operating systems and VisioForge SDK updates. Support for C++ Builder 5/6 might be limited.

## Troubleshooting Common Issues

- **Control Not Found in Import List:** Ensure the VisioForge Media Framework (ActiveX version) was installed correctly with administrative privileges. Try reinstalling the framework. Manually registering the `.ocx` control using `regsvr32` (run from an Administrator command prompt) might be necessary in rare cases (e.g., `regsvr32 "C:\Program Files\VisioForge\All-in-One Media Framework ActiveX\Redist\VisioForge_Media_Player.ocx"` - adjust path as needed, or use `Redist\x64` for the 64-bit control).
- **Package Installation Fails:** Check the build output for errors. Ensure the package project settings (paths, target platform) are correct. Verify you have write permissions to the C++ Builder library/package directories.
- **Component Works in IDE but Fails at Runtime (or vice-versa):** This often points to an architecture mismatch (x86 vs. x64). Review the "Architecture Considerations" section carefully. Ensure the correct version (32-bit or 64-bit) of the VisioForge runtime files is accessible to your compiled application. Deploy the required VisioForge redistributables with your application if necessary.
- **Errors During Playback (`CreateObject` fails, etc.):** Double-check that the `FilenameOrURL` property points to a valid, accessible media file. Ensure the necessary codecs for the media format are installed on the system (though VisioForge often includes internal decoders or utilizes Media Foundation/DirectShow). Check the VisioForge `OnError` event for specific error codes or messages.

## Conclusion

Integrating TVFMediaPlayer into C++ Builder provides a powerful solution for adding media playback to your applications. By following the appropriate steps for your IDE version, carefully managing x86/x64 architectures, and understanding the package system, you can successfully incorporate this component. Remember to consult the official VisioForge documentation and examples for more advanced usage and API details.

---

For further assistance or specific issues not covered here, please contact VisioForge [support](https://support.visioforge.com/). Explore more advanced examples and source code on the VisioForge [GitHub](https://github.com/visioforge/) repository.

---END OF PAGE---


## Install Media Player SDK in Delphi — 32/64-bit Setup
**URL:** https://www.visioforge.com/help/docs/delphi/mediaplayer/install/delphi/
**Description:** Install VisioForge Media Player SDK in Delphi 10.x-12.x — VCL/FMX components, package registration, library paths. Windows 32/64-bit supported.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Playback, MP4
**API:** TVFMediaPlayer

# Installing TVFMediaPlayer in Delphi

Welcome to the detailed guide for installing the VisioForge Media Player SDK, specifically the `TVFMediaPlayer` component, into your Delphi development environment. This guide covers installations for classic Delphi versions like Delphi 6 and 7, as well as modern versions from Delphi 2005 onwards, including the latest releases supporting 64-bit development.

## Understanding TVFMediaPlayer

`TVFMediaPlayer` is a powerful VCL component from VisioForge designed for seamless integration of video and audio playback capabilities into Delphi applications. It simplifies tasks such as playing various media formats, capturing snapshots, controlling playback speed, managing audio streams, and much more. Built upon a robust media engine, it offers high performance and extensive format support, making it a versatile choice for multimedia application development in Delphi.

This guide assumes you have a working installation of Embarcadero Delphi or a compatible older version (Borland Delphi).

## Step 1: Prerequisites and Downloading the Framework

Before proceeding with the installation, ensure your development environment meets the necessary prerequisites. Primarily, you need a licensed or trial version of Delphi installed on your Windows machine.

The `TVFMediaPlayer` component is distributed as part of the VisioForge All-in-One Media Framework. This framework bundles various VisioForge SDKs, providing a comprehensive toolkit for media handling.

1. **Navigate to the Product Page:** Open your web browser and go to the official VisioForge [All-in-One Media Framework product page](https://www.visioforge.com/all-in-one-media-framework).
2. **Select the Delphi Version:** Locate the download section specifically for Delphi. VisioForge typically offers versions tailored for different development platforms.
3. **Download:** Click the download link to obtain the installer executable (`.exe`) file. Save this file to a known location on your computer, such as your Downloads folder.

The downloaded file contains not only the `TVFMediaPlayer` component but also other related libraries, source code (if applicable based on licensing), necessary runtime files, and documentation.

## Step 2: Running the Installer

Once the download is complete, you need to run the installer to place the necessary SDK files onto your system.

1. **Locate the Installer:** Navigate to the folder where you saved the downloaded `.exe` file.
2. **Run as Administrator:** Right-click the installer file and select "Run as administrator". This is crucial because the installer needs to register components and potentially write to system directories, requiring elevated privileges.
3. **Follow On-Screen Instructions:** The installer wizard will guide you through the process. Typically, this involves:
   - Accepting the license agreement.
   - Choosing the installation directory (the default location is usually appropriate, e.g., `C:\Program Files\VisioForge\All-in-One Media Framework Delphi\`). Note this path, as you'll need it later.
   - Selecting components to install (ensure the Media Player SDK is selected).
   - Confirming the installation.
4. **Complete Installation:** Allow the installer to finish copying files and performing necessary setup tasks.

This process unpacks the SDK, including the pre-compiled units (`.dcu`), the component package (`.dpk` / `.dproj`), and the required runtime DLLs. The Delphi component ships as precompiled units — the package `.pas` source is not distributed.

## Step 3: Integrating with the Delphi IDE

After running the main installer, the next critical step is integrating the `TVFMediaPlayer` component into the Delphi IDE so you can use it visually in the form designer and reference its units in your code. The process differs slightly between older (Delphi 6/7) and newer (Delphi 2005+) versions.

**Important:** For all Delphi versions, it's recommended to run the Delphi IDE itself **as administrator** during the package installation process. This helps avoid potential permission issues when compiling and registering the component package.

### Installation in Delphi 6 / Delphi 7

These older versions require manual configuration of paths and package installation.

1. **Launch Delphi (as Administrator):** Start your Delphi 6 or Delphi 7 IDE with administrative privileges.
2. **Open IDE Options:** Go to the `Tools` menu and select `Environment Options`.
3. **Configure Library Path:**
   - Navigate to the `Library` tab.
   - In the `Library path` field, click the ellipsis (`...`) button.
   - Click the `Add` or `New` button (icon might vary) and browse to the package folder for your Delphi version — this is where the precompiled `.dcu` units live, e.g. `C:\Program Files\VisioForge\All-in-One Media Framework Delphi\Media Player\Packages\Delphi 7`. Add this path. This tells Delphi where to find the compiled units during compilation.
   - Click `OK` to close the path editor.
4. **Configure Browsing Path:**
   - While still in the `Library` tab, locate the `Browsing path` field (it might be combined or separate depending on the exact Delphi version/update).
   - Add the same package folder path here as well. This helps the IDE locate files for features like code completion and navigation.
   - Click `OK` to save the Environment Options.
5. **Open the Package File:**
   - Go to the `File` menu and select `Open...`.
   - Navigate to the `Media Player\Packages\Delphi 7` (or `Delphi 6`) subfolder within the VisioForge installation directory (e.g., `C:\Program Files\VisioForge\All-in-One Media Framework Delphi\Media Player\Packages\Delphi 7`).
   - Open the package file `VisioForge_Media_Player.dpk`. This is a single package — there are no separate runtime and design-time packages.
6. **Compile the Package:**
   - With `VisioForge_Media_Player.dpk` open as the active project in the Project Manager, click the `Compile` button (or use `Project -> Compile`). Resolve any compilation errors if they occur (though typically unnecessary with official packages).
7. **Install the Package:**
   - Once compiled successfully, click the `Install` button in the Project Manager.
8. **Confirmation:** You should see a confirmation message indicating that the package(s) were installed. The `TVFMediaPlayer` component (and potentially others from the SDK) should now appear on the Delphi component palette, likely under a "VisioForge" or similar category tab.

*Note on Architecture:* Delphi 6/7 are strictly 32-bit (x86) environments. Therefore, you will only be installing and using the 32-bit version of the `TVFMediaPlayer` component. The SDK might contain 64-bit files, but they are not applicable here.

### Installation in Delphi 2005 and Later (XE, 10.x, 11.x, 12.x)

Modern Delphi versions offer a more streamlined process and robust support for multiple platforms (Win32, Win64).

1. **Launch Delphi (as Administrator):** Start your Delphi IDE (e.g., Delphi 11 Alexandria, Delphi 12 Athens) with administrative privileges.
2. **Open IDE Options:** Go to `Tools -> Options`.
3. **Configure Library Path:**
   - In the Options dialog, navigate to `Language -> Delphi -> Library` (the exact path might slightly vary between versions).
   - Select the target platform for which you want to configure the path (e.g., `Windows 32-bit`, `Windows 64-bit`). It's recommended to configure both if you plan to build for both architectures.
   - Click the ellipsis (`...`) button next to the `Library path` field.
   - Add the path to the package folder that matches your Delphi version and platform, e.g. `C:\Program Files\VisioForge\All-in-One Media Framework Delphi\Media Player\Packages\Delphi 13` (Win32) or `C:\Program Files\VisioForge\All-in-One Media Framework Delphi\Media Player\Packages\Delphi 13 x64` (Win64). This folder holds the precompiled `.dcu` units.
   - Click `Add` and then `OK`. Repeat for the other platform if desired.
4. **Configure Browsing Path (Optional but Recommended):**
   - Under the same `Library` section, add that package folder path to the `Browsing path` field as well.
   - Click `OK` to save the Options.
5. **Open the Package File:**
   - Go to `File -> Open Project...`.
   - Navigate to the `Media Player\Packages` directory within the VisioForge installation. Find the subfolder corresponding to your Delphi version and platform (e.g., `Delphi XE11`, `Delphi XE12`, `Delphi 13`, or the matching `Delphi <version> x64` folder for 64-bit).
   - Open the package project `VisioForge_Media_Player.dproj` (or `VisioForge_Media_Player.dpk`). There is a single package that provides both runtime and design-time functionality.
6. **Compile and Install:**
   - In the Project Manager, right-click on the package project (`.dpk` file).
   - Select `Compile` from the context menu.
   - Once compiled successfully, right-click again and select `Install`.
7. **Confirmation:** Delphi will confirm the installation, and the components will appear on the palette.

*Note on Architecture:* Modern Delphi supports both 32-bit (Win32) and 64-bit (Win64) targets. The VisioForge SDK typically provides pre-compiled units (`.dcu`) for both. When you compile and install the package, Delphi usually handles registering it for the currently active platform. You can switch platforms in the Project Manager and rebuild/reinstall if necessary, although often the IDE handles this association correctly after the initial install.

## Step 4: Project Configuration

After installing the component package into the IDE, you need to ensure your individual *projects* can find the necessary VisioForge files at compile and runtime.

1. **Project Options:** Open your Delphi project (`.dpr` file). Go to `Project -> Options`.
2. **Library Path:** Navigate to `Delphi Compiler -> Search path` (or similar depending on version).
3. **Add SDK Path:** For each target platform (`Windows 32-bit`, `Windows 64-bit`) you intend to use:
   - Add the path to the package folder that matches the target platform, e.g. `C:\Program Files\VisioForge\All-in-One Media Framework Delphi\Media Player\Packages\Delphi 13` for Win32 and `C:\Program Files\VisioForge\All-in-One Media Framework Delphi\Media Player\Packages\Delphi 13 x64` for Win64. This ensures the compiler can find the precompiled `.dcu` units. Each Delphi version and platform has its own `Packages\Delphi <version>` (and `Delphi <version> x64`) folder.
4. **Save Changes:** Click `OK` or `Save` to apply the project options.

Setting the project search path correctly is crucial. If the compiler complains about not finding units like `MediaPlayerMain` or `MediaPlayerTypes`, incorrect or missing search paths are the most common cause.

## Step 5: Verification

To confirm the installation was successful:

1. **Check Component Palette:** Look for the "VisioForge" tab (or similar) on the component palette in the Delphi IDE. You should see the `TVFMediaPlayer` icon.
2. **Create a Test Application:**

   - Create a new VCL Forms Application (`File -> New -> VCL Forms Application - Delphi`).
   - Drag and drop the `TVFMediaPlayer` component from the palette onto the main form.
   - If the component appears on the form without errors, the design-time installation is likely correct.
   - Add a simple button. In its `OnClick` event handler, add a basic line of code to interact with the player, for example:

     ```
     procedure TForm1.Button1Click(Sender: TObject);
     begin
       // Ensure VFMediaPlayer1 is the name of your component instance
       VFMediaPlayer1.FilenameOrURL := 'C:\path\to\your\test_video.mp4'; // Replace with an actual media file path
       VFMediaPlayer1.Play();
     end;
     ```
   - Compile the project (`Project -> Compile`). If it compiles without "File not found" errors related to VisioForge units, the path configuration is likely correct.
   - Run the application. If it runs and you can play the media file using the button, the runtime setup is working.

## Common Installation Problems and Troubleshooting

While the process is generally straightforward, occasional issues can arise:

- **IDE Permissions:** Forgetting to run the Delphi IDE as administrator during package installation can lead to errors writing to registry or system folders, preventing component registration. **Solution:** Close Delphi, restart it as administrator, and try the package installation steps again.
- **Path Configuration Errors:** Incorrect paths in either the IDE `Library Path` or the project's `Search Path` are common. **Solution:** Double-check that the paths point *exactly* to the VisioForge SDK's `Packages\Delphi <version>` (or `Delphi <version> x64`) directory containing the `.dcu` units. Ensure paths are correct for the specific target platform (Win32/Win64).
- **Package Compilation Errors:** Sometimes, conflicts with other installed packages or issues within the package source itself can cause compilation failures. **Solution:** Ensure you are using the correct package version for your specific Delphi version. Consult VisioForge support or forums if errors persist.
- **64-bit Specific Issues:** Installing packages for the 64-bit platform can sometimes present unique challenges, especially in older Delphi versions that first introduced Win64 support. Refer to the linked article [Delphi 64-bit package installation problem](../../../general/install-64bit/) for specific known issues and workarounds.
- **`.otares` File Issues:** Some Delphi versions utilize `.otares` files for resources. Problems during package installation related to these files can occur. See the linked article [Delphi package installation problem with .otares](../../../general/install-otares/).
- **Missing Runtime DLLs:** The `TVFMediaPlayer` often relies on underlying DLLs (e.g., FFmpeg components) for its functionality. While the main installer usually handles these, ensure they are correctly placed either in your application's output directory, a directory in the system PATH, or the System32/SysWOW64 folders as appropriate. Deployment requires distributing these necessary DLLs with your application. Check the VisioForge documentation for a list of required runtime files.

## Further Steps and Resources

With `TVFMediaPlayer` successfully installed, you can now explore its extensive features.

- **Explore Properties and Events:** Use the Delphi Object Inspector to examine the numerous properties and events available for the `TVFMediaPlayer` component.
- **Consult Documentation:** Refer to the official VisioForge documentation installed with the SDK or available online for detailed API references and usage examples.
- **Code Samples:** Visit the VisioForge [GitHub repository](https://github.com/visioforge/) to find demo projects and code snippets showcasing various functionalities.
- **Seek Support:** If you encounter persistent issues or have specific questions not covered here, contact [VisioForge support](https://support.visioforge.com/) for assistance.

---

Please get in touch with [support](https://support.visioforge.com/) to get help with this tutorial. Visit our [GitHub](https://github.com/visioforge/) page to get more code samples.

---END OF PAGE---


## TVFMediaPlayer Installation Guide for Delphi and ActiveX
**URL:** https://www.visioforge.com/help/docs/delphi/mediaplayer/install/
**Description:** Install TVFMediaPlayer in Delphi, C++ Builder, Visual Basic 6, Visual Studio, and ActiveX environments with detailed setup instructions.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Playback, Streaming
**API:** TVFMediaPlayer

# Install the TVFMediaPlayer Library

Welcome to the detailed installation guide for the VisioForge TVFMediaPlayer library, a core component of the powerful All-in-One Media Framework. This guide provides comprehensive steps for installing the library across various Integrated Development Environments (IDEs), ensuring you can leverage its rich media playback capabilities effectively in your projects.

The TVFMediaPlayer library offers developers robust tools for integrating audio and video playback, processing, and streaming functionalities into their applications. It is available in two primary forms to cater to different development ecosystems:

1. **Native Delphi Package:** Optimized specifically for Embarcadero Delphi developers, offering seamless integration, design-time support, and leveraging the full potential of the VCL framework.
2. **ActiveX Control (OCX):** Designed for broad compatibility, allowing integration into environments that support ActiveX technology, such as C++ Builder, Microsoft Visual Basic 6 (VB6), Microsoft Visual Studio (for C#, VB.NET, C++ MFC projects), and other ActiveX containers.

This dual availability ensures that whether you are working within the Delphi ecosystem or utilizing other popular development tools, you can harness the power of TVFMediaPlayer.

## Before You Begin: System Requirements and Prerequisites

Before proceeding with the installation, ensure your development environment meets the necessary requirements:

- **Operating System:** Windows 7, 8, 8.1, 10, 11, or Windows Server 2012 R2 and newer (both x86 and x64 versions are supported).
- **Development Environment:** A compatible IDE such as:
  - Embarcadero Delphi (refer to specific framework version for compatible Delphi releases, typically XE2 or newer).
  - Embarcadero C++ Builder (refer to specific framework version for compatibility).
  - Microsoft Visual Studio 2010 or newer (for C#, VB.NET, C++ MFC development using ActiveX).
  - Microsoft Visual Basic 6 (requires the IDE installed).
  - Any other IDE or development tool capable of hosting ActiveX controls.
- **Dependencies:**
  - **DirectX:** Microsoft DirectX 9 or later is generally required. While modern Windows versions include compatible DirectX runtimes, ensure they are up-to-date.
  - **.NET Framework (for .NET usage):** If using the ActiveX control within .NET applications (C#, VB.NET), ensure the appropriate .NET Framework version targeted by your project is installed.
- **Administrator Privileges:** Running the installer typically requires administrator rights to register components and write to system directories.

## Step-by-Step General Installation Process

The core installation process involves downloading the All-in-One Media Framework installer and running it. Follow these steps carefully:

1. **Download the Framework:**

   - Navigate to the official [All-in-One Media Framework product page](https://www.visioforge.com/all-in-one-media-framework) on the VisioForge website.
   - Locate the downloads section. You might find different versions (e.g., Trial, Full) or builds. Download the latest stable release suitable for your needs. Pay attention to whether you need the Delphi-specific package installer or the general ActiveX installer if they are provided separately (often, one installer contains both).
   - Save the installer executable (`.exe`) file to a convenient location on your computer.
2. **Run the Installer:**

   - Locate the downloaded setup file (e.g., `visioforge_media_framework_activex_full.exe`, or the Delphi edition installer).
   - Right-click the file and select "Run as administrator" to ensure necessary permissions.
   - If prompted by User Account Control (UAC), confirm that you want to allow the installer to make changes to your device.
3. **Follow the Installation Wizard:**

   - **Welcome Screen:** The installer will launch, typically starting with a welcome message. Click "Next" to proceed.
   - **License Agreement:** Read the End-User License Agreement (EULA) carefully. You must accept the terms to continue the installation. Select the appropriate option and click "Next".
   - **Select Destination Location:** Choose the directory where the framework files, examples, and documentation will be installed. The default location is usually `C:\Program Files\VisioForge\All-in-One Media Framework ActiveX\` (or `C:\Program Files\VisioForge\All-in-One Media Framework Delphi\` for the Delphi edition). You can browse for a different path if needed. Click "Next".
   - **Select Components (If Applicable):** Some installers might allow you to choose which components to install (e.g., specific framework features, documentation, examples for different languages). Ensure the core Media Player components and any relevant examples (Delphi, C#, VB.NET, C++, VB6) are selected. Click "Next".
   - **Select Start Menu Folder:** Choose the name for the Start Menu folder where shortcuts will be created. Click "Next".
   - **Ready to Install:** Review your selected options. If everything is correct, click "Install" to begin the file copying and system registration process.
   - **Installation Progress:** The wizard will show the progress of the installation. This may take a few minutes. During this phase, the necessary DLLs and OCX files are copied, and the ActiveX control is registered in the Windows Registry.
   - **Completion:** Once the installation is finished, you will see a completion screen. It might offer options to view documentation or launch an example project. Click "Finish" to exit the wizard.
4. **Post-Installation Verification:**

   - Navigate to the installation directory you selected (e.g., `C:\Program Files\VisioForge\All-in-One Media Framework ActiveX\`).
   - Verify that the core library files (`.dll`, `.ocx`), documentation (`.chm` or `Docs` folder), and example projects (`Examples` folder) are present.
   - Check the Start Menu folder for shortcuts to documentation and examples.
   - It's highly recommended to try compiling and running one of the provided sample projects for your specific IDE to confirm the installation was successful and the components are correctly registered and accessible.

## IDE-Specific Integration

After the general installation, you need to integrate the TVFMediaPlayer library into your chosen development environment.

### Delphi (Native Packages)

Using the native Delphi packages provides the best experience for Delphi developers, including design-time component integration.

- **Detailed Guide:** For comprehensive instructions specific to Delphi, including adding the library path and installing the component package (`VisioForge_Media_Player.dpk`), please refer to the dedicated **[Delphi Installation Guide](delphi/)**.
- **Key Benefits:** Direct component palette access, property inspectors, event handlers integrated within the IDE, and optimized performance for VCL applications.

### ActiveX Integration (C++ Builder, VB6, Visual Studio, etc.)

If you are not using Delphi or prefer the ActiveX approach, you'll need to add the `VisioForge_Media_Player.ocx` control to your project.

#### C++ Builder

Integrating the ActiveX control in C++ Builder involves importing it into the IDE.

- **Detailed Guide:** Refer to the **[C++ Builder Installation Guide](builder/)** for step-by-step instructions on importing the ActiveX control, which typically involves using the IDE's "Import Component" or "Import ActiveX Control" feature to generate necessary wrapper code.
- **Process Overview:** This usually involves navigating `Component -> Import Component...`, selecting "Import ActiveX Control", finding the "VisioForge Media Player SDK" (or similar name) in the list of registered controls, and letting the IDE generate the corresponding C++ wrapper classes that allow you to interact with the control.

#### Visual Basic 6 (VB6)

VB6 relies heavily on ActiveX technology, making integration straightforward.

1. **Open Project:** Launch Visual Basic 6 and open your existing project or create a new one.
2. **Access Components Dialog:** Go to the main menu and select `Project -> Components...`. This will open the Components dialog box, listing registered controls.
3. **Locate and Select Control:** Scroll through the list under the "Controls" tab. Look for an entry like "VisioForge Media Player SDK Control" or similar (the exact name might vary slightly depending on the version). Check the box next to it.
4. **Add via Browse (If Not Listed):** If the control is not listed (perhaps due to a registration issue), click the "Browse..." button. Navigate to the VisioForge installation directory (the `Redist` subfolder containing `VisioForge_Media_Player_VB6.ocx`) and select the `.ocx` file. Click "Open". This should register and add the control to the list. Ensure its checkbox is ticked.
5. **Confirm:** Click "OK" or "Apply" in the Components dialog.
6. **Use Control:** The TVFMediaPlayer icon should now appear in your VB6 Toolbox. You can click and drag it onto your forms to use it visually. You can then interact with its properties and methods via code.

#### Visual Studio (C#, VB.NET, C++ MFC)

Visual Studio manages ActiveX controls through the COM Interoperability layer.

1. **Open Project:** Launch Visual Studio and open your Windows Forms (C# or VB.NET), WPF, or MFC project.
2. **Open Toolbox:** Ensure the Toolbox is visible (`View -> Toolbox`).
3. **Add Control to Toolbox:**
   - Right-click inside the Toolbox, preferably within a relevant tab like "General" or "All Windows Forms", or create a new tab (e.g., "VisioForge").
   - Select "Choose Items...".
   - Wait for the "Choose Toolbox Items" dialog to load. This can sometimes take a moment as it scans registered components.
   - Navigate to the "COM Components" tab.
   - Scroll through the list and look for "VisioForge Media Player SDK Control" or a similar name. Check the box next to it.
   - **Add via Browse (If Not Listed):** If you cannot find it, click the "Browse..." button. Navigate to the VisioForge installation directory (the `Redist` subfolder for 32-bit, or `Redist\x64` for 64-bit) and select the `VisioForge_Media_Player.ocx` file. Click "Open". This should add it to the list; make sure its checkbox is now selected.
   - Click "OK".
4. **Use Control:** The TVFMediaPlayer control icon will now be available in your Visual Studio Toolbox. Drag and drop it onto your form (Windows Forms) or use it programmatically (WPF, MFC). Visual Studio will automatically generate the necessary Interop assemblies (wrappers) to allow managed code (.NET) or C++ to interact with the COM-based ActiveX control.

## Troubleshooting Common Installation Issues

Encountering problems during installation? Here are some common issues and solutions:

- **Control Not Registered / Not Appearing in IDE:**
  - Ensure the installer was run with administrator privileges.
  - The installer registers the control automatically, but you can re-register it manually. Open an **Administrator Command Prompt**, navigate to the directory containing the OCX (e.g., `cd "C:\Program Files\VisioForge\All-in-One Media Framework ActiveX\Redist"` for 32-bit, or `cd "C:\Program Files\VisioForge\All-in-One Media Framework ActiveX\Redist\x64"` for 64-bit), and run `regsvr32 VisioForge_Media_Player.ocx`. A success message should appear.
  - Check for conflicts with other media libraries or older VisioForge versions. Consider uninstalling previous versions first.
- **Installation Fails or Rolls Back:**
  - Ensure you meet all system requirements, including DirectX and .NET versions.
  - Temporarily disable antivirus software, which might interfere with the registration process. Remember to re-enable it afterward.
  - Check for sufficient disk space on the target drive.
- **Issues in Specific IDEs:**
  - **Delphi:** Ensure the library path is correctly added in `Tools -> Options -> Library Path` and that the correct `BPL` files are installed. Rebuilding packages might help.
  - **Visual Studio:** Delete the `obj` and `bin` folders in your project, delete any existing Interop assemblies related to VisioForge, remove the control reference, restart Visual Studio, and try adding the control again. Ensure your project targets a compatible .NET Framework version if applicable.

## Updating the Framework

To update to a newer version of the All-in-One Media Framework:

1. **Check for Compatibility:** Review the release notes for the new version to understand changes and potential compatibility issues with your existing projects.
2. **Backup Projects:** Always back up your projects before updating a major library dependency.
3. **Uninstall Existing Version (Recommended):** It's generally best practice to uninstall the current version via the Windows Control Panel ("Add or Remove Programs" or "Apps & features") before installing the new one. This helps prevent file conflicts or registration issues.
4. **Download and Install:** Download the new version's installer and follow the standard installation procedure outlined earlier in this guide.
5. **Recompile Projects:** Open your projects in their respective IDEs. You may need to remove and re-add references or components if the underlying interfaces have changed significantly (though this is less common with minor updates). Recompile your entire project.
6. **Test Thoroughly:** Test your application extensively to ensure all media functionalities work as expected with the updated library.

## Uninstallation

To remove the TVFMediaPlayer library and the All-in-One Media Framework:

1. **Close IDEs:** Ensure all development environments that might be using the library files are closed.
2. **Use Windows Uninstaller:**
   - Go to the Windows Control Panel or Settings app.
   - Navigate to "Programs and Features" or "Apps & features".
   - Locate "VisioForge Media Framework" (or similar name) in the list of installed programs.
   - Select it and click "Uninstall".
   - Follow the prompts in the uninstallation wizard. This process should remove the installed files and attempt to unregister the ActiveX control.
3. **Manual Cleanup (Optional):** In some rare cases, or if you want to ensure a complete removal, you might manually check and delete:
   - The main installation directory (e.g., `C:\Program Files\VisioForge\`).
   - Any remaining configuration files or registry entries (advanced users only, proceed with caution).
   - Interop assemblies generated within your project folders (`obj`, `bin`).

## Licensing and Activation

The All-in-One Media Framework typically operates under a commercial license, often with a trial period.

- **Trial Version:** The downloaded installer might initially function as a trial, which may have limitations (e.g., nag screens, time limits, restricted features).
- **Purchasing a License:** To unlock the full capabilities and use the framework in production applications, you must purchase a license from the VisioForge website.
- **Activation:** After purchase, you will usually receive a license key or instructions on how to activate the software. This might involve entering the key into a specific property of the control at runtime or using a license activation tool provided by VisioForge. Refer to the documentation accompanying your purchased license for exact details.

## Getting Support

If you encounter issues not covered here or need further assistance:

- **Official Documentation:** Check the `Docs` folder in your installation directory or the online documentation on the VisioForge website. The `CHM` help file often contains detailed API references and usage examples.
- **Sample Projects:** Explore the example projects provided for your IDE. They demonstrate common use cases and correct implementation techniques.
- **VisioForge Support:** Visit the support section on the VisioForge website. This may include forums, a knowledge base, or direct contact options for licensed users.

## Conclusion

Installing the TVFMediaPlayer library, whether as a native Delphi package or an ActiveX control, is a straightforward process when following these detailed steps. By ensuring system requirements are met, carefully executing the installation wizard, and correctly integrating the components into your chosen IDE, you can quickly begin developing powerful multimedia applications. Remember to consult the specific IDE guides (Delphi, C++ Builder) linked herein and the official documentation for deeper insights and advanced configurations. With the framework successfully installed, you are well-equipped to explore the extensive features of the VisioForge All-in-One Media Framework.

---END OF PAGE---


## Installing TVFMediaPlayer Library in Visual Basic 6
**URL:** https://www.visioforge.com/help/docs/delphi/mediaplayer/install/visual-basic-6/
**Description:** Install and integrate TVFMediaPlayer in VB6 - ActiveX setup, 32-bit considerations, basic playback implementation, and deployment practices.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, DirectShow, Windows, VCL, Playback, Streaming, Screen Capture
**API:** TVFMediaPlayer

# Integrating TVFMediaPlayer with Visual Basic 6: A Comprehensive Guide

Microsoft Visual Basic 6 (VB6), despite its age, remains a relevant platform for many legacy applications. Its simplicity and rapid application development (RAD) capabilities made it incredibly popular. One way to extend the functionality of VB6 applications, particularly in multimedia processing, is by leveraging ActiveX controls. The TVFMediaPlayer library, developed by VisioForge, offers a powerful suite of multimedia features accessible to VB6 developers through its ActiveX interface.

This guide provides a comprehensive walkthrough for installing, configuring, and utilizing the TVFMediaPlayer library within a Visual Basic 6 project. We will cover the nuances of working with ActiveX in VB6, address the inherent 32-bit limitations, and provide practical steps for integration and basic usage.

## Understanding ActiveX and VB6 Compatibility

ActiveX controls are reusable software components based on Microsoft's Component Object Model (COM) technology. They allow developers to add specific functionalities to applications without writing the underlying code from scratch. Visual Basic 6 has excellent built-in support for ActiveX, enabling developers to easily incorporate third-party controls like TVFMediaPlayer into their projects via a graphical interface.

This seamless integration means that VB6 developers can access the advanced multimedia capabilities of the VisioForge library—such as video playback, audio manipulation, screen capture, and network streaming—directly within the familiar VB6 IDE.

### The 32-bit Constraint

A crucial point to understand is that Visual Basic 6 is strictly a 32-bit development environment. It was created during an era when 64-bit computing was not mainstream for desktop applications. Consequently, VB6 cannot create or directly interact with 64-bit components or processes.

This limitation dictates that only the 32-bit (x86) version of the TVFMediaPlayer ActiveX control can be used with VB6. While modern systems are predominantly 64-bit, Windows maintains compatibility layers (WoW64 - Windows 32-bit on Windows 64-bit) that allow 32-bit applications like those built with VB6, and the 32-bit ActiveX controls they use, to run correctly on 64-bit operating systems.

Despite being confined to a 32-bit architecture, the TVFMediaPlayer library is optimized to deliver robust and reliable performance. Developers can confidently build sophisticated multimedia applications in VB6, leveraging the full feature set provided by the 32-bit control.

## Prerequisites

Before you begin the installation process, ensure you have the following:

1. **Microsoft Visual Basic 6:** A working installation of the VB6 IDE is required. This includes the necessary service packs (typically SP6).
2. **SDK:** Download the latest version of the SDK that includes the ActiveX components. Ensure you download the installer appropriate for your needs (often a combined x86/x64 installer, but only the x86 components will be registered for VB6 use).
3. **Administrator Privileges:** Installing the SDK and registering the ActiveX control typically requires administrator rights on the development machine.

## Step-by-Step Installation and Integration

Follow these steps to integrate the TVFMediaPlayer control into your Visual Basic 6 project:

### **Step 1: Install the TVFMediaPlayer control**

Run the downloaded VisioForge SDK installer. Follow the on-screen prompts. The installer will copy the necessary library files (`.ocx`, `.dll`) to your system and attempt to register the ActiveX control in the Windows Registry. Pay attention to the installation directory, though typically the registration process makes the control available system-wide.

### **Step 2: Create or Open a VB6 Project**

Launch the Visual Basic 6 IDE. You can either start a new Standard EXE project or open an existing one where you wish to add multimedia capabilities.

*Caption: Creating a new Standard EXE project in Visual Basic 6.*

### **Step 3: Add the TVFMediaPlayer Component**

To make the ActiveX control available in your project's Toolbox, you need to add it through the "Components" dialog.

- Go to the `Project` menu and select `Components...`. Alternatively, right-click on the Toolbox and choose `Components...`.

*Caption: Accessing the Components dialog from the Project menu.*

- The "Components" dialog lists all registered ActiveX controls on your system. Scroll down the list under the "Controls" tab.
- Locate and check the box next to "VisioForge Media Player" (the exact name might vary slightly depending on the installed version).

*Caption: Selecting the 'VisioForge Media Player' control in the Components dialog.*

- Click `OK` or `Apply`.

### **Step 4: Use the Control in Your Project**

After adding the component, its icon will appear in the VB6 Toolbox.

*Caption: The TVFMediaPlayer control added to the Visual Basic 6 Toolbox.*

You can now select the TVFMediaPlayer icon from the Toolbox and draw it onto any form in your project, just like any standard VB6 control (e.g., Button, TextBox). This creates an instance of the media player object on your form. You can resize and position it as needed using the form designer.

#### **Basic Usage: Controlling the Player**

Once the TVFMediaPlayer control (`VFMediaPlayer1` by default, if it's the first one added) is on your form, you can interact with it programmatically using VB6 code.

## Deployment Considerations

When you distribute your VB6 application that uses the TVFMediaPlayer control, you must ensure the necessary runtime files are included and correctly registered on the target user's machine.

1. **Required Files:** Identify the specific `.ocx` file for the TVFMediaPlayer control and any dependent `.dll` files provided by the VisioForge SDK. These files need to be shipped with your application installer.
2. **Registration:** The ActiveX control (`.ocx` file) must be registered in the Windows Registry on the target machine. Standard installer tools (like Inno Setup, InstallShield, or even older VB6 packaging tools) usually provide mechanisms to register ActiveX controls during installation. Alternatively, the `regsvr32.exe` command-line utility can be used manually or via a script:

   ```
   regsvr32.exe "C:\\Program Files (x86)\\YourApp\\VisioForge_Media_Player_VB6.ocx"
   ```

   Remember to use the correct path and run the command with administrator privileges. Since it's a 32-bit control, even on a 64-bit system, you typically use the `regsvr32.exe` found in the `C:\Windows\SysWOW64` directory, although the system often handles this redirection automatically. 3. **Licensing:** Ensure you comply with the VisioForge licensing terms for deployment. Some versions might require a runtime license key to be set programmatically within your application.

## Troubleshooting Common Issues

- **Control Not Appearing in Components:**
- Ensure the VisioForge SDK was installed correctly with administrator rights.
- Try manually registering the `.ocx` file using `regsvr32.exe` from an elevated command prompt.
- Verify you are looking for the correct name in the Components list.
- **"Runtime Error '429': ActiveX component can't create object":**
- This usually indicates the control is not properly registered on the machine where the application is running. Re-register the `.ocx` file.
- Ensure all dependent DLLs are present in the application's directory or a system path.
- **Playback Issues (No Video/Audio, Errors):**
- Verify the path to the media file is correct and accessible.
- Ensure necessary codecs are installed on the system (though TVFMediaPlayer often includes internal decoders or uses DirectShow/Media Foundation).
- Check the VisioForge documentation for specific error codes or properties that might give more detail.
- Implement proper error handling around player methods (`Play`, `Stop`, property setting) to diagnose issues.

## Beyond VB6: Modernization

While TVFMediaPlayer provides a bridge for adding modern multimedia features to legacy VB6 applications, organizations should also consider long-term strategies. Migrating VB6 applications to newer platforms like .NET (using C# or VB.NET) or web-based technologies can offer significant advantages in terms of performance, security, maintainability, and access to the latest development tools and libraries. VisioForge also offers .NET-native versions of its libraries, which would be the preferred choice in a modernized application.

## Conclusion

The TVFMediaPlayer library, through its ActiveX control, offers a powerful and accessible way for Visual Basic 6 developers to incorporate advanced multimedia functionalities into their applications. By understanding the installation process, the 32-bit limitations, basic control usage, and deployment requirements outlined in this guide, developers can effectively leverage VisioForge technology to enhance their VB6 projects. While VB6 is a legacy platform, tools like TVFMediaPlayer help extend its useful life for specific application needs.

---

For further assistance or more complex scenarios, please get in touch with [VisioForge support](https://support.visioforge.com/). Explore the extensive code samples available on the VisioForge [GitHub repository](https://github.com/visioforge/) for more advanced examples and techniques.

---END OF PAGE---


## Add ActiveX Media Player to Visual Studio C++/C#/VB.NET
**URL:** https://www.visioforge.com/help/docs/delphi/mediaplayer/install/visual-studio/
**Description:** Import TVFMediaPlayer ActiveX control into Visual Studio 2010+ projects. Step-by-step COM wrapper generation, toolbox setup, and .NET SDK migration guide.
**Tags:** Media Player SDK, All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Playback, MP4, AVI, MOV, WMV, C#
**API:** TVFMediaPlayer

# Installing TVFMediaPlayer ActiveX in Visual Studio 2010 and Later

This guide provides detailed instructions for integrating the VisioForge Media Player (`TVFMediaPlayer`) ActiveX control into your Microsoft Visual Studio projects (version 2010 and newer). We will cover the necessary steps for C++, C#, and Visual Basic .NET environments, explain the underlying mechanisms, and discuss important considerations, including why migrating to the native .NET SDK is highly recommended for modern development.

## Understanding ActiveX and its Role in Modern Development

ActiveX, a technology developed by Microsoft, allows software components (controls) to interact with one another regardless of the language they were originally written in. It's based on the Component Object Model (COM). In the context of Visual Studio, ActiveX controls can be embedded within application forms to provide specific functionalities, such as media playback in the case of `TVFMediaPlayer`.

While historically significant, ActiveX usage has declined, especially within the .NET ecosystem. Modern .NET frameworks offer more integrated, robust, and secure ways to incorporate UI components and functionality. However, legacy applications or specific interoperability scenarios might still necessitate the use of ActiveX controls.

When you use an ActiveX control in a .NET project (C# or VB.Net), Visual Studio doesn't interact with it directly. Instead, it automatically generates **Runtime Callable Wrappers (RCW)**. These wrappers are essentially .NET assemblies that act as intermediaries, translating .NET calls into COM calls that the ActiveX control understands, and vice versa. This process allows managed (.NET) code to utilize unmanaged (COM/ActiveX) components.

## Prerequisites

Before you begin, ensure you have the following:

1. **Microsoft Visual Studio:** Version 2010 or a later edition installed.
2. **TVFMediaPlayer ActiveX Control:** The VisioForge Media Player ActiveX control must be properly installed and registered on your development machine. You can typically download this from the VisioForge website or distributor. **Crucially**, you might need both the 32-bit (x86) and 64-bit (x64) versions registered, even if you are only developing a 64-bit application. Visual Studio's designer often runs as a 32-bit process and requires the x86 version to display the control visually during design time. The runtime will use the version corresponding to your project's target architecture (x86 or x64).
3. **Project:** An existing or new C++, C#, or VB.NET project where you intend to use the media player.

## Step-by-Step Installation in Visual Studio

The process involves adding the `TVFMediaPlayer` control to the Visual Studio Toolbox, which then allows you to drag and drop it onto your application's forms or windows.

### **Step 1: Create or Open Your Project**

Launch Visual Studio and create a new project or open an existing one. The example screenshots below use a C# Windows Forms application, but the steps are analogous for C++ (MFC, perhaps) and VB.NET WinForms.

- For C# WinForms: `File -> New -> Project -> Visual C# -> Windows Forms App (.NET Framework)`
- For VB.NET WinForms: `File -> New -> Project -> Visual Basic -> Windows Forms App (.NET Framework)`
- For C++ MFC: `File -> New -> Project -> Visual C++ -> MFC/ATL -> MFC App`

### **Step 2: Open the Toolbox**

If the Toolbox is not visible, you can open it via the `View` menu (`View -> Toolbox` or `Ctrl+Alt+X`). The Toolbox contains standard UI controls and components.

### **Step 3: Add the ActiveX Control to the Toolbox**

To make the `TVFMediaPlayer` control available, you need to add it to the Toolbox:

1. Right-click within an empty area of the Toolbox (e.g., under the "General" tab or create a new tab).
2. Select "Choose Items..." from the context menu.

### **Step 4: Select the TVFMediaPlayer Control**

1. The "Choose Toolbox Items" dialog will appear. Navigate to the "COM Components" tab. This tab lists all registered ActiveX controls on your system.
2. Scroll through the list or use the filter box to find the "VisioForge Media Player" control (the exact name might vary slightly based on the installed version).
3. Check the checkbox next to the control's name.
4. Click "OK".

Visual Studio will now add the control to your Toolbox and, if you are in a C# or VB.Net project, it will generate the necessary RCW assemblies (often named `AxInterop.VisioForgeMediaPlayerLib.dll` and `Interop.VisioForgeMediaPlayerLib.dll`) and add references to them in your project.

### **Step 5: Add the Control to Your Form**

1. Locate the newly added "VisioForge Media Player" icon in the Toolbox.
2. Click and drag the icon onto your application's form or design surface.

An instance of the `TVFMediaPlayer` control will appear on your form. You can resize and position it as needed using the designer.

### **Step 6: Interacting with the Control (Code)**

You can now interact with the media player control programmatically through its properties, methods, and events. Select the control in the designer, and use the Properties window (`F4`) to configure its appearance and basic behavior.

To control playback, handle events, etc., you'll write code. Here's a simple C# example to load and play a video file when a button is clicked:

```
// Assuming your TVFMediaPlayer control is named 'axMediaPlayer1'
// and you have a button named 'buttonPlay'

private void buttonPlay_Click(object sender, EventArgs e)
{
    // Prompt user to select a video file
    OpenFileDialog openFileDialog = new OpenFileDialog();
    openFileDialog.Filter = "Media Files|*.mp4;*.avi;*.mov;*.wmv|All Files|*.*";
    if (openFileDialog.ShowDialog() == DialogResult.OK)
    {
        try
        {
            // Set the filename for the ActiveX control
            axMediaPlayer1.FilenameOrURL = openFileDialog.FileName;

            // Start playback
            axMediaPlayer1.Play();
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Error playing file: {ex.Message}");
        }
    }
}

// Example of handling an event (e.g., playback completed)
private void axMediaPlayer1_OnStop(object sender, EventArgs e)
{
    MessageBox.Show("Playback stopped or finished.");
}

// Remember to attach the event handler, usually in the Form's Load event or constructor
public Form1()
{
    InitializeComponent();
    axMediaPlayer1.OnStop += axMediaPlayer1_OnStop; // Attach the event handler
}
```

Similar code can be written in VB.NET, accessing the same properties (`FilenameOrURL`, `Play()`) and events (`OnStop`). In C++, you would typically use COM interfaces directly or MFC wrappers if using that framework.

## Important: The Case for the Native .NET SDK

While the steps above show how to use the ActiveX control, **for all new .NET development (C#, VB.NET), we strongly recommend using the native VisioForge Media Player SDK for .NET.**

The ActiveX approach, while functional, carries several significant disadvantages in the modern .NET world:

1. **Complexity:** Relies on COM Interop and RCW generation, adding layers of abstraction that can sometimes be fragile or lead to unexpected behavior.
2. **Performance:** COM Interop can introduce performance overhead compared to native .NET code.
3. **Deployment:** Requires proper registration of the ActiveX control (x86 and potentially x64) on the end-user's machine using `regsvr32`, which can complicate deployment and require administrative privileges. Native .NET libraries are typically deployed just by copying files (XCopy deployment) or via NuGet.
4. **Limited Integration:** ActiveX controls don't integrate as seamlessly with modern .NET UI frameworks like WPF or MAUI. While they can sometimes be hosted, it's often awkward and limited compared to native controls.
5. **Bitness Mismatches:** Managing x86/x64 versions and ensuring the correct one is used by the application and the VS designer can be error-prone.
6. **Technology Age:** ActiveX is a legacy technology with limited ongoing evolution compared to the rapidly advancing .NET platform.

**Advantages of the Native .NET SDK:**

- **Native Controls:** Provides dedicated, optimized controls for WinForms, WPF, and MAUI.
- **Full .NET Integration:** Leverages the full power of the .NET framework, including async/await, LINQ, modern event patterns, and easier data binding.
- **Simplified Deployment:** Usually involves just referencing the SDK assemblies or NuGet packages. No COM registration needed.
- **Enhanced Features:** Often includes more features, better performance, and more granular control than the corresponding ActiveX version.
- **Improved Stability & Maintainability:** Native code is generally easier to debug, maintain, and less prone to interop issues.
- **Future-Proofing:** Aligns your application with modern .NET development practices.

You can find the native [.Net version of the SDK here](https://www.visioforge.com/media-player-sdk-net). It offers a significantly superior development experience and results for .NET applications.

## Troubleshooting Common Issues

- **Control Not Appearing in "COM Components":** Ensure the `TVFMediaPlayer` ActiveX control is correctly installed and registered. Try running the registration command (`regsvr32 <path_to_control.ocx>`) manually as an administrator. Remember to register both x86 and x64 versions if available and needed.
- **Error Adding Control to Form:** This often points to a mismatch between the Visual Studio designer process (usually x86) and the registered control version. Make sure the x86 version is registered.
- **Runtime Errors (File Not Found, Class Not Registered):** Verify the control (correct bitness for your app's target) is registered on the target machine where the application is run. Check project references to ensure the Interop assemblies are correctly included.
- **Events Not Firing:** Double-check that event handlers are correctly attached to the control's events in your code.

## Conclusion

Integrating the `TVFMediaPlayer` ActiveX control into Visual Studio 2010+ is achievable by adding it via the "Choose Toolbox Items" dialog. Visual Studio handles the generation of wrapper assemblies for .NET projects, allowing interaction via standard properties, methods, and events. However, due to the complexities, limitations, and deployment challenges associated with ActiveX/COM Interop in the .NET environment, **it is strongly advised to use the native VisioForge Media Player SDK for .NET for any new WinForms, WPF, or MAUI development.** The native SDK provides a more robust, performant, and developer-friendly experience aligned with modern application development practices.

---

Need further assistance? Please contact [VisioForge Support](https://support.visioforge.com/) or explore more examples on our [GitHub](https://github.com/visioforge/) page.

---END OF PAGE---


## Audio Capture to MP3 Files in Delphi, C++ MFC & VB6
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/audio-capture-mp3/
**Description:** Implement MP3 audio capture in Delphi, C++, and VB6 - configure LAME encoder, manage bitrates, and create high-quality audio recordings.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture, Encoding, MP3

# Audio Capture to MP3 Files in Delphi, C++ MFC & VB6

## Introduction

Audio capture capabilities are essential for many modern applications, from voice recording tools to multimedia creation software. This guide walks through the implementation of MP3 audio capture functionality in Delphi, C++ MFC, and VB6 applications using the VideoCapture component.

MP3 remains one of the most widely used audio formats due to its excellent compression and broad compatibility. By implementing proper MP3 audio capture in your applications, you can provide users with efficient, high-quality audio recording capabilities.

## Prerequisites

Before implementing MP3 audio capture, ensure you have:

- Development environment with Delphi, Visual C++ (for MFC), or Visual Basic 6
- VideoCapture component properly installed and referenced in your project
- Basic understanding of audio encoding concepts
- Required permissions for audio device access in your application

## LAME Encoder Configuration

The LAME MP3 encoder provides extensive customization options for audio quality, bitrate management, and channel configuration. Properly configuring these settings is crucial for achieving the desired audio quality while managing file size.

### Configuring Basic Encoding Parameters

The following code snippets demonstrate how to configure basic LAME encoding parameters:

```
// Delphi
VideoCapture1.Audio_LAME_CBR_Bitrate := StrToInt(cbLameCBRBitrate.Items[cbLameCBRBitrate.ItemIndex]);
VideoCapture1.Audio_LAME_VBR_Min_Bitrate := StrToInt(cbLameVBRMin.Items[cbLameVBRMin.ItemIndex]);
VideoCapture1.Audio_LAME_VBR_Max_Bitrate := StrToInt(cbLameVBRMax.Items[cbLameVBRMax.ItemIndex]);
VideoCapture1.Audio_LAME_Sample_Rate := StrToInt(cbLameSampleRate.Items[cbLameSampleRate.ItemIndex]);
VideoCapture1.Audio_LAME_VBR_Quality := tbLameVBRQuality.Position;
VideoCapture1.Audio_LAME_Encoding_Quality := tbLameEncodingQuality.Position;
```

```
// C++ MFC
// CComboBox::GetCurSel returns CB_ERR (-1) when nothing is selected — skip the
// assignment in that case so the property keeps its previously configured value.
int nIndex;
nIndex = m_cbLameCBRBitrate.GetCurSel();
if (nIndex != CB_ERR) m_VideoCapture.Audio_LAME_CBR_Bitrate = (int)m_cbLameCBRBitrate.GetItemData(nIndex);
nIndex = m_cbLameVBRMin.GetCurSel();
if (nIndex != CB_ERR) m_VideoCapture.Audio_LAME_VBR_Min_Bitrate = (int)m_cbLameVBRMin.GetItemData(nIndex);
nIndex = m_cbLameVBRMax.GetCurSel();
if (nIndex != CB_ERR) m_VideoCapture.Audio_LAME_VBR_Max_Bitrate = (int)m_cbLameVBRMax.GetItemData(nIndex);
nIndex = m_cbLameSampleRate.GetCurSel();
if (nIndex != CB_ERR) m_VideoCapture.Audio_LAME_Sample_Rate = (int)m_cbLameSampleRate.GetItemData(nIndex);
m_VideoCapture.Audio_LAME_VBR_Quality = m_tbLameVBRQuality.GetPos();
m_VideoCapture.Audio_LAME_Encoding_Quality = m_tbLameEncodingQuality.GetPos();
```

```
' VB6
VideoCapture1.Audio_LAME_CBR_Bitrate = CInt(cbLameCBRBitrate.List(cbLameCBRBitrate.ListIndex))
VideoCapture1.Audio_LAME_VBR_Min_Bitrate = CInt(cbLameVBRMin.List(cbLameVBRMin.ListIndex))
VideoCapture1.Audio_LAME_VBR_Max_Bitrate = CInt(cbLameVBRMax.List(cbLameVBRMax.ListIndex))
VideoCapture1.Audio_LAME_Sample_Rate = CInt(cbLameSampleRate.List(cbLameSampleRate.ListIndex))
VideoCapture1.Audio_LAME_VBR_Quality = tbLameVBRQuality.Value
VideoCapture1.Audio_LAME_Encoding_Quality = tbLameEncodingQuality.Value
```

### Setting Audio Channel Modes

Channel configuration affects both sound quality and file size. The following code demonstrates how to set the channel mode:

```
// Delphi
if rbLameStandardStereo.Checked then
  VideoCapture1.Audio_LAME_Channels_Mode := CH_Standard_Stereo
else if rbLameJointStereo.Checked then
  VideoCapture1.Audio_LAME_Channels_Mode := CH_Joint_Stereo
else if rbLameDualChannels.Checked then
  VideoCapture1.Audio_LAME_Channels_Mode := CH_Dual_Stereo
else
  VideoCapture1.Audio_LAME_Channels_Mode := CH_Mono;
```

```
// C++ MFC
if (m_rbLameStandardStereo.GetCheck())
  m_VideoCapture.Audio_LAME_Channels_Mode = VisioForge_Video_Capture::CH_Standard_Stereo;
else if (m_rbLameJointStereo.GetCheck())
  m_VideoCapture.Audio_LAME_Channels_Mode = VisioForge_Video_Capture::CH_Joint_Stereo;
else if (m_rbLameDualChannels.GetCheck())
  m_VideoCapture.Audio_LAME_Channels_Mode = VisioForge_Video_Capture::CH_Dual_Stereo;
else
  m_VideoCapture.Audio_LAME_Channels_Mode = VisioForge_Video_Capture::CH_Mono;
```

```
' VB6
If rbLameStandardStereo.Value Then
  VideoCapture1.Audio_LAME_Channels_Mode = CH_Standard_Stereo
ElseIf rbLameJointStereo.Value Then
  VideoCapture1.Audio_LAME_Channels_Mode = CH_Joint_Stereo
ElseIf rbLameDualChannels.Value Then
  VideoCapture1.Audio_LAME_Channels_Mode = CH_Dual_Stereo
Else
  VideoCapture1.Audio_LAME_Channels_Mode = CH_Mono
End If
```

### Advanced LAME Configuration Options

For more precise control over the encoding process, configure these advanced LAME options:

```
// Delphi
VideoCapture1.Audio_LAME_VBR_Mode := rbLameVBR.Checked;
VideoCapture1.Audio_LAME_Copyright := cbLameCopyright.Checked;
VideoCapture1.Audio_LAME_Original := cbLameOriginalCopy.Checked;
VideoCapture1.Audio_LAME_CRC_Protected := cbLameCRCProtected.Checked;
VideoCapture1.Audio_LAME_Force_Mono := cbLameForceMono.Checked;
VideoCapture1.Audio_LAME_Strictly_Enforce_VBR_Min_Bitrate := cbLameStrictlyEnforceVBRMinBitrate.Checked;
VideoCapture1.Audio_LAME_Voice_Encoding_Mode := cbLameVoiceEncodingMode.Checked;
VideoCapture1.Audio_LAME_Keep_All_Frequencies := cbLameKeepAllFrequencies.Checked;
VideoCapture1.Audio_LAME_Strict_ISO_Compilance := cbLameStrictISOCompilance.Checked;
VideoCapture1.Audio_LAME_Disable_Short_Blocks := cbLameDisableShortBlocks.Checked;
VideoCapture1.Audio_LAME_Enable_Xing_VBR_Tag := cbLameEnableXingVBRTag.Checked;
VideoCapture1.Audio_LAME_Mode_Fixed := cbLameModeFixed.Checked;
```

```
// C++ MFC
m_VideoCapture.Audio_LAME_VBR_Mode = m_rbLameVBR.GetCheck() ? true : false;
m_VideoCapture.Audio_LAME_Copyright = m_cbLameCopyright.GetCheck() ? true : false;
m_VideoCapture.Audio_LAME_Original = m_cbLameOriginalCopy.GetCheck() ? true : false;
m_VideoCapture.Audio_LAME_CRC_Protected = m_cbLameCRCProtected.GetCheck() ? true : false;
m_VideoCapture.Audio_LAME_Force_Mono = m_cbLameForceMono.GetCheck() ? true : false;
m_VideoCapture.Audio_LAME_Strictly_Enforce_VBR_Min_Bitrate = m_cbLameStrictlyEnforceVBRMinBitrate.GetCheck() ? true : false;
m_VideoCapture.Audio_LAME_Voice_Encoding_Mode = m_cbLameVoiceEncodingMode.GetCheck() ? true : false;
m_VideoCapture.Audio_LAME_Keep_All_Frequencies = m_cbLameKeepAllFrequencies.GetCheck() ? true : false;
m_VideoCapture.Audio_LAME_Strict_ISO_Compilance = m_cbLameStrictISOCompilance.GetCheck() ? true : false;
m_VideoCapture.Audio_LAME_Disable_Short_Blocks = m_cbLameDisableShortBlocks.GetCheck() ? true : false;
m_VideoCapture.Audio_LAME_Enable_Xing_VBR_Tag = m_cbLameEnableXingVBRTag.GetCheck() ? true : false;
m_VideoCapture.Audio_LAME_Mode_Fixed = m_cbLameModeFixed.GetCheck() ? true : false;
```

```
' VB6
VideoCapture1.Audio_LAME_VBR_Mode = rbLameVBR.Value
VideoCapture1.Audio_LAME_Copyright = cbLameCopyright.Value
VideoCapture1.Audio_LAME_Original = cbLameOriginalCopy.Value
VideoCapture1.Audio_LAME_CRC_Protected = cbLameCRCProtected.Value
VideoCapture1.Audio_LAME_Force_Mono = cbLameForceMono.Value
VideoCapture1.Audio_LAME_Strictly_Enforce_VBR_Min_Bitrate = cbLameStrictlyEnforceVBRMinBitrate.Value
VideoCapture1.Audio_LAME_Voice_Encoding_Mode = cbLameVoiceEncodingMode.Value
VideoCapture1.Audio_LAME_Keep_All_Frequencies = cbLameKeepAllFrequencies.Value
VideoCapture1.Audio_LAME_Strict_ISO_Compilance = cbLameStrictISOCompilance.Value
VideoCapture1.Audio_LAME_Disable_Short_Blocks = cbLameDisableShortBlocks.Value
VideoCapture1.Audio_LAME_Enable_Xing_VBR_Tag = cbLameEnableXingVBRTag.Value
VideoCapture1.Audio_LAME_Mode_Fixed = cbLameModeFixed.Value
```

## Understanding LAME Configuration Options

### Bitrate Settings

- **CBR (Constant Bitrate)**: Maintains the same bitrate throughout the entire recording
- **VBR (Variable Bitrate)**: Adjusts bitrate based on audio complexity
- **Min/Max Bitrate**: Sets boundaries for VBR encoding
- **VBR Quality**: Controls the quality/file size balance in VBR mode

### Channel Modes

- **Standard Stereo**: Completely separate left and right channels
- **Joint Stereo**: Combines redundant information between channels to save space
- **Dual Stereo**: Two completely independent mono channels
- **Mono**: Single audio channel

### Special Encoding Options

- **Voice Encoding Mode**: Optimizes encoding for voice frequencies
- **Force Mono**: Converts stereo input to mono output
- **CRC Protection**: Adds error detection data
- **Strict ISO Compliance**: Ensures maximum compatibility with all MP3 players

## Configuring Output Format

After setting up LAME encoding parameters, specify MP3 as the output format:

```
// Delphi
VideoCapture1.OutputFormat := Format_LAME;
```

```
// C++ MFC
m_VideoCapture.OutputFormat = VisioForge_Video_Capture::Format_LAME;
```

```
' VB6
VideoCapture1.OutputFormat = Format_LAME
```

## Setting Audio Capture Mode

Set the VideoCapture component to audio-only capture mode:

```
// Delphi
VideoCapture1.Mode := Mode_Audio_Capture;
```

```
// C++ MFC
m_VideoCapture.Mode = VisioForge_Video_Capture::Mode_Audio_Capture;
```

```
' VB6
VideoCapture1.Mode = Mode_Audio_Capture
```

## Starting the Audio Capture

Once all parameters are configured, initiate the recording process:

```
// Delphi
VideoCapture1.Start;
```

```
// C++ MFC
m_VideoCapture.Start();
```

```
' VB6
VideoCapture1.Start
```

## Best Practices for MP3 Audio Capture

- **Quality vs. Size**: For voice recordings, lower bitrates (64-128 kbps) are usually sufficient. For music, use 192 kbps or higher.
- **Sample Rate Selection**: 44.1 kHz is standard for most audio. Lower rates can be used for voice-only recordings.
- **VBR vs. CBR**: VBR generally provides better quality-to-size ratio but might have compatibility issues with some players.
- **Error Handling**: Always implement proper error handling around the recording process.
- **User Feedback**: Provide visual feedback during recording (level meters, time elapsed).

## Conclusion

Implementing MP3 audio capture in your applications provides users with a widely compatible and efficient recording solution. By properly configuring LAME encoder settings, you can balance audio quality and file size based on your application's specific requirements.

The VideoCapture component makes this implementation straightforward in Delphi, C++ MFC, and VB6 applications, allowing you to focus on creating a great user experience around the audio capture functionality.

---

For additional code samples and advanced implementation techniques, visit our GitHub repository. If you encounter any issues during implementation, contact our technical support team for assistance.

---END OF PAGE---


## Delphi Video Capture SDK WAV Audio Recording Guide
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/audio-capture-wav/
**Description:** Capture audio to WAV files in Delphi with codec selection, compression options, and stereo recording using TVFVideoCapture code examples.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture, WAV

# Audio Capture to WAV Files: Developer Implementation Guide

## Introduction

Capturing audio to WAV files is a fundamental requirement for many multimedia applications. This guide provides detailed instructions for implementing audio capture functionality with or without compression in your applications. Whether you're developing in Delphi, C++ MFC, or VB6 using our ActiveX controls, this guide will walk you through the entire process from initial setup to final implementation.

## Setting Up Your Development Environment

Before you begin implementing audio capture, ensure you have:

1. Installed the SDK in your development environment
2. Added the VideoCapture component to your form/project
3. Set up basic error handling to manage capture exceptions
4. Configured your application to access audio hardware

## Audio Codec Management

### Retrieving Available Audio Codecs

The first step in implementing audio capture is to retrieve a list of available audio codecs on the system. This allows you to present users with codec options or to programmatically select the most appropriate codec for your application's needs.

#### Delphi Implementation

```
// Iterate through all available audio codecs
for i := 0 to VideoCapture1.Audio_Codecs_GetCount - 1 do
  cbAudioCodec.Items.Add(VideoCapture1.Audio_Codecs_GetItem(i));
```

#### C++ MFC Implementation

```
// Get all available audio codecs and populate combo box
for (int i = 0; i < m_VideoCapture.Audio_Codecs_GetCount(); i++) {
  CString codec = m_VideoCapture.Audio_Codecs_GetItem(i);
  m_AudioCodecCombo.AddString(codec);
}
```

#### VB6 Implementation

```
' Iterate through all available audio codecs
For i = 0 To VideoCapture1.Audio_Codecs_GetCount - 1
  cboAudioCodec.AddItem VideoCapture1.Audio_Codecs_GetItem(i)
Next i
```

### Selecting an Audio Codec

Once you've populated the list of available codecs, you'll need to provide a way to select the desired codec for the audio capture operation. This can be done programmatically or via user selection.

#### Delphi Implementation

```
// Set the codec based on user selection from combo box
VideoCapture1.Audio_Codec := cbAudioCodec.Items[cbAudioCodec.ItemIndex];
```

#### C++ MFC Implementation

```
// Get the selected codec from the combo box
int selectedIndex = m_AudioCodecCombo.GetCurSel();
CString selectedCodec;
m_AudioCodecCombo.GetLBText(selectedIndex, selectedCodec);

// Set the codec
m_VideoCapture.SetAudio_Codec(selectedCodec);
```

#### VB6 Implementation

```
' Set the codec based on user selection
VideoCapture1.Audio_Codec = cboAudioCodec.Text
```

## Configuring Audio Parameters

Proper audio parameter configuration is crucial for achieving the desired quality and file size balance. The three primary parameters to configure are channels, bits per sample (BPS), and sample rate.

### Setting Audio Channels

Audio channels determine whether the captured audio is mono (1 channel) or stereo (2 channels). Stereo provides better spatial audio representation but requires more storage space.

#### Delphi Implementation

```
// Set the number of audio channels (1 for mono, 2 for stereo)
VideoCapture1.Audio_Channels := StrToInt(cbChannels2.Items[cbChannels2.ItemIndex]);
```

#### C++ MFC Implementation

```
// Set audio channels (1 for mono, 2 for stereo)
int nIndex = m_ChannelsCombo.GetCurSel();
if (nIndex == CB_ERR) return; // No selection — leave the current value untouched
CString strChannels;
m_ChannelsCombo.GetLBText(nIndex, strChannels);
int channels = _ttoi(strChannels);
m_VideoCapture.SetAudio_Channels(channels);
```

#### VB6 Implementation

```
' Set audio channels (1 for mono, 2 for stereo)
VideoCapture1.Audio_Channels = CInt(cboChannels.Text)
```

### Configuring Bits Per Sample (BPS)

The bits per sample (BPS) setting affects the dynamic range and quality of the audio. Common values include 8, 16, and 24 bits, with higher values providing better quality at the cost of larger file sizes.

#### Delphi Implementation

```
// Set bits per sample (typically 8, 16, or 24)
VideoCapture1.Audio_BPS := StrToInt(cbBPS2.Items[cbBPS2.ItemIndex]);
```

#### C++ MFC Implementation

```
// Set bits per sample
int nIndex = m_BPSCombo.GetCurSel();
if (nIndex == CB_ERR) return; // No selection — leave the current value untouched
CString strBPS;
m_BPSCombo.GetLBText(nIndex, strBPS);
int bps = _ttoi(strBPS);
m_VideoCapture.SetAudio_BPS(bps);
```

#### VB6 Implementation

```
' Set bits per sample
VideoCapture1.Audio_BPS = CInt(cboBPS.Text)
```

### Setting Sample Rate

The sample rate determines how many audio samples are captured per second. Common values include 8000 Hz, 44100 Hz (CD quality), and 48000 Hz (professional audio). Higher sample rates capture more high-frequency detail but increase file size.

#### Delphi Implementation

```
// Set audio sample rate in Hz (common values: 8000, 44100, 48000)
VideoCapture1.Audio_SampleRate := StrToInt(cbSamplerate.Items[cbSamplerate.ItemIndex]);
```

#### C++ MFC Implementation

```
// Set sample rate
int nIndex = m_SampleRateCombo.GetCurSel();
if (nIndex == CB_ERR) return; // No selection — leave the current value untouched
CString strSampleRate;
m_SampleRateCombo.GetLBText(nIndex, strSampleRate);
int sampleRate = _ttoi(strSampleRate);
m_VideoCapture.SetAudio_SampleRate(sampleRate);
```

#### VB6 Implementation

```
' Set sample rate
VideoCapture1.Audio_SampleRate = CInt(cboSampleRate.Text)
```

## Configuring Output Format

### Selecting PCM/ACM Format

The Windows Audio Compression Manager (ACM) supports various audio formats including PCM (uncompressed) and compressed formats. Setting the output format to PCM/ACM enables codec-based compression when a codec other than PCM is selected.

#### Delphi Implementation

```
// Set output to PCM/ACM format to enable codec-based compression
VideoCapture1.OutputFormat := Format_PCM_ACM;
```

#### C++ MFC Implementation

```
// Set output format to PCM/ACM
m_VideoCapture.SetOutputFormat(Format_PCM_ACM);
```

#### VB6 Implementation

```
' Set output format to PCM/ACM
VideoCapture1.OutputFormat = Format_PCM_ACM
```

## Setting the Audio Capture Mode

Before starting the capture operation, you need to set the component to audio capture mode. This ensures that only audio is captured without any video streams.

### Delphi Implementation

```
// Set to audio-only capture mode
VideoCapture1.Mode := Mode_Audio_Capture;
```

### C++ MFC Implementation

```
// Set to audio-only capture mode
m_VideoCapture.SetMode(Mode_Audio_Capture);
```

### VB6 Implementation

```
' Set to audio-only capture mode
VideoCapture1.Mode = Mode_Audio_Capture
```

## Starting the Audio Capture

With all parameters configured, you can now start the audio capture process. This initializes the audio hardware, applies the selected codec and settings, and begins capturing audio to the specified output file.

### Delphi Implementation

```
// Begin audio capture process
VideoCapture1.Start;
```

### C++ MFC Implementation

```
// Begin audio capture process
m_VideoCapture.Start();
```

### VB6 Implementation

```
' Begin audio capture process
VideoCapture1.Start
```

## Advanced Implementation Considerations

### User Interface Integration

To provide a better user experience, consider implementing:

1. Real-time audio level metering
2. Elapsed time display
3. File size estimation
4. Pause/resume functionality

### Performance Optimization

For optimal performance when capturing extended audio sessions:

1. Monitor system memory usage
2. Implement file splitting for long recordings
3. Consider buffering strategies for high-quality captures

## Troubleshooting Common Issues

When implementing audio capture, you might encounter these common issues:

1. **No audio devices detected**: Ensure proper hardware connections and drivers
2. **Poor audio quality**: Verify sample rate and bits per sample settings
3. **Codec compatibility issues**: Test with standard codecs like PCM or MP3
4. **High CPU usage**: Consider reducing sample rate or using hardware acceleration

## Conclusion

Implementing audio capture to WAV files in your applications requires careful configuration of codecs, audio parameters, and output settings. By following this guide, you can create robust audio capture functionality that balances quality and file size requirements.

For complex implementations or specific technical challenges, our support team is available to assist with custom solutions tailored to your application requirements.

## Additional Resources

Visit our GitHub page for more code samples and implementation examples that demonstrate advanced audio capture techniques and integration patterns.

---

For technical assistance with this implementation, please contact our support team. Additional code samples are available on our GitHub page.

---END OF PAGE---


## Delphi Audio Output Device Selection | VideoCapture
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/audio-output/
**Description:** Select audio output devices in Delphi - enumerate devices, control volume, adjust balance with code examples for Delphi, C++, and VB6.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture

# Audio Output Device Selection in Delphi

This guide provides detailed instructions and code examples for implementing audio output device selection in your video capture applications. Delphi, C++ MFC, and VB6 implementations are covered to help you integrate this functionality into your projects efficiently.

## Available Audio Output Device Enumeration

The first step in implementing audio output device selection is retrieving the complete list of available audio output devices on the system. This allows users to choose their preferred audio output device.

### Delphi Implementation

```
// Iterate through all available audio output devices
for i := 0 to VideoCapture1.Audio_OutputDevices_GetCount - 1 do
  // Add each device to the dropdown list
  cbAudioOutputDevice.Items.Add(VideoCapture1.Audio_OutputDevices_GetItem(i));
```

### C++ MFC Implementation

```
// Populate the combobox with all available audio output devices
for (int i = 0; i < m_VideoCapture.Audio_OutputDevices_GetCount(); i++) {
  CString deviceName = m_VideoCapture.Audio_OutputDevices_GetItem(i);
  m_AudioOutputDeviceCombo.AddString(deviceName);
}
```

### VB6 Implementation

```
' Iterate through all available audio output devices
For i = 0 To VideoCapture1.Audio_OutputDevices_GetCount - 1
  ' Add each device to the dropdown list
  cboAudioOutputDevice.AddItem VideoCapture1.Audio_OutputDevices_GetItem(i)
Next i
```

## Setting the Active Audio Output Device

After retrieving the available devices, the next step is to set the selected device as the active audio output device for your application.

### Delphi Implementation

```
// Set the selected device as the active audio output device
VideoCapture1.Audio_OutputDevice := cbAudioOutputDevice.Items[cbAudioOutputDevice.ItemIndex];
```

### C++ MFC Implementation

```
// Get the selected index from the combobox
int selectedIndex = m_AudioOutputDeviceCombo.GetCurSel();
CString selectedDevice;
m_AudioOutputDeviceCombo.GetLBText(selectedIndex, selectedDevice);

// Set the selected device as the active audio output device.
// COM property setters in MFC use the put_ wrapper, not direct assignment.
m_VideoCapture.put_Audio_OutputDevice(selectedDevice);
```

### VB6 Implementation

```
' Set the selected device as the active audio output device
VideoCapture1.Audio_OutputDevice = cboAudioOutputDevice.Text
```

## Enabling Audio Playback

Once the output device is selected, you need to enable audio playback to hear the audio through the selected device.

### Delphi Implementation

```
// Enable audio playback through the selected device
VideoCapture1.Audio_PlayAudio := true;
```

### C++ MFC Implementation

```
// Enable audio playback through the selected device
m_VideoCapture.Audio_PlayAudio = TRUE;
```

### VB6 Implementation

```
' Enable audio playback through the selected device
VideoCapture1.Audio_PlayAudio = True
```

## Adjusting Audio Volume Levels

Providing volume control gives users the ability to customize their audio experience. This section shows how to implement volume adjustment.

### Delphi Implementation

```
// Set the volume level based on trackbar position
VideoCapture1.Audio_OutputDevice_SetVolume(tbAudioVolume.Position);
```

### C++ MFC Implementation

```
// Get the current position of the volume slider
int volumeLevel = m_VolumeSlider.GetPos();

// Set the volume level based on slider position
m_VideoCapture.Audio_OutputDevice_SetVolume(volumeLevel);
```

### VB6 Implementation

```
' Set the volume level based on slider position
VideoCapture1.Audio_OutputDevice_SetVolume sldVolume.Value
```

## Controlling Audio Balance

For stereo output, balance control allows users to adjust the relative volume between left and right channels.

### Delphi Implementation

```
// Set the balance level based on trackbar position
VideoCapture1.Audio_OutputDevice_SetBalance(tbAudioBalance.Position);
```

### C++ MFC Implementation

```
// Get the current position of the balance slider
int balanceLevel = m_BalanceSlider.GetPos();

// Set the balance level based on slider position
m_VideoCapture.Audio_OutputDevice_SetBalance(balanceLevel);
```

### VB6 Implementation

```
' Set the balance level based on slider position
VideoCapture1.Audio_OutputDevice_SetBalance sldBalance.Value
```

## Best Practices for Audio Device Implementation

- Always check if the audio device is valid before attempting to use it
- Provide fallback mechanisms when the selected device becomes unavailable
- Consider saving user preferences for audio device selection between sessions
- Implement visual feedback when volume or balance settings are changed

---

Please contact our [support team](https://support.visioforge.com/) if you need assistance with this implementation. Visit our [GitHub repository](https://github.com/visioforge/) for additional code samples and resources.

---END OF PAGE---


## Delphi Video Capture SDK Version Changelog and Notes
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/changelog/
**Description:** TVFVideoCapture version history - GPU acceleration, streaming capabilities, format updates from version 4.1 to 11.0 with detailed release notes.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture, Streaming
**API:** TVFVideoCapture, TVFMediaPlayer

# TVFVideoCapture Version History

## Release 11.00 - Enhanced GPU Encoding & Modern Delphi Support

- **Expanded Framework Compatibility**: Added support for Delphi 10.4 and 11.0 development environments
- **Advanced AMD GPU Acceleration**: Implemented MP4 (H264/AAC) video encoding utilizing AMD graphics processing units
- **Intel GPU Hardware Encoding**: Added MP4 (H264/AAC) video encoding through Intel integrated and discrete GPUs
- **NVIDIA CUDA Acceleration**: Introduced MP4 (H264/AAC) video encoding powered by NVIDIA graphics hardware
- **Container Format Improvements**: Enhanced MKV output with optimized performance and reliability
- **New Output Format**: Added MOV container format support for Apple ecosystem compatibility

## Release 10.0 - Performance Optimizations & Multi-Platform Support

- **MP4 Enhancement**: Thoroughly updated and improved MP4 output capabilities
- **Streaming Improvements**: Updated VLC source filter with enhanced RTMP and HTTPS support
- **Memory Management**: Fixed critical CUDA encoder memory leak for stable long-duration encoding
- **Resource Optimization**: Resolved FFMPEG source memory leak for improved application stability
- **Audio Capture**: Enhanced What You Hear filter for superior system audio recording
- **64-bit Architecture**: Added x64 VLC source for TVFMediaPlayer and TVFVideoCapture (both Delphi and ActiveX)
- **Extended Format Support**: Enhanced YUV2RGB filter with HDYC format support
- **Audio Encoding**: Updated LAME encoder with fix for low bitrate mono audio issues
- **Development Environment**: Added Delphi 10, 10.1 support for modern development workflows

## Release 8.7 - Core Engine Updates

- **VLC Integration**: Updated VLC engine to libVLC 2.2.1.0 for improved streaming capabilities
- **Decoder Enhancement**: Updated FFMPEG engine for better format compatibility and performance

## Release 8.6 - Reliability Improvements & Format Support

- **Resource Management**: Fixed critical memory leak for improved application stability
- **File Handling**: Resolved issues with improperly closed input and output files
- **New Format Support**: Added custom WebM filters based on the WebM project specifications

## Release 8.4 - Architecture Expansion

- **Modern Delphi**: Added Delphi XE8 support for latest development environments
- **64-bit Architecture**: Introduced Delphi and ActiveX x64 versions for performance on modern systems

## Release 8.31 - Development Environment Update

- **Framework Compatibility**: Added Delphi XE7 support for expanded development options

## Release 8.3 - API and Performance Improvements

- **Interface Enhancement**: Updated ActiveX API for improved developer experience
- **Decoder Optimization**: Enhanced FFMPEG decoder for better performance and format support
- **Stability**: Implemented several critical bug fixes and performance improvements

## Release 8.0 - Streaming Capabilities

- **Network Streaming**: Introduced VLC engine for IP video capture capabilities
- **Reliability**: Fixed several bugs for improved stability across all components

## Release 7.15 - Advanced Output Options & Security

- **Network Capture**: Improved IP capture engine for better connection stability and performance
- **Modern Format Support**: Added MP4 with H264/AAC output for industry-standard compatibility
- **Security Feature**: Implemented video encryption for protected content workflows
- **System Integration**: Added Virtual Camera output for software integration scenarios
- **Stability**: Multiple small bug fixes for improved reliability

## Release 7.0 - Capture Engine Improvements

- **Network Performance**: Enhanced IP capture engine with improved throughput and reliability
- **Desktop Capture**: Updated screen capture engine for better performance and quality
- **Output Options**: Enhanced FFMPEG output for expanded format support
- **Visual Effects**: Added Pan/zoom video effect for advanced video manipulation
- **Reliability**: Implemented multiple small bug fixes for improved stability

## Release 6.0 - Multi-Source & Windows 8 Compatibility

- **Advanced Compositing**: Improved Picture-In-Picture with support for any video source including screen capture and IP cameras
- **Streaming Protocol**: Enhanced RTSP sources support for better network video integration
- **Special Capture Mode**: Added layered windows screen capture support for complex UI recording
- **Hardware Support**: Implemented iCube cameras support for specialized imaging applications
- **OS Compatibility**: Added Windows 8 Developer Preview support for forward compatibility
- **Visual Processing**: Enhanced video effects with new options and improved performance
- **Audio Management**: Introduced multiple audio stream support for AVI and WMV outputs

## Release 5.5 - Stability & Feature Enhancements

- **Visual Processing**: Enhanced video effects with improved quality and performance
- **Network Video**: Improved IP cameras support for better connectivity and compatibility
- **Reliability**: Fixed several bugs for improved overall stability

## Release 5.4 - Modern Delphi Support

- **Development Environment**: Added Delphi XE2 support for modern application development
- **Stability**: Implemented several bug fixes for improved reliability

## Release 5.3 - Video Processing Improvements

- **Visual Effects**: Enhanced video effects with additional options and better performance
- **Network Video**: Improved IP cameras support for wider device compatibility
- **Reliability**: Fixed multiple bugs for more stable operation

## Release 5.2 - Frame Processing Enhancements

- **Visual Effects**: Improved video effects and video frame grabber functionality
- **Stability**: Fixed several bugs for enhanced reliability

## Release 5.1 - Network Video & Effects Improvements

- **IP Camera Integration**: Enhanced IP camera support for improved connectivity
- **Visual Processing**: Improved video effect quality and performance
- **Reliability**: Fixed various issues for better stability

## Release 5.0 - Major Format Support Expansion

- **Network Video**: Added RTSP/HTTP IP camera support (MJPEG/MPEG-4/H264 with or without audio)
- **Modern Format**: Implemented WebM output for open web standards compatibility
- **Format Flexibility**: Added MPEG-1/2/4 and FLV output using FFMPEG integration

## Release 4.22 - Screen Capture Improvements

- **Desktop Recording**: Fixed bugs in screen capture filter for improved recording quality

## Release 4.21 - Screen Capture Enhancements

- **Desktop Recording**: Implemented multiple bug fixes and improvements in screen capture filter

## Release 4.2 - Audio Processing Improvement

- **Sound Effects**: Enhanced audio effects filter with improved quality and performance

## Release 4.1 - Modern Delphi Integration

- **Development Environment**: Added Delphi 2010 support for the Delphi edition
- **Stability**: Fixed several bugs for improved reliability

---END OF PAGE---


## DirectShow Output Formats in Delphi - Complete Guide
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/custom-output/
**Description:** Implement DirectShow custom output formats in Delphi, C++, VB6 - integrate third-party filters, codecs, and multiplexers with code examples.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, DirectShow, Windows, VCL, Capture, Encoding

# Code sample - Custom output formats

Delphi, C++ MFC, and VB6 sample code.

Currently, there are several options for connecting third-party DirectShow filters to get the necessary format.

## The first option - 3 different DirectShow filters

An audio codec, a video codec, and a multiplexer – different filter. You can use both DirectShow filters and regular codecs as codecs.

## The second option - an all-in-one DirectShow filter

A multiplexer, a video codec, and an audio codec – the same filter.
 Another difference is whether the filter can write to a file itself, whether you should use the standard File Writer filter, or whether you need another special filter.

In the first two cases, VisioForge Video Capture will detect it automatically and set the necessary parameters, but you have to specify the necessary filter yourself in the third case.

Now, let us see what the code for different options looks like.

## First option

Get lists of audio and video codecs

```
for I := 0 to VideoCapture1.Video_Codecs_GetCount - 1 do
  cbCustomVideoCodec.Items.Add(VideoCapture1.Video_Codecs_GetItem(i));
for I := 0 to VideoCapture1.Audio_Codecs_GetCount - 1 do
  cbCustomAudioCodec.Items.Add(VideoCapture1.Audio_Codecs_GetItem(i));
```

```
// C++ MFC
for (int i = 0; i < m_VideoCapture.Video_Codecs_GetCount(); i++)
  m_CustomVideoCodecCombo.AddString(m_VideoCapture.Video_Codecs_GetItem(i));
for (int i = 0; i < m_VideoCapture.Audio_Codecs_GetCount(); i++)
  m_CustomAudioCodecCombo.AddString(m_VideoCapture.Audio_Codecs_GetItem(i));
```

```
' VB6
For i = 0 To VideoCapture1.Video_Codecs_GetCount - 1
  cbCustomVideoCodec.AddItem VideoCapture1.Video_Codecs_GetItem(i)
Next i
For i = 0 To VideoCapture1.Audio_Codecs_GetCount - 1
  cbCustomAudioCodec.AddItem VideoCapture1.Audio_Codecs_GetItem(i)
Next i
```

Get the list of DirectShow filters

```
for I := 0 to VideoCapture1.DirectShow_Filters_GetCount - 1 do
  begin
    cbCustomDSFilterV.Items.Add(VideoCapture1.DirectShow_Filters_GetItem(i));
    cbCustomDSFilterA.Items.Add(VideoCapture1.DirectShow_Filters_GetItem(i));
    cbCustomMuxer.Items.Add(VideoCapture1.DirectShow_Filters_GetItem(i));
    cbCustomFilewriter.Items.Add(VideoCapture1.DirectShow_Filters_GetItem(i));
  end;
```

```
// C++ MFC
for (int i = 0; i < m_VideoCapture.DirectShow_Filters_GetCount(); i++)
{
  m_CustomDSFilterVCombo.AddString(m_VideoCapture.DirectShow_Filters_GetItem(i));
  m_CustomDSFilterACombo.AddString(m_VideoCapture.DirectShow_Filters_GetItem(i));
  m_CustomMuxerCombo.AddString(m_VideoCapture.DirectShow_Filters_GetItem(i));
  m_CustomFilewriterCombo.AddString(m_VideoCapture.DirectShow_Filters_GetItem(i));
}
```

```
' VB6
For i = 0 To VideoCapture1.DirectShow_Filters_GetCount - 1
  cbCustomDSFilterV.AddItem VideoCapture1.DirectShow_Filters_GetItem(i)
  cbCustomDSFilterA.AddItem VideoCapture1.DirectShow_Filters_GetItem(i)
  cbCustomMuxer.AddItem VideoCapture1.DirectShow_Filters_GetItem(i)
  cbCustomFilewriter.AddItem VideoCapture1.DirectShow_Filters_GetItem(i)
Next i
```

Select filters and codecs

```
if rbCustomUseVideoCodecsCat.Checked then
  begin
    VideoCapture1.Custom_Output_Video_Codec := cbCustomVideoCodec.Items[cbCustomVideoCodec.ItemIndex];
    VideoCapture1.Custom_Output_Video_Codec_Use_Filters_Category := false;
  end
else
  begin
    VideoCapture1.Custom_Output_Video_Codec := cbCustomDSFilterV.Items[cbCustomDSFilterV.ItemIndex];
    VideoCapture1.Custom_Output_Video_Codec_Use_Filters_Category := true;
  end;

if rbCustomUseAudioCodecsCat.Checked then
  begin
    VideoCapture1.Custom_Output_Audio_Codec := cbCustomAudioCodec.Items[cbCustomAudioCodec.ItemIndex];
    VideoCapture1.Custom_Output_Audio_Codec_Use_Filters_Category := false;
  end
else
  begin
    VideoCapture1.Custom_Output_Audio_Codec := cbCustomDSFilterA.Items[cbCustomDSFilterA.ItemIndex];
    VideoCapture1.Custom_Output_Audio_Codec_Use_Filters_Category := true;
  end;
VideoCapture1.Custom_Output_Mux_Filter_Name := cbCustomMuxer.Items[cbCustomMuxer.ItemIndex];
```

```
// C++ MFC
// CComboBox::GetCurSel returns CB_ERR (-1) when no item is selected; guard each
// read so GetLBText is never called with -1.
int nIndex;
if (m_CustomUseVideoCodecsCat.GetCheck())
{
  nIndex = m_CustomVideoCodecCombo.GetCurSel();
  if (nIndex != CB_ERR)
  {
    CString videoCodec;
    m_CustomVideoCodecCombo.GetLBText(nIndex, videoCodec);
    m_VideoCapture.Custom_Output_Video_Codec = videoCodec;
    m_VideoCapture.Custom_Output_Video_Codec_Use_Filters_Category = false;
  }
}
else
{
  nIndex = m_CustomDSFilterVCombo.GetCurSel();
  if (nIndex != CB_ERR)
  {
    CString videoCodec;
    m_CustomDSFilterVCombo.GetLBText(nIndex, videoCodec);
    m_VideoCapture.Custom_Output_Video_Codec = videoCodec;
    m_VideoCapture.Custom_Output_Video_Codec_Use_Filters_Category = true;
  }
}

if (m_CustomUseAudioCodecsCat.GetCheck())
{
  nIndex = m_CustomAudioCodecCombo.GetCurSel();
  if (nIndex != CB_ERR)
  {
    CString audioCodec;
    m_CustomAudioCodecCombo.GetLBText(nIndex, audioCodec);
    m_VideoCapture.Custom_Output_Audio_Codec = audioCodec;
    m_VideoCapture.Custom_Output_Audio_Codec_Use_Filters_Category = false;
  }
}
else
{
  nIndex = m_CustomDSFilterACombo.GetCurSel();
  if (nIndex != CB_ERR)
  {
    CString audioCodec;
    m_CustomDSFilterACombo.GetLBText(nIndex, audioCodec);
    m_VideoCapture.Custom_Output_Audio_Codec = audioCodec;
    m_VideoCapture.Custom_Output_Audio_Codec_Use_Filters_Category = true;
  }
}

nIndex = m_CustomMuxerCombo.GetCurSel();
if (nIndex != CB_ERR)
{
  CString muxerName;
  m_CustomMuxerCombo.GetLBText(nIndex, muxerName);
  m_VideoCapture.Custom_Output_Mux_Filter_Name = muxerName;
}
```

```
' VB6
If rbCustomUseVideoCodecsCat.Value Then
  VideoCapture1.Custom_Output_Video_Codec = cbCustomVideoCodec.List(cbCustomVideoCodec.ListIndex)
  VideoCapture1.Custom_Output_Video_Codec_Use_Filters_Category = False
Else
  VideoCapture1.Custom_Output_Video_Codec = cbCustomDSFilterV.List(cbCustomDSFilterV.ListIndex)
  VideoCapture1.Custom_Output_Video_Codec_Use_Filters_Category = True
End If

If rbCustomUseAudioCodecsCat.Value Then
  VideoCapture1.Custom_Output_Audio_Codec = cbCustomAudioCodec.List(cbCustomAudioCodec.ListIndex)
  VideoCapture1.Custom_Output_Audio_Codec_Use_Filters_Category = False
Else
  VideoCapture1.Custom_Output_Audio_Codec = cbCustomDSFilterA.List(cbCustomDSFilterA.ListIndex)
  VideoCapture1.Custom_Output_Audio_Codec_Use_Filters_Category = True
End If
VideoCapture1.Custom_Output_Mux_Filter_Name = cbCustomMuxer.List(cbCustomMuxer.ListIndex)
```

## Second option

Get lists of DirectShow filters.

```
for I := 0 to VideoCapture1.DirectShow_Filters_GetCount - 1 do
  begin
    cbCustomDSFilterV.Items.Add(VideoCapture1.DirectShow_Filters_GetItem(i));
    cbCustomDSFilterA.Items.Add(VideoCapture1.DirectShow_Filters_GetItem(i));
    cbCustomMuxer.Items.Add(VideoCapture1.DirectShow_Filters_GetItem(i));
    cbCustomFilewriter.Items.Add(VideoCapture1.DirectShow_Filters_GetItem(i));
  end;
```

```
// C++ MFC
for (int i = 0; i < m_VideoCapture.DirectShow_Filters_GetCount(); i++)
{
  m_CustomDSFilterVCombo.AddString(m_VideoCapture.DirectShow_Filters_GetItem(i));
  m_CustomDSFilterACombo.AddString(m_VideoCapture.DirectShow_Filters_GetItem(i));
  m_CustomMuxerCombo.AddString(m_VideoCapture.DirectShow_Filters_GetItem(i));
  m_CustomFilewriterCombo.AddString(m_VideoCapture.DirectShow_Filters_GetItem(i));
}
```

```
' VB6
For i = 0 To VideoCapture1.DirectShow_Filters_GetCount - 1
  cbCustomDSFilterV.AddItem VideoCapture1.DirectShow_Filters_GetItem(i)
  cbCustomDSFilterA.AddItem VideoCapture1.DirectShow_Filters_GetItem(i)
  cbCustomMuxer.AddItem VideoCapture1.DirectShow_Filters_GetItem(i)
  cbCustomFilewriter.AddItem VideoCapture1.DirectShow_Filters_GetItem(i)
Next i
```

Select multiplexer (mux) filter

```
VideoCapture1.Custom_Output_Mux_Filter_Name := cbCustomMuxer.Items[cbCustomMuxer.ItemIndex];
VideoCapture1.Custom_Output_Mux_Filter_Is_Encoder := cbCustomMuxFilterIsEncoder.Checked;
```

```
// C++ MFC
CString muxerName;
m_CustomMuxerCombo.GetLBText(m_CustomMuxerCombo.GetCurSel(), muxerName);
m_VideoCapture.Custom_Output_Mux_Filter_Name = muxerName;
m_VideoCapture.Custom_Output_Mux_Filter_Is_Encoder = m_CustomMuxFilterIsEncoder.GetCheck();
```

```
' VB6
VideoCapture1.Custom_Output_Mux_Filter_Name = cbCustomMuxer.List(cbCustomMuxer.ListIndex)
VideoCapture1.Custom_Output_Mux_Filter_Is_Encoder = cbCustomMuxFilterIsEncoder.Value
```

If you need a special File Writer filter, you should specify it. This is true for both options described above.

```
VideoCapture1.Custom_Output_Special_FileWriter_Needed := cbUseSpecialFilewriter.Checked;
VideoCapture1.Custom_Output_Special_FileWriter_Filter_Name := cbCustomFilewriter.Items[cbCustomFilewriter.ItemIndex];
```

```
// C++ MFC
m_VideoCapture.Custom_Output_Special_FileWriter_Needed = m_UseSpecialFilewriter.GetCheck();
CString fileWriterName;
m_CustomFilewriterCombo.GetLBText(m_CustomFilewriterCombo.GetCurSel(), fileWriterName);
m_VideoCapture.Custom_Output_Special_FileWriter_Filter_Name = fileWriterName;
```

```
' VB6
VideoCapture1.Custom_Output_Special_FileWriter_Needed = cbUseSpecialFilewriter.Value
VideoCapture1.Custom_Output_Special_FileWriter_Filter_Name = cbCustomFilewriter.List(cbCustomFilewriter.ListIndex)
```

Start capture

```
VideoCapture1.Start;
```

```
// C++ MFC
m_VideoCapture.Start();
```

```
' VB6
VideoCapture1.Start
```

---

Please get in touch with [support](https://support.visioforge.com/) to get help with this tutorial. Visit our [GitHub](https://github.com/visioforge/) page to get more code samples.

---END OF PAGE---


## Deploying TVFVideoCapture Library in Delphi Projects
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/deployment/
**Description:** Deploy TVFVideoCapture in Delphi - install components, register DirectShow filters, configure environment for successful application deployment.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, DirectShow, Windows, VCL, Capture, Encoding, IP Camera, MP4, MP3
**API:** TVFVideoCapture

# Complete TVFVideoCapture Library Deployment Guide

When distributing applications built with the TVFVideoCapture library, you'll need to deploy several framework components to ensure proper functionality on end-user systems. This guide covers all deployment scenarios to help you create reliable installations.

## Deployment Options Overview

You have two primary approaches for deploying the necessary components: automatic installers for simpler deployment or manual installation for more customized setups.

## Automatic Silent Installers (Requires Admin Rights)

These pre-configured installers handle dependencies automatically and can be integrated into your application's installation process:

### Essential Components

- **Base Package** (mandatory for all deployments)
- [Delphi Version](https://files.visioforge.com/redists_delphi/redist_video_capture_base_delphi.exe)
- [ActiveX Version](https://files.visioforge.com/redists_delphi/redist_video_capture_base_ax.exe)

### Optional Feature Components

- **FFMPEG Package** (required for file or IP camera sources)
- [x86 Architecture](https://files.visioforge.com/redists_delphi/redist_video_capture_ffmpeg.exe)
- **MP4 Output Support**
- [x86 Architecture](https://files.visioforge.com/redists_delphi/redist_video_capture_mp4.exe)
- **VLC Source Package** (alternative option for file or IP camera sources)
- [x86 Architecture](https://files.visioforge.com/redists_delphi/redist_video_capture_vlc.exe)

## Manual Installation Process (Requires Admin Rights)

For more control over the deployment process, follow these detailed steps:

### Step 1: Install Required Dependencies

1. Deploy Visual C++ 2010 SP1 redistributables:
2. [x86 Architecture](https://files.visioforge.com/shared/vcredist_2010_x86.exe)
3. [x64 Architecture](https://files.visioforge.com/shared/vcredist_2010_x64.exe)

### Step 2: Deploy Core Components

1. Copy all Media Foundation Platform (MFP) DLLs from the `Redist\Filters` directory to your application folder
2. For ActiveX implementations: copy and register the OCX file using [regsvr32.exe](https://support.microsoft.com/en-us/topic/how-to-use-the-regsvr32-tool-and-troubleshoot-regsvr32-error-messages-a98d960a-7392-e6fe-d90a-3f4e0cb543e5)

### Step 3: Register DirectShow Filters

Using [regsvr32.exe](https://support.microsoft.com/en-us/topic/how-to-use-the-regsvr32-tool-and-troubleshoot-regsvr32-error-messages-a98d960a-7392-e6fe-d90a-3f4e0cb543e5), register these essential DirectShow filters:

- `VisioForge_Audio_Effects_4.ax`
- `VisioForge_Dump.ax`
- `VisioForge_RGB2YUV.ax`
- `VisioForge_Screen_Capture.ax`
- `VisioForge_Video_Effects_Pro.ax`
- `VisioForge_Video_Mixer.ax`
- `VisioForge_Video_Resize.ax`
- `VisioForge_WavDest.ax`
- `VisioForge_YUV2RGB.ax`
- `VisioForge_FFMPEG_Source.ax`

> **Important:** Add the filter directory to the system PATH environment variable if your application executable resides in a different folder.

## Advanced Component Installation

### FFMPEG Integration

1. Copy all files from `Redist\FFMPEG` folder to your deployment
2. Add the FFMPEG folder to the Windows system PATH variable
3. Register all .ax files from the FFMPEG folder

### VLC Integration

1. Copy all files from the `Redist\VLC` folder
2. Register the included .ax file using regsvr32.exe
3. Create an environment variable named `VLC_PLUGIN_PATH` pointing to the `VLC\plugins` directory

### Audio Output Support (LAME)

1. Copy `lame.ax` from the `Redist\Formats` folder
2. Register the `lame.ax` file using regsvr32.exe

### Container Format Support

- **WebM Support:** Install free codecs from [xiph.org](https://www.xiph.org)
- **Matroska Support:** Deploy `Haali Matroska Splitter`

### MP4 Output Configuration

#### Modern Encoder Setup

1. Copy appropriate library files:
2. `libmfxsw32.dll` (for 32-bit deployments)
3. `libmfxsw64.dll` (for 64-bit deployments)
4. Register required components:
5. `VisioForge_H264_Encoder.ax`
6. `VisioForge_MP4_Muxer.ax`
7. `VisioForge_AAC_Encoder.ax`
8. `VisioForge_Video_Resize.ax`

#### Legacy Encoder Setup (for older systems)

1. Copy appropriate library files:
2. `libmfxxp32.dll` (for 32-bit deployments)
3. `libmfxxp64.dll` (for 64-bit deployments)
4. Register required components:
5. `VisioForge_H264_Encoder_XP.ax`
6. `VisioForge_MP4_Muxer_XP.ax`
7. `VisioForge_AAC_Encoder_XP.ax`
8. `VisioForge_Video_Resize.ax`

## Bulk Registration Utility

To simplify DirectShow filter registration, you can use the `reg_special.exe` utility from the framework setup. Place this executable in your filter directory and run it with administrator privileges to register all filters at once.

---

For additional code samples and implementation examples, visit our [GitHub repository](https://github.com/visioforge/). If you encounter any difficulties with deployment, please contact [technical support](https://support.visioforge.com/) for personalized assistance.

---END OF PAGE---


## DV Camcorder Control in Delphi with TVFVideoCapture
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/dv-camcorder/
**Description:** Control DV camcorders in Delphi with TVFVideoCapture - playback, navigation, transport controls with code examples for Delphi, C++, and VB6.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture, DV Camera
**API:** TVFVideoCapture

# Complete Guide to DV Camcorder Control

This developer guide demonstrates how to effectively integrate and control Digital Video (DV) camcorders in your applications using the TVFVideoCapture component. The examples below include implementations for Delphi, C++ MFC, and Visual Basic 6, allowing you to choose the development environment that best suits your project requirements.

## Prerequisites for Implementation

Before using any of the DV control commands, you must initialize your video capture system by starting either the video preview or capture process. This establishes the necessary connection between your application and the DV device.

## DV Transport Control Commands

The following sections provide detailed implementation examples for each of the essential DV transport control functions, allowing you to create professional video manipulation applications.

### Starting Playback

Initiate standard playback of your DV content with the `DV_PLAY` command. This command starts playback at normal speed and is essential for basic video viewing functionality.

```
VideoCapture1.DV_SendCommand(DV_PLAY);
```

```
// C++ MFC
m_VideoCapture.DV_SendCommand(DV_PLAY);
```

```
' VB6
VideoCapture1.DV_SendCommand DV_PLAY
```

### Pausing Video Playback

Temporarily suspend video playback while maintaining the current position with the `DV_PAUSE` command. This is useful for implementing frame analysis or allowing users to examine specific content.

```
VideoCapture1.DV_SendCommand(DV_PAUSE);
```

```
// C++ MFC
m_VideoCapture.DV_SendCommand(DV_PAUSE);
```

```
' VB6
VideoCapture1.DV_SendCommand DV_PAUSE
```

### Stopping Playback

Completely halt playback and reset the DV device to a ready state using the `DV_STOP` command. This typically returns the playback position to the beginning of the current section.

```
VideoCapture1.DV_SendCommand(DV_STOP);
```

```
// C++ MFC
m_VideoCapture.DV_SendCommand(DV_STOP);
```

```
' VB6
VideoCapture1.DV_SendCommand DV_STOP
```

### Advanced Navigation Controls

#### Fast Forward Operation

Rapidly advance through content with the `DV_FF` command. This allows users to quickly navigate to specific sections of the video.

```
VideoCapture1.DV_SendCommand(DV_FF);
```

```
// C++ MFC
m_VideoCapture.DV_SendCommand(DV_FF);
```

```
' VB6
VideoCapture1.DV_SendCommand DV_FF
```

#### Rewind Operation

Move backward through content at high speed with the `DV_REW` command. This function enables efficient navigation to previous sections of video.

```
VideoCapture1.DV_SendCommand(DV_REW);
```

```
// C++ MFC
m_VideoCapture.DV_SendCommand(DV_REW);
```

```
' VB6
VideoCapture1.DV_SendCommand DV_REW
```

## Frame-by-Frame Navigation

For precision video analysis and editing applications, these commands enable frame-accurate navigation.

### Forward Frame Step

Advance exactly one frame forward with the `DV_STEP_FW` command. This enables precise frame analysis and is essential for detailed video editing applications.

```
VideoCapture1.DV_SendCommand(DV_STEP_FW);
```

```
// C++ MFC
m_VideoCapture.DV_SendCommand(DV_STEP_FW);
```

```
' VB6
VideoCapture1.DV_SendCommand DV_STEP_FW
```

### Backward Frame Step

Move exactly one frame backward with the `DV_STEP_REV` command. This complements the forward step function and allows for bidirectional frame-accurate navigation.

```
VideoCapture1.DV_SendCommand(DV_STEP_REV);
```

```
// C++ MFC
m_VideoCapture.DV_SendCommand(DV_STEP_REV);
```

```
' VB6
VideoCapture1.DV_SendCommand DV_STEP_REV
```

## Implementation Best Practices

When integrating DV control functionality into your applications, consider the following practices:

1. Always verify device connectivity before sending commands
2. Implement proper error handling for cases when commands fail
3. Provide visual feedback to users when transport control states change
4. Consider implementing keyboard shortcuts for common DV control operations

## Additional Resources

For more detailed information and advanced implementation techniques, explore our additional documentation and code repositories.

Please contact our support team if you need assistance with implementation. Visit our GitHub repository for additional code samples and example projects.

---END OF PAGE---


## FM Radio and TV Tuning in Delphi — Channel Scanning Guide
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/fm-radio-tv-tuning/
**Description:** Implement FM radio and TV tuning in Delphi - channel scanning, frequency management, signal detection with code examples for Delphi, C++, VB6.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, C++, Windows, VCL, Capture, TV Tuner

# Implementing FM Radio and TV Tuning in Delphi Applications

## Introduction to TV and Radio Tuning

This guide provides detailed implementation examples for Delphi developers working with FM radio and TV tuning functionality. We've included equivalent code samples for C++ MFC and VB6 to support cross-platform development needs.

## Device Management

### Retrieving Available TV Tuners

The first step in implementing tuner functionality is identifying available hardware devices:

```
// Iterate through all connected TV Tuner devices and populate dropdown
for I := 0 to VideoCapture1.TVTuner_Devices_GetCount - 1 do
  cbTVTuner.Items.Add(VideoCapture1.TVTuner_Devices_GetItem(i));
```

```
// C++ MFC implementation for retrieving TV Tuner devices
for (int i = 0; i < m_VideoCapture.TVTuner_Devices_GetCount(); i++)
  m_cbTVTuner.AddString(m_VideoCapture.TVTuner_Devices_GetItem(i));
```

```
' VB6 implementation for device enumeration
For i = 0 To VideoCapture1.TVTuner_Devices_GetCount - 1
  cbTVTuner.AddItem VideoCapture1.TVTuner_Devices_GetItem(i)
Next i
```

### Enumerating TV Format Support

Different regions use different broadcast standards. Your application should detect and handle these formats:

```
// Load available TV formats (PAL, NTSC, SECAM, etc.)
for I := 0 to VideoCapture1.TVTuner_TVFormats_GetCount - 1 do
  cbTVSystem.Items.Add(VideoCapture1.TVTuner_TVFormats_GetItem(i));
```

```
// C++ MFC - Populate TV format dropdown with available standards
for (int i = 0; i < m_VideoCapture.TVTuner_TVFormats_GetCount(); i++)
  m_cbTVSystem.AddString(m_VideoCapture.TVTuner_TVFormats_GetItem(i));
```

```
' VB6 - Get supported TV formats for the selected tuner
For i = 0 To VideoCapture1.TVTuner_TVFormats_GetCount - 1
  cbTVSystem.AddItem VideoCapture1.TVTuner_TVFormats_GetItem(i)
Next i
```

### Country-Specific Configuration

Broadcasting standards vary by country, so your application should provide appropriate region selection:

```
// Load country/region list for localized tuning parameters
for I := 0 to VideoCapture1.TVTuner_Countries_GetCount - 1 do
  cbTVCountry.Items.Add(VideoCapture1.TVTuner_Countries_GetItem(i));
```

```
// C++ MFC - Build country selection list for regional settings
for (int i = 0; i < m_VideoCapture.TVTuner_Countries_GetCount(); i++)
  m_cbTVCountry.AddString(m_VideoCapture.TVTuner_Countries_GetItem(i));
```

```
' VB6 - Populate country dropdown for regional broadcast settings
For i = 0 To VideoCapture1.TVTuner_Countries_GetCount - 1
  cbTVCountry.AddItem VideoCapture1.TVTuner_Countries_GetItem(i)
Next i
```

## Device Configuration

### Selecting a TV Tuner Device

Once you've enumerated the available devices, users can select their preferred tuner:

```
// Set the active tuner device based on user selection
VideoCapture1.TVTuner_Name := cbTVTuner.Items[cbTVTuner.ItemIndex];
```

```
// C++ MFC - Apply user's tuner device selection
CString strText;
m_cbTVTuner.GetLBText(m_cbTVTuner.GetCurSel(), strText);
m_VideoCapture.put_TVTuner_Name(strText);
```

```
' VB6 - Set selected tuner as active device
VideoCapture1.TVTuner_Name = cbTVTuner.Text
```

### Reading Current Tuner Configuration

After selecting a device, you'll need to read its current settings:

```
// Initialize tuner and read current configuration
VideoCapture1.TVTuner_Read;
```

```
// C++ MFC - Load current tuner settings into application
m_VideoCapture.TVTuner_Read();
```

```
' VB6 - Read tuner configuration after device selection
VideoCapture1.TVTuner_Read
```

### Available Operation Modes

Tuners support different modes like TV, FM Radio, etc:

```
// Populate operation mode dropdown with available options
for I := 0 to VideoCapture1.TVTuner_Modes_GetCount - 1 do
  cbTVMode.Items.Add(VideoCapture1.TVTuner_Modes_GetItem(i));
```

```
// C++ MFC - Get supported operational modes for this device
for (int i = 0; i < m_VideoCapture.TVTuner_Modes_GetCount(); i++)
  m_cbTVMode.AddString(m_VideoCapture.TVTuner_Modes_GetItem(i));
```

```
' VB6 - List available tuner modes (TV, FM Radio, etc)
For i = 0 To VideoCapture1.TVTuner_Modes_GetCount - 1
  cbTVMode.AddItem VideoCapture1.TVTuner_Modes_GetItem(i)
Next i
```

## Frequency Management

### Reading Current Frequencies

Display the current audio and video frequencies to provide user feedback:

```
// Display current video and audio frequencies in Hz
edVideoFreq.Text := IntToStr(VideoCapture1.TVTuner_VideoFrequency);
edAudiofreq.Text := IntToStr(VideoCapture1.TVTuner_AudioFrequency);
```

```
// C++ MFC - Show current frequency values in the interface
CString strFreq;
strFreq.Format(_T("%d"), m_VideoCapture.get_TVTuner_VideoFrequency());
m_edVideoFreq.SetWindowText(strFreq);
strFreq.Format(_T("%d"), m_VideoCapture.get_TVTuner_AudioFrequency());
m_edAudioFreq.SetWindowText(strFreq);
```

```
' VB6 - Update frequency display fields with current values
edVideoFreq.Text = CStr(VideoCapture1.TVTuner_VideoFrequency)
edAudioFreq.Text = CStr(VideoCapture1.TVTuner_AudioFrequency)
```

## Input and Mode Configuration

### Setting Signal Input Source

Tuners may support multiple input sources that should be configurable:

```
// Select the appropriate input source based on current configuration
cbTVInput.ItemIndex := cbTVInput.Items.IndexOf(VideoCapture1.TVTuner_InputType);
```

```
// C++ MFC - Update input source selection in UI
CString strInputType = m_VideoCapture.get_TVTuner_InputType();
m_cbTVInput.SetCurSel(m_cbTVInput.FindStringExact(-1, strInputType));
```

```
' VB6 - Set input source dropdown to match current configuration
cbTVInput.ListIndex = cbTVInput.FindItem(VideoCapture1.TVTuner_InputType)
```

### Configuring Operation Mode

Different tuner modes require specific UI and parameter adjustments:

```
// Set operation mode dropdown to current mode (TV, FM Radio, etc)
cbTVMode.ItemIndex := cbTVMode.Items.IndexOf(VideoCapture1.TVTuner_Mode);
```

```
// C++ MFC - Update mode selector to match current tuner configuration
CString strMode = m_VideoCapture.get_TVTuner_Mode();
m_cbTVMode.SetCurSel(m_cbTVMode.FindStringExact(-1, strMode));
```

```
' VB6 - Select current operating mode in dropdown
cbTVMode.ListIndex = cbTVMode.FindItem(VideoCapture1.TVTuner_Mode)
```

### TV Format Configuration

Set the appropriate broadcast standard for the region:

```
// Configure the appropriate TV standard (PAL, NTSC, SECAM, etc)
cbTVSystem.ItemIndex := cbTVSystem.Items.IndexOf(VideoCapture1.TVTuner_TVFormat);
```

```
// C++ MFC - Set TV format dropdown to current broadcast standard
CString strTVFormat = m_VideoCapture.get_TVTuner_TVFormat();
m_cbTVSystem.SetCurSel(m_cbTVSystem.FindStringExact(-1, strTVFormat));
```

```
' VB6 - Update TV system format selection
cbTVSystem.ListIndex = cbTVSystem.FindItem(VideoCapture1.TVTuner_TVFormat)
```

### Regional Settings

Configure region-specific broadcast parameters:

```
// Set country/region for appropriate frequency tables and standards
cbTVCountry.ItemIndex := cbTVCountry.Items.IndexOf(VideoCapture1.TVTuner_Country);
```

```
// C++ MFC - Update country selection to match current setting
CString strCountry = m_VideoCapture.get_TVTuner_Country();
m_cbTVCountry.SetCurSel(m_cbTVCountry.FindStringExact(-1, strCountry));
```

```
' VB6 - Set country dropdown to current regional setting
cbTVCountry.ListIndex = cbTVCountry.FindItem(VideoCapture1.TVTuner_Country)
```

## Channel Scanning

### Handling Channel Scan Events

Implement the event handler for channel scanning process:

```
// Event handler for channel scanning process
// Tracks progress and collects found channels
procedure TForm1.VideoCapture1TVTunerTuneChannels(SignalPresent: Boolean; Channel, Frequency, Progress: Integer);
begin
  // Update progress bar with current scan progress
  pbChannels.Position := Progress;

  // Add channel to list if signal is detected
  if SignalPresent then
    cbTVChannel.Items.Add(IntToStr(Channel));

  // Scan complete when Channel = -1
  if Channel = -1 then
    begin
      pbChannels.Position := 0;
      ShowMessage('AutoTune complete');
    end;
end;
```

```
// C++ MFC - Channel scan event handler implementation
// In header file (.h)
BEGIN_EVENTSINK_MAP(CMainDlg, CDialog)
    ON_EVENT(CMainDlg, IDC_VIDEOCAPTURE, 1, OnTVTunerTuneChannels, VTS_BOOL VTS_I4 VTS_I4 VTS_I4)
END_EVENTSINK_MAP()

// In implementation file (.cpp)
void CMainDlg::OnTVTunerTuneChannels(BOOL SignalPresent, long Channel, long Frequency, long Progress)
{
    // Update scan progress indicator
    m_pbChannels.SetPos(Progress);

    // Add found channels to the selection list
    if (SignalPresent)
    {
        CString strChannel;
        strChannel.Format(_T("%d"), Channel);
        m_cbTVChannel.AddString(strChannel);
    }

    // Handle scan completion
    if (Channel == -1)
    {
        m_pbChannels.SetPos(0);
        MessageBox(_T("AutoTune complete"), _T("Information"), MB_OK | MB_ICONINFORMATION);
    }
}
```

```
' VB6 - Channel scan event handler
Private Sub VideoCapture1_TVTunerTuneChannels(ByVal SignalPresent As Boolean, ByVal Channel As Long, ByVal Frequency As Long, ByVal Progress As Long)
    ' Update scan progress display
    pbChannels.Value = Progress

    ' Add channel to list when signal is found
    If SignalPresent Then
        cbTVChannel.AddItem CStr(Channel)
    End If

    ' Handle scan completion
    If Channel = -1 Then
        pbChannels.Value = 0
        MsgBox "AutoTune complete", vbInformation
    End If
End Sub
```

### Initiating Channel Scan

Start the automatic channel scanning process:

```
// Define frequency constants for clarity
const KHz = 1000;
const MHz = 1000000;

// Initialize tuner with current settings
VideoCapture1.TVTuner_Read;
// Clear previous channel list
cbTVChannel.Items.Clear;

// Configure special parameters for FM Radio scanning
if ( (cbTVMode.ItemIndex <> -1) and (cbTVMode.Items[cbTVMode.ItemIndex] = 'FM Radio') ) then
  begin
    // Set frequency range for FM scanning (100-110MHz)
    VideoCapture1.TVTuner_FM_Tuning_StartFrequency := 100 * MHz;
    VideoCapture1.TVTuner_FM_Tuning_StopFrequency := 110 * MHz;
    // Set 100KHz increments for FM scanning
    VideoCapture1.TVTuner_FM_Tuning_Step := 100 * KHz;
  end;

// Begin automatic channel scan
VideoCapture1.TVTuner_TuneChannels_Start;
```

```
// C++ MFC - Initiate channel scan with appropriate parameters
const int KHz = 1000;
const int MHz = 1000000;

// Update tuner configuration
m_VideoCapture.TVTuner_Read();
// Reset channel list before scanning
m_cbTVChannel.ResetContent();

// Configure FM-specific parameters if in radio mode
CString strMode;
m_cbTVMode.GetLBText(m_cbTVMode.GetCurSel(), strMode);
if (strMode == _T("FM Radio"))
{
    // Set FM scan range (100-110MHz)
    m_VideoCapture.put_TVTuner_FM_Tuning_StartFrequency(100 * MHz);
    m_VideoCapture.put_TVTuner_FM_Tuning_StopFrequency(110 * MHz);
    // Use 100KHz steps for FM scanning
    m_VideoCapture.put_TVTuner_FM_Tuning_Step(100 * KHz);
}

// Start the channel scanning process
m_VideoCapture.TVTuner_TuneChannels_Start();
```

```
' VB6 - Begin channel scanning process
Const KHz = 1000
Const MHz = 1000000

' Read current tuner configuration
VideoCapture1.TVTuner_Read
' Clear existing channel list
cbTVChannel.Clear

' Special configuration for FM Radio scanning
If (cbTVMode.ListIndex <> -1) And (cbTVMode.Text = "FM Radio") Then
    ' Set FM band scan parameters (100-110MHz)
    VideoCapture1.TVTuner_FM_Tuning_StartFrequency = 100 * MHz
    VideoCapture1.TVTuner_FM_Tuning_StopFrequency = 110 * MHz
    ' Use 100KHz step size for FM scanning
    VideoCapture1.TVTuner_FM_Tuning_Step = 100 * KHz
End If

' Initiate automatic channel scan
VideoCapture1.TVTuner_TuneChannels_Start
```

## Manual Tuning Operations

### Setting Channel by Number

Allow direct channel selection by number:

```
// Change to specified channel number
VideoCapture1.TVTuner_Channel := StrToInt(edChannel.Text);
// Apply tuning changes
VideoCapture1.TVTuner_Apply;
```

```
// C++ MFC - Set tuner to specified channel number
CString strChannel;
m_edChannel.GetWindowText(strChannel);
m_VideoCapture.put_TVTuner_Channel(_ttoi(strChannel));
m_VideoCapture.TVTuner_Apply();
```

```
' VB6 - Tune to specific channel number
VideoCapture1.TVTuner_Channel = CInt(edChannel.Text)
VideoCapture1.TVTuner_Apply
```

### Setting Radio Frequency Directly

For FM radio, direct frequency tuning is often required:

```
// Set channel to -1 for frequency-based tuning
VideoCapture1.TVTuner_Channel := -1; // must be -1 to use frequency
// Set specific frequency from input field
VideoCapture1.TVTuner_Frequency := StrToInt(edChannel.Text);
// Apply frequency change
VideoCapture1.TVTuner_Apply;
```

```
// C++ MFC - Direct frequency tuning implementation
CString strFrequency;
m_edChannel.GetWindowText(strFrequency);
// Set channel to -1 to enable frequency-based tuning
m_VideoCapture.put_TVTuner_Channel(-1); // must be -1 to use frequency
// Apply the specified frequency
m_VideoCapture.put_TVTuner_Frequency(_ttoi(strFrequency));
m_VideoCapture.TVTuner_Apply();
```

```
' VB6 - Manual frequency tuning for radio
VideoCapture1.TVTuner_Channel = -1 ' must be -1 to use frequency
VideoCapture1.TVTuner_Frequency = CInt(edChannel.Text)
VideoCapture1.TVTuner_Apply
```

## Conclusion

This guide covers the essential aspects of implementing FM radio and TV tuning functionality in your Delphi applications. By following these examples, you can create robust tuning interfaces with proper channel scanning, frequency management, and signal detection.

For optimal integration into your projects, remember to handle error conditions and provide appropriate user feedback during lengthy operations such as channel scanning.

---

Please visit our [GitHub](https://github.com/visioforge/) page for additional code samples and implementation examples.

---END OF PAGE---


## Camera Brightness, Contrast and Saturation Control in Delphi
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/hardware-adjustments/
**Description:** Adjust camera brightness, contrast, and saturation in Delphi with TVFVideoCapture hardware controls and parameter configuration examples.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture

# Implementing Hardware Video Adjustments in Delphi Applications

## Overview

Modern video capture devices offer powerful hardware-level adjustments that can significantly enhance the quality of your video applications. By leveraging these capabilities in your Delphi applications, you can provide users with professional-grade video control features without complex software-based image processing.

## Supported Adjustment Types

Most webcams and video capture devices support several adjustment parameters:

- Brightness
- Contrast
- Saturation
- Hue
- Sharpness
- Gamma
- White balance
- Gain

## Retrieving Available Adjustment Ranges

Before setting adjustments, you'll need to determine what ranges are supported by the connected device. The `Video_CaptureDevice_VideoAdjust_GetRanges` method provides this information.

### Delphi Implementation

```
// Retrieve the available range for brightness adjustment
// Returns minimum, maximum, step size, default value, and auto-adjustment capability
VideoCapture1.Video_CaptureDevice_VideoAdjust_GetRanges(adj_Brightness, min, max, step, default, auto);
```

### C++ MFC Implementation

```
// C++ MFC implementation for getting brightness adjustment ranges
// Store results in integer variables for UI configuration
int min, max, step, default_value;
BOOL auto_value;
m_VideoCapture.Video_CaptureDevice_VideoAdjust_GetRanges(
  TxVFVideoCapAdjust::adj_Brightness,
  &min,
  &max,
  &step,
  &default_value,
  &auto_value);
```

### VB6 Implementation

```
' VB6 implementation for retrieving brightness adjustment parameters
' Use these values to configure slider controls and checkboxes
Dim min As Integer, max As Integer, step As Integer, default_val As Integer
Dim auto_val As Boolean
VideoCapture1.Video_CaptureDevice_VideoAdjust_GetRanges adj_Brightness, min, max, step, default_val, auto_val
```

## Setting Adjustment Values

Once you've determined the available ranges, you can use the `Video_CaptureDevice_VideoAdjust_SetValue` method to apply specific settings to the video stream.

### Delphi Implementation

```
// Set the brightness level based on trackbar position
// The third parameter enables/disables automatic brightness adjustment
VideoCapture1.Video_CaptureDevice_VideoAdjust_SetValue(
  adj_Brightness,
  tbAdjBrightness.Position,
  cbAdjBrightnessAuto.Checked);
```

### C++ MFC Implementation

```
// C++ MFC implementation for setting brightness value
// Uses slider position for manual adjustment value
// Checkbox state determines if auto-adjustment is enabled
m_VideoCapture.Video_CaptureDevice_VideoAdjust_SetValue(
  TxVFVideoCapAdjust::adj_Brightness,
  m_sliderBrightness.GetPos(),
  m_checkBrightnessAuto.GetCheck() == BST_CHECKED);
```

### VB6 Implementation

```
' VB6 implementation for applying brightness settings
' Uses trackbar value for adjustment level
' Checkbox value determines automatic adjustment mode
VideoCapture1.Video_CaptureDevice_VideoAdjust_SetValue _
  adj_Brightness, _
  tbAdjBrightness.Value, _
  cbAdjBrightnessAuto.Value = vbChecked
```

## Best Practices for Video Adjustment Implementation

When implementing video adjustments in your applications:

1. Always check device capabilities first, as not all devices support all adjustment types
2. Provide intuitive UI controls like sliders with appropriate min/max values
3. Include auto-adjustment options when available
4. Consider saving user preferences for future sessions
5. Implement real-time preview so users can see the effects of their adjustments

## Additional Resources

Please contact our support team for assistance with implementing these features in your application. Visit our GitHub repository for additional code samples and implementation examples.

---END OF PAGE---


## Delphi Video Capture SDK - TVFVideoCapture Full Guide
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/
**Description:** Build Delphi video and audio capture apps with TVFVideoCapture, including device enumeration, preview, MP4/AVI recording, screen capture, and IP cameras.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture, Streaming
**API:** TVFVideoCapture

# Video Capture SDK for Delphi

[Video Capture SDK Delphi](https://www.visioforge.com/all-in-one-media-framework)

This section covers using the Video Capture SDK with Delphi to build video and audio capture applications. The `TVFVideoCapture` component (declared in `VideoCaptureMain.pas`) is a `TCustomPanel` descendant, so it both renders the preview surface and exposes the full capture API as published properties, methods, and events.

## Main Component

### TVFVideoCapture

`TVFVideoCapture` provides complete video and audio capture functionality. You can drop it on a form from the IDE palette or create it at runtime. As it descends from `TCustomPanel`, set `Parent` and `Align` like any other VCL container.

```
var
  VideoCapture1: TVFVideoCapture;
begin
  VideoCapture1 := TVFVideoCapture.Create(Self);
  VideoCapture1.Parent := Panel1;
  VideoCapture1.Align := alClient;
end;
```

## Device Enumeration

Populate combo boxes with the video and audio capture devices discovered on the host. The SDK exposes `_GetCount` / `_GetItem(Index)` pairs for every device list.

```
procedure TForm1.EnumerateDevices;
var
  i: Integer;
begin
  // Video capture devices
  cbVideoDevices.Clear;
  for i := 0 to VideoCapture1.Video_CaptureDevices_GetCount - 1 do
    cbVideoDevices.Items.Add(VideoCapture1.Video_CaptureDevices_GetItem(i));

  // Audio capture devices
  cbAudioDevices.Clear;
  for i := 0 to VideoCapture1.Audio_CaptureDevices_GetCount - 1 do
    cbAudioDevices.Items.Add(VideoCapture1.Audio_CaptureDevices_GetItem(i));
end;
```

## Preview

Switch the component to `Mode_Video_Preview` to render live video to the panel without writing anything to disk. Audio monitoring is controlled by `Audio_PlayAudio`.

```
procedure TForm1.StartPreview;
begin
  // Select devices by display name
  VideoCapture1.Video_CaptureDevice := cbVideoDevices.Text;
  VideoCapture1.Audio_CaptureDevice := cbAudioDevices.Text;

  // Preview mode (no file output)
  VideoCapture1.Mode := Mode_Video_Preview;
  VideoCapture1.Audio_PlayAudio := True;

  VideoCapture1.Start;
end;

procedure TForm1.StopPreview;
begin
  VideoCapture1.Stop;
end;
```

## Capturing to a File

Switch to `Mode_Video_Capture` and assign `Output_Filename` and `Output_Format`. The `TVFOutputFormat` enum lists every container the component can write (`Format_MP4`, `Format_AVI`, `Format_WMV`, `Format_DV`, `Format_WebM`, `Format_FFMPEG`, `Format_FFMPEGX`, and so on).

```
procedure TForm1.StartCapture;
begin
  VideoCapture1.Video_CaptureDevice := cbVideoDevices.Text;
  VideoCapture1.Audio_CaptureDevice := cbAudioDevices.Text;
  VideoCapture1.Audio_RecordAudio := True;

  // Output file and container
  VideoCapture1.Output_Filename := 'C:\Videos\capture.mp4';
  VideoCapture1.Output_Format := Format_MP4;

  // Switch to capture mode
  VideoCapture1.Mode := Mode_Video_Capture;

  VideoCapture1.Start;
end;
```

You can change the output file on the fly without stopping the graph by calling `OutputFilename_ChangeOnTheFly`.

## Snapshots

Save the current preview frame to disk in any of the supported `TVFImageFormat` values (`IM_BMP`, `IM_JPEG`, `IM_PNG`, `IM_GIF`, `IM_TIFF`). The third parameter is the JPEG quality (ignored for other formats).

```
procedure TForm1.TakeSnapshot;
begin
  VideoCapture1.Frame_Save('C:\Photos\snapshot.jpg', IM_JPEG, 85);
end;
```

To pull the frame straight into a `TBitmap` (for example to display in a `TImage`), use `Frame_GetCurrent`:

```
procedure TForm1.TakeSnapshotToMemory;
var
  Bitmap: TBitmap;
begin
  Bitmap := TBitmap.Create;
  try
    VideoCapture1.Frame_GetCurrent(Bitmap);
    Image1.Picture.Assign(Bitmap);
  finally
    Bitmap.Free;
  end;
end;
```

## IP Cameras (RTSP / HTTP)

Switch the mode to `Mode_IP_Preview` or `Mode_IP_Capture` and set `IP_Camera_URL`. Use `IP_Camera_Type` to pick the engine and protocol — for example `IP_RTSP_TCP` for RTSP over TCP via the FFmpeg engine, or `IP_Auto_VLC` to fall back to the bundled VLC source.

```
procedure TForm1.ConnectIPCamera;
begin
  VideoCapture1.IP_Camera_URL := 'rtsp://user:password@192.168.1.100:554/stream';
  VideoCapture1.IP_Camera_Type := IP_RTSP_TCP;
  VideoCapture1.Mode := Mode_IP_Preview;
  VideoCapture1.Start;
end;
```

## Screen Capture

The component records the desktop, an individual display, a region, or a window. Set the capture rectangle (or enable full-screen), choose a frame rate, then switch to `Mode_Screen_Capture`.

```
procedure TForm1.StartScreenCapture;
begin
  // Full-screen capture at 30 fps with the mouse cursor included
  VideoCapture1.Screen_Capture_FullScreen := True;
  VideoCapture1.Screen_Capture_FrameRate := 30.0;
  VideoCapture1.Screen_Capture_Grab_Mouse_Cursor := True;

  VideoCapture1.Output_Filename := 'C:\Videos\screen.mp4';
  VideoCapture1.Output_Format := Format_MP4;

  VideoCapture1.Mode := Mode_Screen_Capture;
  VideoCapture1.Start;
end;
```

For region capture, disable `Screen_Capture_FullScreen` and supply `Screen_Capture_Left`, `Screen_Capture_Top`, `Screen_Capture_Right`, and `Screen_Capture_Bottom` (all in pixels). See [Screen Capture Implementation](screen-capture/) for the full set of options.

## Video Effects

Effects (brightness, contrast, saturation, flip, blur, grayscale, sepia, and many more) are managed with `Video_Effect_Ex`. Enable the effects pipeline first with `Video_Effects_Enabled := True`, then add each effect by `TVFEffectType`. The `Amount` argument is the strength of the effect — for `ef_contrast` it shifts contrast, for `ef_flip_right` it acts as an on/off flag, and so on.

```
procedure TForm1.ApplyVideoEffects;
begin
  VideoCapture1.Video_Effects_Enabled := True;

  // ID=1, applied for the full graph (StartTime=0, StopTime=0), enabled,
  // contrast effect with amount = 20
  VideoCapture1.Video_Effect_Ex(1, 0, 0, True, ef_contrast, 20.0, '');

  // ID=2, horizontal flip
  VideoCapture1.Video_Effect_Ex(2, 0, 0, True, ef_flip_right, 0.0, '');
end;
```

Remove individual effects with `Video_Effects_Remove(ID)` or clear them all with `Video_Effects_Clear`.

## Text Overlay

Use `Video_Effects_Text_Logo` (legacy GDI overlay) or `Video_Effects_Text_Logo_Plus` (modern GDI+ overlay with gradients, rotation, and outline effects) to burn text into the video stream. The example below uses `Video_Effects_Text_Logo_Plus`.

```
procedure TForm1.AddTextOverlay;
begin
  VideoCapture1.Video_Effects_Enabled := True;

  // ID=10, full duration (0..0), enabled, "My Video" at (10, 10),
  // Arial 24, not bold/italic/underline/strike-out, white color
  VideoCapture1.Video_Effects_Text_Logo_Plus(
    10, 0, 0, True, 'My Video', 10, 10,
    'Arial', 24, False, False, False, False, clWhite);
end;
```

## Events

`TVFVideoCapture` raises three core lifecycle events: `OnStart`, `OnStop`, and `OnError`. None of them carry a `Sender` parameter — `OnError` receives the error message as a `WideString`.

```
procedure TForm1.VideoCapture1Start;
begin
  Button1.Caption := 'Stop';
end;

procedure TForm1.VideoCapture1Stop;
begin
  Button1.Caption := 'Start';
end;

procedure TForm1.VideoCapture1Error(ErrorText: WideString);
begin
  ShowMessage('Capture error: ' + ErrorText);
end;
```

Additional events cover live frame access (`OnVideoFrame`, `OnAudioFrame`), motion detection (`OnMotion`), mouse and keyboard activity on the preview surface, VU-meter values, DV transport events, and TV-tuner channel scanning.

## Development Resources

For detailed implementation guidance, explore these essential resources:

- [Complete Changelog and Version History](changelog/)
- [Installation and Configuration Guide](install/)
- [Deployment Best Practices](deployment/)
- [Licensing Information and EULA](../../eula/)
- [Comprehensive API Documentation](https://api.visioforge.org/delphi/video_capture_sdk/index.html)

## Implementation Tutorials

### Audio Recording and Processing

Master audio capture with these step-by-step guides:

- [MP3 Audio Capture Implementation](audio-capture-mp3/) - Learn how to capture audio streams and encode them directly to MP3 format with configurable bitrates and quality settings.
- [WAV Audio Recording with Compression Options](audio-capture-wav/) - Implement high-quality WAV audio recording with optional compression codecs and format configurations.
- [Configuring Audio Output Devices](audio-output/) - Guide to selecting and configuring audio output devices for monitoring and playback in your applications.

### Video Capture and Device Control

Learn essential video handling techniques:

- [AVI Video Capture Implementation](video-capture-avi/) - Develop applications that capture video streams to AVI format with customizable codecs and container settings.
- [DV Camcorder Control and Integration](dv-camcorder/) - Connect and control DV camcorders through FireWire/IEEE-1394 with transport controls and metadata handling.
- [Device Selection for Video and Audio Sources](video-audio-sources/) - Techniques for enumerating, selecting, and managing multiple capture devices in your applications.
- [Hardware Video Adjustment Parameters](hardware-adjustments/) - Access and modify device-level parameters including brightness, contrast, saturation, and white balance.
- [Video Input Configuration via Crossbar](video-input-crossbar/) - Learn to configure video input routing through crossbar interfaces for multi-input capture devices.
- [Video Renderer Selection and Configuration](video-renderer/) - Choose and configure the optimal video rendering engine for your capture application.

### Advanced Media Techniques

Explore sophisticated implementation scenarios:

- [Custom Output Format Configuration](custom-output/) - Create specialized output formats with custom compression settings and container configurations.
- [FM Radio and TV Tuner Integration](fm-radio-tv-tuning/) - Implement FM radio reception and TV channel tuning in applications with supported hardware.
- [Network Streaming with WMV Format](network-streaming-wmv/) - Stream captured video over networks using Windows Media Video format with bandwidth optimization.
- [Resolution Management with Resize and Crop](resize-crop/) - Process video frames with dynamic resizing and cropping to achieve custom output dimensions.
- [Screen Capture Implementation](screen-capture/) - Capture on-screen content with configurable frame rates and region selection capabilities.
- [DV File Capture with Compression Options](video-capture-dv/) - Save video directly to DV format or with recompression for optimized storage requirements.
- [MPEG-2 Capture with TV Tuner Integration](mpeg2-capture/) - Utilize hardware MPEG-2 encoders in TV tuners for efficient high-quality broadcast capture.
- [Windows Media Video Capture with External Profiles](video-capture-wmv/) - Implement Windows Media Video encoding with external profile configurations for optimized quality and size.

---END OF PAGE---


## Install TVFVideoCapture ActiveX Control in C++ Builder
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/install/builder/
**Description:** Import and configure TVFVideoCapture ActiveX control in C++ Builder 5/6, 2006, and newer versions with detailed installation steps.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture
**API:** TVFVideoCapture

# TVFVideoCapture Integration Guide for C++ Builder

This detailed installation guide walks you through the process of integrating the powerful TVFVideoCapture ActiveX control with your C++ Builder projects. We've provided separate instructions for different C++ Builder versions to ensure seamless implementation regardless of your development environment.

> Related products: [All-in-One Media Framework (Delphi / ActiveX)](https://www.visioforge.com/all-in-one-media-framework)

## Installation in Borland C++ Builder 5/6

Follow these detailed steps to properly install the TVFVideoCapture control in Borland C++ Builder 5/6:

1. Navigate to the main menu and select **Component → Import ActiveX Controls**

1. From the available controls list, locate and select the **VisioForge Video Capture** item
2. Click the **Install** button to begin importing the ActiveX control

1. When prompted for confirmation, click the **Yes** button to proceed

1. Once the installation process completes successfully, you'll see a confirmation message
2. Click the **OK** button to finalize the installation

## Installation in C++ Builder 2006 and Later Versions

For more recent versions of C++ Builder (2006 and newer), follow this expanded installation process:

### Step 1: Create a New Package

Begin by creating a new package that will contain the TVFVideoCapture control

### Step 2: Import the ActiveX Component

1. From the main menu, select **Component → Import Component**

1. In the dialog that appears, select the **Import ActiveX Control** radio button
2. Click the **Next** button to continue

### Step 3: Select the TVFVideoCapture Control

1. Browse through the available ActiveX controls
2. Locate and select the **VisioForge Video Capture** item from the list
3. Click the **Next** button to proceed

### Step 4: Configure Output Settings

1. Specify the desired package output folder for the component files
2. Click the **Next** button after selecting an appropriate location

### Step 5: Add Component to Package

1. Ensure the **Add unit to…** radio button is selected
2. Click the **Finish** button to complete the import process

### Step 6: Save and Install the Package

1. Save your project when prompted

1. Install the package to make the component available in your development environment

1. Verify that the TVFVideoCapture ActiveX control has been successfully installed

## Additional Resources and Support

After completing the installation, you can begin using the TVFVideoCapture control in your applications. The component provides extensive functionality for video capture and processing operations.

For developers looking to explore additional implementation examples and techniques:

- Access our [GitHub repository](https://github.com/visioforge/) for code samples and example projects
- Contact our [technical support team](https://support.visioforge.com/) for personalized assistance with integration challenges
- Review our documentation for detailed API references and advanced usage scenarios

By following this installation guide, you'll have successfully integrated the TVFVideoCapture ActiveX control into your C++ Builder development environment, enabling powerful video capture capabilities in your applications.

---END OF PAGE---


## TVFVideoCapture Installation Guide for Delphi 6 to 11
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/install/delphi/
**Description:** Install TVFVideoCapture packages in Delphi 6/7 through Delphi 11+ with complete setup instructions, library paths, and configuration.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture
**API:** TVFVideoCapture

# Comprehensive TVFVideoCapture Installation Guide for Delphi Developers

> Related products: [All-in-One Media Framework (Delphi / ActiveX)](https://www.visioforge.com/all-in-one-media-framework)

## Installation in Borland Delphi 6/7

The installation process for legacy Delphi 6/7 environments requires several specific steps to ensure proper integration of the TVFVideoCapture library.

### Step 1: Create a New Package

Begin by creating a new package in your Delphi 6/7 development environment.

### Step 2: Configure Library Paths

Add the TVFVideoCapture package folder (`Video Capture\Packages\Delphi <version>`, which holds the precompiled `.dcu` units) to both the library and browsing path settings. This allows Delphi to locate the necessary component files.

### Step 3: Open the Library Package

Navigate to and open the library package file to prepare for installation.

### Step 4: Install the Component Package

Complete the installation by selecting the install option within the package interface.

### Architecture Limitations

While TVFVideoCapture offers both x86 and x64 architecture support, Delphi 6/7 only supports x86 due to platform limitations. Developers using these versions will need to utilize the 32-bit implementation exclusively.

## Installation Process for Delphi 2005 and Later Versions

Modern Delphi versions offer an improved installation workflow with enhanced capabilities.

### Step 1: Launch Delphi with Administrative Privileges

Ensure you run your Delphi IDE with administrative rights to prevent permission-related installation issues.

### Step 2: Access Options Dialog

Navigate to the Options menu to configure essential library settings.

### Step 3: Configure Source Directory Paths

Add the TVFVideoCapture package folder (`Video Capture\Packages\Delphi <version>`, which holds the precompiled `.dcu` units) to both the library and browsing path settings to ensure proper component discovery.

### Step 4: Open the Component Library Package

Locate and open the library package file included with TVFVideoCapture.

### Step 5: Complete Package Installation

Install the package through the IDE's package installation interface.

## Advanced Installation for Delphi 11 and Newer Releases

The latest Delphi versions require a slightly different approach that leverages modern project structures.

### Step 1: Locate and Open the Package Project

After installing the framework, navigate to the `Video Capture\Packages\Delphi <version>` folder in the installation directory and open the `VisioForge_VideoCapture_Package.dproj` package project.

### Step 2: Select the Appropriate Build Configuration

Choose the Release build configuration to ensure optimal component performance.

### Step 3: Install the Component Package

Complete the installation process through the IDE's package installation interface.

### Step 4: Verify Installation Success

Confirm that the installation completed successfully before proceeding with development.

## Project Configuration Requirements and Best Practices

### Multi-Architecture Support

TVFVideoCapture supports both x86 and x64 architectures, allowing you to develop applications for different platform targets. You can install both package versions simultaneously to support flexible deployment scenarios.

### Library Path Configuration

For proper component functionality, ensure that you've configured the correct library folder path in your application project settings. This path should point to the location containing the `.dcu` files for your target architecture.

To set this up: 1. Open your project options dialog 2. Navigate to the Library path section 3. Add the appropriate TVFVideoCapture library path 4. Save your project settings

This configuration ensures that your application can locate all required component resources during both development and runtime.

## Troubleshooting Common Installation Issues

When installing TVFVideoCapture, developers might encounter several known issues. Here are solutions to the most frequent problems:

### 64-bit Package Installation Problems

If you're having difficulties installing the 64-bit package version, refer to our [detailed guide for resolving Delphi 64-bit package installation issues](../../../general/install-64bit/).

### Resource File (.otares) Installation Issues

Some developers encounter problems related to `.otares` files during package installation. For a step-by-step resolution process, see our [troubleshooting guide for .otares installation problems](../../../general/install-otares/).

## Technical Support and Additional Resources

For developers requiring additional assistance with the installation process or component implementation:

- Contact our [technical support team](https://support.visioforge.com/) for personalized installation assistance
- Visit our [GitHub repository](https://github.com/visioforge/) for additional code samples and implementation examples
- Check our documentation for advanced usage scenarios and integration patterns

Following this installation guide will ensure that you have a properly configured development environment for creating powerful multimedia applications with TVFVideoCapture in your Delphi projects.

---END OF PAGE---


## Install TVFVideoCapture in Delphi, VB6, and C++ Builder
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/install/
**Description:** Install TVFVideoCapture library in Delphi, Visual Studio, C++ Builder, and VB6 with step-by-step IDE setup and ActiveX integration.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture
**API:** TVFVideoCapture

# TVFVideoCapture Installation Guide

## Installation

1. **Download the latest version of the VisioForge All-in-One Media Framework**: Navigate to the [product page](https://www.visioforge.com/all-in-one-media-framework) on our official website and download the most up-to-date version of the TVFVideoCapture library. Ensure that you select the appropriate version that matches your development environment requirements.
2. **Run the setup file**: After the download completes, locate the setup file in your download directory and execute it. This will launch the installation process.
3. **Follow the installation wizard instructions**: The setup wizard will guide you through the installation steps. Carefully read each prompt, accept the license agreement, choose the installation directory, and proceed by clicking "Next".
4. **Completion**: Upon successful installation, go to the installation folder. Here, you will find a variety of framework samples and detailed documentation designed to assist you in integrating and utilizing the library effectively within your projects.

### Delphi packages installation

For detailed instructions on installing the TVFVideoCapture packages in your Delphi IDE, please refer to the following [Delphi installation guide](delphi/).

### ActiveX installation

#### C++ Builder

For [C++ Builder](builder/), the installation process involves importing the ActiveX control into your project. This straightforward process ensures that you can quickly start using the TVFVideoCapture library in your C++ Builder projects.

#### Visual Basic 6

In [Visual Basic 6](visual-basic-6/), open your project and go to the "Project" menu. Select "Components" and click "Browse". Find `VisioForge_Video_Capture.ocx` in the `Redist` folder of the installation and add it to your project. The components will now be available in the toolbox for your VB6 applications.

### Visual Studio 2010 and later

For [Visual Studio 2010 and newer](visual-studio/) versions, open your project in the IDE, right-click on the toolbox, and select "Choose Items". Navigate to the COM components tab, click "Browse", and select `VisioForge_Video_Capture.ocx` from the `Redist` folder (or `Redist\x64` for 64-bit) of the framework installation directory. This will add the components to your toolbox, allowing you to use them in your Visual Studio projects.

## Conclusion

By following this comprehensive guide, you should be able to smoothly install and integrate the TVFVideoCapture library into your chosen development environment. Should you encounter any issues or require further assistance, please refer to the detailed documentation included in the framework or contact our support team.

---END OF PAGE---


## Installing TVFVideoCapture in VB6 for Delphi Users
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/install/visual-basic-6/
**Description:** Integrate TVFVideoCapture ActiveX control in Visual Basic 6 with x86 compatibility and full video capture feature access.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture
**API:** TVFVideoCapture

# Integrating TVFVideoCapture with Visual Basic 6

## Overview and Compatibility

Microsoft Visual Basic 6 offers excellent compatibility with our TVFVideoCapture library through its ActiveX control interface. This integration empowers developers to significantly enhance their applications with advanced video capture capabilities while maintaining optimal performance characteristics.

Due to the architecture of Visual Basic 6, which was developed during the early stages of Windows programming frameworks, the platform exclusively supports 32-bit applications. Consequently, only the x86 version of our TVFVideoCapture library is compatible with VB6 development environments.

Despite this architectural limitation, our framework delivers exceptional performance within the 32-bit environment. The library provides full access to our comprehensive feature set, ensuring developers can implement sophisticated video capture solutions regardless of the 32-bit constraint.

## Detailed Installation Process

The following step-by-step guide will walk you through the complete process of installing and configuring the TVFVideoCapture ActiveX control in your Visual Basic 6 development environment.

### Step 1: Create a New Project Environment

Begin by launching Visual Basic 6 and creating a new standard project that will serve as the foundation for your video capture implementation.

### Step 2: Access the Components Dialog

Navigate to the Project menu and select the "Components" option to open the component selection dialog. This interface allows you to browse and select from available ActiveX controls.

### Step 3: Select the TVFVideoCapture Component

In the Components dialog, scroll through the available controls and locate the "VisioForge Video Capture" item. Check the box next to it to include this component in your toolbox.

### Step 4: Verify Successful Integration

After adding the component, you should notice the new TVFVideoCapture control appearing in your VB6 toolbox. This confirms that the ActiveX control has been successfully integrated into your development environment.

## Implementation Considerations

When implementing the TVFVideoCapture control in your VB6 application, consider the following best practices:

- Initialize the control early in your application lifecycle
- Configure capture parameters before starting the capture process
- Implement proper error handling for device connectivity issues
- Release resources when they are no longer needed

## Technical Support and Additional Resources

---

For technical questions or implementation challenges, please contact our [support team](https://support.visioforge.com/) who specialize in assisting developers with integration requirements. For additional code examples and implementation patterns, visit our [GitHub repository](https://github.com/visioforge/) which contains numerous samples demonstrating optimal usage patterns.

---END OF PAGE---


## Install TVFVideoCapture ActiveX Control in Visual Studio
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/install/visual-studio/
**Description:** Install TVFVideoCapture ActiveX controls in Visual Studio 2010+ with C++ and managed code integration for video capture projects.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture
**API:** TVFVideoCapture

# Installing TVFVideoCapture in Visual Studio 2010 and Later

## Overview of TVFVideoCapture Integration

The TVFVideoCapture ActiveX control provides powerful video capture capabilities for your development projects. This guide walks you through the installation process in Visual Studio environments, with special considerations for Delphi developers.

## Installation Requirements

Before beginning the installation process, ensure you have:

- Visual Studio 2010 or a later version installed
- Administrator rights on your development machine
- Both x86 and x64 ActiveX controls registered (if applicable)

## Installation Process for Different Project Types

You can implement the TVFVideoCapture ActiveX control directly in various project types. The integration approach differs slightly depending on your development environment:

### For C++ Projects

In C++ projects, you can use the ActiveX control directly without additional wrappers or interfaces.

### For C#/VB.Net Projects

When working with C# or Visual Basic .NET projects, Visual Studio automatically generates a custom wrapper assembly. This wrapper exposes the ActiveX API through managed code, making integration seamless.

## Step-by-Step Installation Guide

Follow these detailed steps to install the TVFVideoCapture control in your Visual Studio environment:

1. Create a new project in your preferred language (C++, C#, or Visual Basic .NET)
2. Access the toolbox panel in your Visual Studio interface

1. Right-click on the toolbox and select "Choose toolbox items" from the context menu

1. In the dialog box that appears, locate and select the "VisioForge Video Capture" component

1. After selection, the control will be added to your toolbox for easy access

1. Add the control to your form by dragging it from the toolbox
2. For .NET projects, Visual Studio will automatically generate the necessary wrapper assembly

## Framework Samples and Resources

For practical implementation examples, refer to the framework samples included with your installation package. These samples cover all supported programming languages and demonstrate various integration scenarios.

## Recommendations for .NET Developers

While ActiveX integration is fully supported, .NET developers may benefit from using the native .NET version of the SDK. The native implementation offers:

- Enhanced performance and stability
- Direct integration with WinForms and WPF
- MAUI control support for cross-platform development
- More intuitive API design for .NET environments

## Additional Resources and Support

Explore our extensive documentation for advanced configuration options and optimization techniques. Our development team continuously updates resources to address common implementation challenges.

---

For technical assistance with this installation process, please contact our [support team](https://support.visioforge.com/). Additional code samples and implementation examples are available on our [GitHub repository](https://github.com/visioforge/).

---END OF PAGE---


## Delphi MPEG-2 Video Capture with TV Tuner Hardware
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/mpeg2-capture/
**Description:** Implement MPEG-2 capture in Delphi using TV tuner hardware encoders - device enumeration, format configuration, and optimized code examples.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, DirectShow, Windows, VCL, Capture, Encoding, TV Tuner, MPEG-2

# MPEG-2 Video Capture in Delphi Using TV Tuner Hardware Encoders

This comprehensive tutorial demonstrates how to implement high-quality MPEG-2 video capture functionality in your Delphi applications by leveraging TV tuners with built-in hardware encoding capabilities. Hardware encoding significantly reduces CPU usage while maintaining excellent video quality.

## Overview of MPEG-2 Hardware Encoding

MPEG-2 hardware encoders provide superior performance compared to software-based encoding solutions. They're particularly useful for developing professional video capture applications that require efficient processing and high-quality output.

## Enumerating Available MPEG-2 Hardware Encoders

The first step is to identify all available MPEG-2 hardware encoders in the system. This code demonstrates how to populate a dropdown with detected devices:

```
// List all available MPEG-2 hardware encoders in the system
// This helps users select the appropriate encoding device
VideoCapture1.Special_Filters_Fill;
for I := 0 to VideoCapture1.Special_Filters_GetCount(SF_Hardware_Video_Encoder) - 1 do
  cbMPEGEncoder.Items.Add(VideoCapture1.Special_Filters_GetItem(SF_Hardware_Video_Encoder, i));
```

```
// C++ MFC implementation for MPEG-2 encoder enumeration
// Populates a combobox with all detected hardware encoders
m_VideoCapture.Special_Filters_Fill();
for (int i = 0; i < m_VideoCapture.Special_Filters_GetCount(SF_Hardware_Video_Encoder); i++)
{
  CString encoderName = m_VideoCapture.Special_Filters_GetItem(SF_Hardware_Video_Encoder, i);
  m_cbMPEGEncoder.AddString(encoderName);
}
```

```
' VB6 implementation for finding hardware MPEG-2 encoders
' Lists all available encoders in a combobox control
VideoCapture1.Special_Filters_Fill
For i = 0 To VideoCapture1.Special_Filters_GetCount(SF_Hardware_Video_Encoder) - 1
  cbMPEGEncoder.AddItem VideoCapture1.Special_Filters_GetItem(SF_Hardware_Video_Encoder, i)
Next i
```

## Selecting a Specific MPEG-2 Encoder

After enumerating the available encoders, the next step is to select a specific encoder for use:

```
// Configure the component to use the selected MPEG-2 hardware encoder
// This must be done before starting the capture process
VideoCapture1.Video_CaptureDevice_InternalMPEGEncoder_Name := cbMPEGEncoder.Items[cbMPEGEncoder.ItemIndex];
```

```
// C++ MFC: Select and configure the chosen MPEG-2 hardware encoder
// Retrieves the selected encoder name from the combobox
int nIndex = m_cbMPEGEncoder.GetCurSel();
CString encoderName;
m_cbMPEGEncoder.GetLBText(nIndex, encoderName);
m_VideoCapture.Video_CaptureDevice_InternalMPEGEncoder_Name = encoderName;
```

```
' VB6: Set the selected encoder as the active MPEG-2 hardware encoder
' Must be called before initializing the capture graph
VideoCapture1.Video_CaptureDevice_InternalMPEGEncoder_Name = cbMPEGEncoder.List(cbMPEGEncoder.ListIndex)
```

## Configuring DirectStream MPEG Format for Output

To properly capture MPEG-2 encoded video, you need to set the appropriate output format:

```
// Set the output format to DirectStream MPEG
// This enables proper handling of hardware-encoded MPEG-2 streams
VideoCapture1.OutputFormat := Format_DirectStream_MPEG;
```

```
// C++ MFC: Configure the output format for MPEG-2 encoded content
// DirectStream MPEG format preserves the hardware-encoded stream
m_VideoCapture.OutputFormat = Format_DirectStream_MPEG;
```

```
' VB6: Set the proper output format for MPEG-2 hardware encoding
' DirectStream format ensures the encoded data is properly handled
VideoCapture1.OutputFormat = Format_DirectStream_MPEG
```

## Establishing Video Capture Mode

Before starting the capture process, set the component to video capture mode:

```
// Configure the component for video capture operation
// This prepares the internal DirectShow graph for recording
VideoCapture1.Mode := Mode_Video_Capture;
```

```
// C++ MFC: Set the component to video capture mode
// Required before starting the MPEG-2 capture process
m_VideoCapture.Mode = Mode_Video_Capture;
```

```
' VB6: Set video capture mode before starting recording
' This initializes the appropriate DirectShow filters
VideoCapture1.Mode = Mode_Video_Capture
```

## Initiating the MPEG-2 Capture Process

Finally, start the capture process to begin recording MPEG-2 video:

```
// Begin the video capture process with the configured settings
// The component will now start recording to the specified output
VideoCapture1.Start;
```

```
// C++ MFC: Start the MPEG-2 video capture process
// Recording begins with the previously configured settings
m_VideoCapture.Start();
```

```
' VB6: Start the video capture with the current configuration
' The hardware encoder will now begin processing video data
VideoCapture1.Start
```

## Advanced MPEG-2 Capture Considerations

When implementing MPEG-2 capture with hardware encoders, consider these additional factors:

1. Hardware encoders typically offer better performance than software-based solutions
2. Some TV tuners provide additional encoding parameters that can be customized
3. Buffer sizes may need adjustment for higher quality captures
4. Hardware encoders often handle video scaling and frame rate conversion internally

## Troubleshooting Common Issues

If you encounter problems with MPEG-2 hardware encoding:

1. Verify that your TV tuner device supports hardware MPEG-2 encoding
2. Ensure proper driver installation for the capture device
3. Check that DirectX is properly installed and updated
4. Consider system resource availability, as some encoders require specific resources

Please contact our dedicated support team for assistance with implementing this tutorial in your specific application. Visit our GitHub repository for additional code samples and implementation examples.

---END OF PAGE---


## Implement WMV Network Streaming in Delphi and ActiveX
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/network-streaming-wmv/
**Description:** Implement WMV network streaming in Delphi - configure profiles, manage client connections, set ports, and broadcast video with code examples.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture, Streaming, Encoding, WMV

# WMV Network Streaming Implementation Guide

## Overview

This guide demonstrates how to implement network-based video broadcasting using Windows Media Video (WMV) format in your Delphi applications. The techniques shown here allow you to stream video content over networks while simultaneously capturing and saving the video to a file for archival purposes.

## Requirements

Before implementing WMV network streaming, ensure that you have:

- A supported video capture device connected to your system
- Proper network access and permissions
- A valid WMV profile file with encoder settings

## Implementation Steps

### Basic Configuration

To enable WMV network streaming in your application, you'll need to configure several essential parameters:

1. Enable network streaming functionality
2. Specify a WMV profile file containing video encoding parameters
3. Set the maximum number of concurrent client connections
4. Define the network port for client connections

### Delphi Implementation Code

```
// Delphi code for configuring WMV network streaming
// Enable the network streaming functionality
VideoCapture1.Network_Streaming_Enabled := true;

// Set the path to the WMV profile file containing encoder settings
// This file defines video quality, bitrate, resolution, etc.
VideoCapture1.Network_Streaming_WMV_Profile_FileName := edNetworkStreamingWMVProfile.Text;

// Define maximum number of concurrent clients that can connect
VideoCapture1.Network_Streaming_Maximum_Clients := StrToInt(edMaximumClients.Text);

// Specify the network port that clients will use to connect
VideoCapture1.Network_Streaming_Network_Port := StrToInt(edNetworkPort.Text);
```

### C++ MFC Implementation

```
// C++ MFC implementation for WMV network streaming.
// CEdit::GetWindowText takes a CString reference and writes into it (returns void),
// so capture the value via a local CString and pass that to the COM setter.
CString profile, maxClients, port;
edNetworkStreamingWMVProfile.GetWindowText(profile);
edMaximumClients.GetWindowText(maxClients);
edNetworkPort.GetWindowText(port);

// Enable streaming functionality
m_VideoCapture.SetNetwork_Streaming_Enabled(true);

// Set WMV profile path - contains encoding parameters
m_VideoCapture.SetNetwork_Streaming_WMV_Profile_FileName(profile);

// Define maximum concurrent client connections
m_VideoCapture.SetNetwork_Streaming_Maximum_Clients(_ttoi(maxClients));

// Set the network port for client connections
m_VideoCapture.SetNetwork_Streaming_Network_Port(_ttoi(port));
```

### VB6 Implementation

```
' VB6 (ActiveX) implementation for WMV network streaming
' Enable network streaming capabilities
VideoCapture1.Network_Streaming_Enabled = True

' Set the profile file containing video encoder settings
VideoCapture1.Network_Streaming_WMV_Profile_FileName = txtNetworkStreamingWMVProfile.Text

' Define maximum number of clients allowed to connect simultaneously
VideoCapture1.Network_Streaming_Maximum_Clients = CInt(txtMaximumClients.Text)

' Specify the network port for client connections
VideoCapture1.Network_Streaming_Network_Port = CInt(txtNetworkPort.Text)
```

## Client Connection Information

After configuring the streaming parameters, your application can obtain the connection URL that clients will use to access the video stream:

```
// Get the URL that clients will use to connect to the stream
// This URL can be shared with users who need to view the stream
strStreamURL := VideoCapture1.Network_Streaming_URL;
```

This URL can be used with Windows Media Player or any other application that supports Windows Media streaming protocols.

## Best Practices

For optimal streaming performance, consider the following recommendations:

- Use appropriate bitrates based on your network capabilities
- Monitor client connections to ensure system stability
- Test your streaming configuration with various client applications
- Consider network bandwidth limitations when setting quality parameters

## Troubleshooting

If you encounter issues with your streaming implementation:

- Verify network firewall settings allow traffic on your selected port
- Ensure the WMV profile file exists and contains valid settings
- Check that the maximum client count is appropriate for your server resources
- Validate network connectivity between the server and potential clients

---

Please get in touch with [support](https://support.visioforge.com/) if you have questions about this implementation. Visit our [GitHub](https://github.com/visioforge/) page for additional code samples and resources.

---END OF PAGE---


## Resize and Crop Video in Delphi with TVFVideoCapture
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/resize-crop/
**Description:** Implement video resizing and cropping in Delphi - real-time processing, aspect ratio handling, and performance optimization with code samples.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture, Streaming
**API:** TVFVideoCapture

# Video Resizing and Cropping in Delphi TVFVideoCapture

Video manipulation is a critical component of many modern applications. This guide provides detailed instructions for implementing real-time video resizing and cropping in your Delphi applications with minimal performance impact.

## Why Resize or Crop Video?

Video resizing and cropping serve multiple purposes in development:

- Optimize video for different display sizes
- Reduce bandwidth requirements for streaming
- Focus on specific regions of interest
- Create uniform video dimensions across your application
- Improve performance on resource-constrained devices

## Enabling Resize and Crop Functionality

Before applying any transformations, you must enable the resize/crop functionality in the TVFVideoCapture component.

### Step 1: Enable the Feature

```
// Enable video resizing or cropping functionality
VideoCapture1.Video_ResizeOrCrop_Enabled := true;
```

```
// C++ MFC - Enable video transformation capabilities
m_VideoCapture.SetVideo_ResizeOrCrop_Enabled(TRUE);
```

```
' VB6 - Activate resize/crop features
VideoCapture1.Video_ResizeOrCrop_Enabled = True
```

## Video Resizing Implementation

Resizing allows you to change the dimensions of your video stream while maintaining visual quality.

### Setting New Dimensions

```
// Set the desired width and height for the resized video output
VideoCapture1.Video_Resize_NewWidth := StrToInt(edResizeWidth.Text);
VideoCapture1.Video_Resize_NewHeight := StrToInt(edResizeHeight.Text);
```

```
// C++ MFC - Configure target dimensions for video resize
m_VideoCapture.SetVideo_Resize_NewWidth(_ttoi(m_strResizeWidth));
m_VideoCapture.SetVideo_Resize_NewHeight(_ttoi(m_strResizeHeight));
```

```
' VB6 - Define new video dimensions
VideoCapture1.Video_Resize_NewWidth = CInt(txtResizeWidth.Text)
VideoCapture1.Video_Resize_NewHeight = CInt(txtResizeHeight.Text)
```

### Handling Aspect Ratio Changes

When resizing video, you can choose between preserving the original aspect ratio (letterbox) or stretching the content to fit the new dimensions.

```
// Letterbox mode adds black borders to preserve aspect ratio
// When false, the video will stretch to fit the new dimensions
VideoCapture1.Video_Resize_LetterBox := cbResizeLetterbox.Checked;
```

```
// C++ MFC - Configure aspect ratio handling method
m_VideoCapture.SetVideo_Resize_LetterBox(m_bResizeLetterbox);
```

```
' VB6 - Set letterbox mode for aspect ratio preservation
VideoCapture1.Video_Resize_LetterBox = chkResizeLetterbox.Value
```

### Selecting Resize Algorithms

Choose from multiple resize algorithms based on your quality requirements and performance constraints:

```
// Select the appropriate resize algorithm:
// - NearestNeighbor: Fastest but lowest quality
// - Bilinear: Good balance between speed and quality
// - Bilinear_HQ: Enhanced bilinear with improved quality
// - Bicubic: Better quality with moderate performance impact
// - Bicubic_HQ: Highest quality with highest CPU usage
case cbResizeMode.ItemIndex of
  0: VideoCapture1.Video_Resize_Mode := rm_NearestNeighbor;
  1: VideoCapture1.Video_Resize_Mode := rm_Bilinear;
  2: VideoCapture1.Video_Resize_Mode := rm_Bilinear_HQ;
  3: VideoCapture1.Video_Resize_Mode := rm_Bicubic;
  4: VideoCapture1.Video_Resize_Mode := rm_Bicubic_HQ;
end;
```

```
// C++ MFC - Set the resize algorithm based on quality/performance needs
switch(m_nResizeMode)
{
  case 0: m_VideoCapture.SetVideo_Resize_Mode(rm_NearestNeighbor); break; // Fastest
  case 1: m_VideoCapture.SetVideo_Resize_Mode(rm_Bilinear); break;        // Standard
  case 2: m_VideoCapture.SetVideo_Resize_Mode(rm_Bilinear_HQ); break;     // Enhanced
  case 3: m_VideoCapture.SetVideo_Resize_Mode(rm_Bicubic); break;         // High quality
  case 4: m_VideoCapture.SetVideo_Resize_Mode(rm_Bicubic_HQ); break;      // Maximum quality
}
```

```
' VB6 - Choose resize algorithm based on quality and performance needs
Select Case cboResizeMode.ListIndex
  Case 0: VideoCapture1.Video_Resize_Mode = rm_NearestNeighbor  ' Fastest, lower quality
  Case 1: VideoCapture1.Video_Resize_Mode = rm_Bilinear         ' Balanced option
  Case 2: VideoCapture1.Video_Resize_Mode = rm_Bilinear_HQ      ' Enhanced bilinear
  Case 3: VideoCapture1.Video_Resize_Mode = rm_Bicubic          ' Better quality
  Case 4: VideoCapture1.Video_Resize_Mode = rm_Bicubic_HQ       ' Highest quality
End Select
```

## Video Cropping Implementation

Cropping allows you to select a specific region of interest from your video stream.

### Step 1: Enable Cropping

As with resizing, you must first enable the feature:

```
// Enable video transformation capabilities before applying crop
VideoCapture1.Video_ResizeOrCrop_Enabled := true;
```

```
// C++ MFC - Activate video manipulation features
m_VideoCapture.SetVideo_ResizeOrCrop_Enabled(TRUE);
```

```
' VB6 - Enable video transformation functionality
VideoCapture1.Video_ResizeOrCrop_Enabled = True
```

### Step 2: Define Crop Region

Specify the boundaries of your crop region by defining the left, top, right, and bottom coordinates:

```
// Define the crop region coordinates in pixels
// These values represent the distance from each edge of the original video
VideoCapture1.Video_Crop_Left := StrToInt(edCropLeft.Text);
VideoCapture1.Video_Crop_Top := StrToInt(edCropTop.Text);
VideoCapture1.Video_Crop_Right := StrToInt(edCropRight.Text);
VideoCapture1.Video_Crop_Bottom := StrToInt(edCropBottom.Text);
```

```
// C++ MFC - Set the crop boundaries in pixels
// Each value defines how many pixels to crop from the respective edge
m_VideoCapture.SetVideo_Crop_Left(_ttoi(m_strCropLeft));
m_VideoCapture.SetVideo_Crop_Top(_ttoi(m_strCropTop));
m_VideoCapture.SetVideo_Crop_Right(_ttoi(m_strCropRight));
m_VideoCapture.SetVideo_Crop_Bottom(_ttoi(m_strCropBottom));
```

```
' VB6 - Configure crop region boundaries
' Values represent pixel counts from each edge to exclude
VideoCapture1.Video_Crop_Left = CInt(txtCropLeft.Text)
VideoCapture1.Video_Crop_Top = CInt(txtCropTop.Text)
VideoCapture1.Video_Crop_Right = CInt(txtCropRight.Text)
VideoCapture1.Video_Crop_Bottom = CInt(txtCropBottom.Text)
```

## Best Practices for Video Manipulation

For optimal results when implementing video resizing and cropping:

1. **Test on target hardware** - Different resize algorithms have varying CPU requirements
2. **Consider your use case** - For real-time applications, favor performance over quality
3. **Maintain aspect ratios** - Unless specifically needed, preserve original proportions
4. **Combine operations judiciously** - Applying both resize and crop increases processing overhead
5. **Cache settings** - Avoid changing parameters frequently during capture

## Troubleshooting Common Issues

- If performance is poor, try a faster resize algorithm
- Ensure crop values don't exceed the dimensions of your video stream
- When using letterbox mode, account for the black borders in your UI design
- For best results, resize to dimensions that are multiples of 8 or 16

---

For additional code samples and implementation examples, visit our [GitHub](https://github.com/visioforge/) repository. Need technical assistance? Contact our support team for personalized guidance.

---END OF PAGE---


## Delphi Screen Capture and Recording with TVFVideoCapture
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/screen-capture/
**Description:** Implement screen recording in Delphi with TVFVideoCapture - capture regions, full screen, customize frame rates, track cursor with code examples.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture, Screen Capture
**API:** TVFVideoCapture

# Screen Recording Implementation in Delphi

## Introduction to Screen Capture Functionality

TVFVideoCapture provides powerful screen recording capabilities for Delphi developers. This guide walks through the implementation of screen capture features in your applications, allowing you to record specific regions or the entire screen with customizable settings.

## Configuring Screen Capture Area

You can precisely control which portion of the screen to record by setting coordinate parameters. This is particularly useful when you want to focus on specific application windows or screen regions.

### Setting Specific Screen Coordinates

Use these parameters to define the exact boundaries of your capture area:

```
// Define the top edge position of the capture rectangle (in pixels)
VideoCapture1.Screen_Capture_Top := StrToInt(edScreenTop.Text);
// Define the bottom edge position of the capture rectangle (in pixels)
VideoCapture1.Screen_Capture_Bottom := StrToInt(edScreenBottom.Text);
// Define the left edge position of the capture rectangle (in pixels)
VideoCapture1.Screen_Capture_Left := StrToInt(edScreenLeft.Text);
// Define the right edge position of the capture rectangle (in pixels)
VideoCapture1.Screen_Capture_Right := StrToInt(edScreenRight.Text);
```

```
// CEdit::GetWindowText(CString&) returns void and fills the buffer by reference,
// so we must declare a CString first and then convert it to int via _ttoi
// (the TCHAR-aware variant — required because CString is wide in Unicode MFC builds).
CString sTop, sBottom, sLeft, sRight;
m_edScreenTop.GetWindowText(sTop);
m_edScreenBottom.GetWindowText(sBottom);
m_edScreenLeft.GetWindowText(sLeft);
m_edScreenRight.GetWindowText(sRight);

// Define the top edge position of the capture rectangle (in pixels)
m_VideoCapture.SetScreen_Capture_Top(_ttoi(sTop));
// Define the bottom edge position of the capture rectangle (in pixels)
m_VideoCapture.SetScreen_Capture_Bottom(_ttoi(sBottom));
// Define the left edge position of the capture rectangle (in pixels)
m_VideoCapture.SetScreen_Capture_Left(_ttoi(sLeft));
// Define the right edge position of the capture rectangle (in pixels)
m_VideoCapture.SetScreen_Capture_Right(_ttoi(sRight));
```

```
' Define the top edge position of the capture rectangle (in pixels)
VideoCapture1.Screen_Capture_Top = CInt(edScreenTop.Text)
' Define the bottom edge position of the capture rectangle (in pixels)
VideoCapture1.Screen_Capture_Bottom = CInt(edScreenBottom.Text)
' Define the left edge position of the capture rectangle (in pixels)
VideoCapture1.Screen_Capture_Left = CInt(edScreenLeft.Text)
' Define the right edge position of the capture rectangle (in pixels)
VideoCapture1.Screen_Capture_Right = CInt(edScreenRight.Text)
```

### Capturing the Full Screen

For complete screen recording, simply enable the full screen capture option:

```
// Enable full screen capture mode - will record the entire display
VideoCapture1.Screen_Capture_FullScreen := true;
```

```
// Enable full screen capture mode - will record the entire display
m_VideoCapture.SetScreen_Capture_FullScreen(true);
```

```
' Enable full screen capture mode - will record the entire display
VideoCapture1.Screen_Capture_FullScreen = True
```

## Optimizing Frame Rate Settings

The frame rate directly impacts both the quality and file size of your screen recordings. Higher frame rates produce smoother video but generate larger files.

```
// Set capture frame rate to 10 frames per second
// Adjust this value based on your performance requirements
VideoCapture1.Screen_Capture_FrameRate := 10;
```

```
// Set capture frame rate to 10 frames per second
// Adjust this value based on your performance requirements
m_VideoCapture.SetScreen_Capture_FrameRate(10);
```

```
' Set capture frame rate to 10 frames per second
' Adjust this value based on your performance requirements
VideoCapture1.Screen_Capture_FrameRate = 10
```

## Cursor Tracking Configuration

For instructional videos or demonstrations, capturing the mouse cursor movement is essential:

```
// Enable mouse cursor capture in the recording
// Set to false to hide cursor in the output video
VideoCapture1.Screen_Capture_Grab_Mouse_Cursor := true;
```

```
// Enable mouse cursor capture in the recording
// Set to false to hide cursor in the output video
m_VideoCapture.SetScreen_Capture_Grab_Mouse_Cursor(true);
```

```
' Enable mouse cursor capture in the recording
' Set to false to hide cursor in the output video
VideoCapture1.Screen_Capture_Grab_Mouse_Cursor = True
```

## Activating Screen Capture Mode

After configuring all settings, set the component to screen capture mode to begin recording:

```
// Set component to screen capture operational mode
// This activates all screen recording functionality
VideoCapture1.Mode := Mode_Screen_Capture;
```

```
// Set component to screen capture operational mode
// This activates all screen recording functionality
m_VideoCapture.SetMode(Mode_Screen_Capture);
```

```
' Set component to screen capture operational mode
' This activates all screen recording functionality
VideoCapture1.Mode = Mode_Screen_Capture
```

## Advanced Implementation Tips

For optimal screen recording performance:

- Consider system resources when selecting frame rates
- Use region capture when possible to minimize processing load
- Test different quality settings to balance file size and visual quality
- Remember that cursor capture adds slight processing overhead

---

For additional code samples and implementation examples, visit our [GitHub](https://github.com/visioforge/) repository. For technical assistance with implementation, please contact our [support team](https://support.visioforge.com/).

---END OF PAGE---


## Select Video and Audio Capture Devices in Delphi and VB6
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/video-audio-sources/
**Description:** Select video and audio devices in Delphi - enumerate devices, configure formats, set frame rates with code examples for Delphi, C++, and VB6.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture

# Code sample - How to select video and audio capture devices?

Delphi, C++ MFC and VB6 sample code

## Select video source

### Get a list of available video capture devices

```
for i := 0 to VideoCapture1.Video_CaptureDevices_GetCount - 1 do
  cbVideoInputDevice.Items.Add(VideoCapture1.Video_CaptureDevices_GetItem(i));
```

```
// C++ MFC
for (int i = 0; i < m_VideoCapture.Video_CaptureDevices_GetCount(); i++)
  m_cbVideoInputDevice.AddString(m_VideoCapture.Video_CaptureDevices_GetItem(i));
```

```
' VB6
For i = 0 To VideoCapture1.Video_CaptureDevices_GetCount - 1
  cbVideoInputDevice.AddItem VideoCapture1.Video_CaptureDevices_GetItem(i)
Next i
```

### Select the video input device

```
VideoCapture1.Video_CaptureDevice := cbVideoInputDevice.Items[cbVideoInputDevice.ItemIndex];
```

```
// C++ MFC
CString strDevice;
m_cbVideoInputDevice.GetLBText(m_cbVideoInputDevice.GetCurSel(), strDevice);
m_VideoCapture.put_Video_CaptureDevice(strDevice);
```

```
' VB6
VideoCapture1.Video_CaptureDevice = cbVideoInputDevice.Text
```

### Get a list of available video formats

```
VideoCapture1.Video_CaptureDevice_Formats_Fill;
for I := 0 to VideoCapture1.Video_CaptureDevice_Formats_GetCount - 1 do
 cbVideoInputFormat.Items.Add(VideoCapture1.Video_CaptureDevice_Formats_GetItem(i));
```

```
// C++ MFC
m_VideoCapture.Video_CaptureDevice_Formats_Fill();
for (int i = 0; i < m_VideoCapture.Video_CaptureDevice_Formats_GetCount(); i++)
  m_cbVideoInputFormat.AddString(m_VideoCapture.Video_CaptureDevice_Formats_GetItem(i));
```

```
' VB6
VideoCapture1.Video_CaptureDevice_Formats_Fill
For i = 0 To VideoCapture1.Video_CaptureDevice_Formats_GetCount - 1
  cbVideoInputFormat.AddItem VideoCapture1.Video_CaptureDevice_Formats_GetItem(i)
Next i
```

### Select video format

```
VideoCapture1.Video_CaptureFormat := cbVideoInputFormat.Items[cbVideoInputFormat.ItemIndex];
```

```
// C++ MFC
CString strFormat;
m_cbVideoInputFormat.GetLBText(m_cbVideoInputFormat.GetCurSel(), strFormat);
m_VideoCapture.put_Video_CaptureFormat(strFormat);
```

```
' VB6
VideoCapture1.Video_CaptureFormat = cbVideoInputFormat.Text
```

or

### Automatically choose the best video format

```
VideoCapture1.Video_CaptureFormat_UseBest := cbUseBestVideoInputFormat.Checked;
```

```
// C++ MFC
m_VideoCapture.put_Video_CaptureFormat_UseBest(m_cbUseBestVideoInputFormat.GetCheck() == BST_CHECKED);
```

```
' VB6
VideoCapture1.Video_CaptureFormat_UseBest = cbUseBestVideoInputFormat.Value
```

### Get a list of available frame rates

```
VideoCapture1.Video_CaptureDevice_FrameRates_Fill;
for I := 0 to VideoCapture1.Video_CaptureDevice_FrameRates_GetCount - 1 do
  cbFrameRate.Items.Add(VideoCapture1.Video_CaptureDevice_FrameRates_GetItem(i));
```

```
// C++ MFC
m_VideoCapture.Video_CaptureDevice_FrameRates_Fill();
for (int i = 0; i < m_VideoCapture.Video_CaptureDevice_FrameRates_GetCount(); i++)
  m_cbFrameRate.AddString(m_VideoCapture.Video_CaptureDevice_FrameRates_GetItem(i));
```

```
' VB6
VideoCapture1.Video_CaptureDevice_FrameRates_Fill
For i = 0 To VideoCapture1.Video_CaptureDevice_FrameRates_GetCount - 1
  cbFrameRate.AddItem VideoCapture1.Video_CaptureDevice_FrameRates_GetItem(i)
Next i
```

### Select frame rate

```
VideoCapture1.Video_FrameRate := StrToFloat(cbFrameRate.Items[cbFrameRate.ItemIndex]);
```

```
// C++ MFC
CString strFrameRate;
m_cbFrameRate.GetLBText(m_cbFrameRate.GetCurSel(), strFrameRate);
m_VideoCapture.put_Video_FrameRate(_wtof(strFrameRate));
```

```
' VB6
VideoCapture1.Video_FrameRate = CDbl(cbFrameRate.Text)
```

Select needed video input (configure crossbar) if needed.

## Select audio source

### Use video capture device as audio source

```
VideoCapture1.Video_CaptureDevice_IsAudioSource := true;
```

```
// C++ MFC
m_VideoCapture.put_Video_CaptureDevice_IsAudioSource(true);
```

```
' VB6
VideoCapture1.Video_CaptureDevice_IsAudioSource = True
```

or

### Get a list of available audio capture devices

```
for I := 0 to VideoCapture1.Audio_CaptureDevices_GetCount - 1 do
  cbAudioInputDevice.Items.Add(VideoCapture1.Audio_CaptureDevices_GetItem(i));
```

```
// C++ MFC
for (int i = 0; i < m_VideoCapture.Audio_CaptureDevices_GetCount(); i++)
  m_cbAudioInputDevice.AddString(m_VideoCapture.Audio_CaptureDevices_GetItem(i));
```

```
' VB6
For i = 0 To VideoCapture1.Audio_CaptureDevices_GetCount - 1
  cbAudioInputDevice.AddItem VideoCapture1.Audio_CaptureDevices_GetItem(i)
Next i
```

### Select the audio input device

```
VideoCapture1.Audio_CaptureDevice := cbAudioInputDevice.Items[cbAudioInputDevice.ItemIndex];
```

```
// C++ MFC
CString strAudioDevice;
m_cbAudioInputDevice.GetLBText(m_cbAudioInputDevice.GetCurSel(), strAudioDevice);
m_VideoCapture.put_Audio_CaptureDevice(strAudioDevice);
```

```
' VB6
VideoCapture1.Audio_CaptureDevice = cbAudioInputDevice.Text
```

### Get a list of available audio formats

```
VideoCapture1.Audio_CaptureDevice_Formats_Fill;
for I := 0 to VideoCapture1.Audio_CaptureDevice_Formats_GetCount - 1 do
  cbAudioInputFormat.Items.Add(VideoCapture1.Audio_CaptureDevice_Formats_GetItem(i));
```

```
// C++ MFC
m_VideoCapture.Audio_CaptureDevice_Formats_Fill();
for (int i = 0; i < m_VideoCapture.Audio_CaptureDevice_Formats_GetCount(); i++)
  m_cbAudioInputFormat.AddString(m_VideoCapture.Audio_CaptureDevice_Formats_GetItem(i));
```

```
' VB6
VideoCapture1.Audio_CaptureDevice_Formats_Fill
For i = 0 To VideoCapture1.Audio_CaptureDevice_Formats_GetCount - 1
  cbAudioInputFormat.AddItem VideoCapture1.Audio_CaptureDevice_Formats_GetItem(i)
Next i
```

### Select the format

```
VideoCapture1.Audio_CaptureFormat := cbAudioInputFormat.Items[cbAudioInputFormat.ItemIndex];
```

```
// C++ MFC
CString strAudioFormat;
m_cbAudioInputFormat.GetLBText(m_cbAudioInputFormat.GetCurSel(), strAudioFormat);
m_VideoCapture.put_Audio_CaptureFormat(strAudioFormat);
```

```
' VB6
VideoCapture1.Audio_CaptureFormat = cbAudioInputFormat.Text
```

or

### Automatically choose the best audio format

```
VideoCapture1.Audio_CaptureFormat_UseBest := cbUseBestAudioInputFormat.Checked;
```

```
// C++ MFC
m_VideoCapture.put_Audio_CaptureFormat_UseBest(m_cbUseBestAudioInputFormat.GetCheck() == BST_CHECKED);
```

```
' VB6
VideoCapture1.Audio_CaptureFormat_UseBest = cbUseBestAudioInputFormat.Value
```

### Get a list of available audio inputs (lines)

```
VideoCapture1.Audio_CaptureDevice_Lines_Fill;
for I := 0 to VideoCapture1.Audio_CaptureDevice_Lines_GetCount - 1 do
  cbAudioInputLine.Items.Add(VideoCapture1.Audio_CaptureDevice_Lines_GetItem(i));
```

```
// C++ MFC
m_VideoCapture.Audio_CaptureDevice_Lines_Fill();
for (int i = 0; i < m_VideoCapture.Audio_CaptureDevice_Lines_GetCount(); i++)
  m_cbAudioInputLine.AddString(m_VideoCapture.Audio_CaptureDevice_Lines_GetItem(i));
```

```
' VB6
VideoCapture1.Audio_CaptureDevice_Lines_Fill
For i = 0 To VideoCapture1.Audio_CaptureDevice_Lines_GetCount - 1
  cbAudioInputLine.AddItem VideoCapture1.Audio_CaptureDevice_Lines_GetItem(i)
Next i
```

### Select audio input

```
VideoCapture1.Audio_CaptureLine := cbAudioInputLine.Items[cbAudioInputLine.ItemIndex];
```

```
// C++ MFC
CString strAudioLine;
m_cbAudioInputLine.GetLBText(m_cbAudioInputLine.GetCurSel(), strAudioLine);
m_VideoCapture.put_Audio_CaptureLine(strAudioLine);
```

```
' VB6
VideoCapture1.Audio_CaptureLine = cbAudioInputLine.Text
```

---

Please get in touch with [support](https://support.visioforge.com/) to get help with this tutorial. Visit our [GitHub](https://github.com/visioforge/) page to get more code samples.

---END OF PAGE---


## AVI Video Capture in Delphi Using TVFVideoCapture SDK
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/video-capture-avi/
**Description:** Record video to AVI format in Delphi with TVFVideoCapture using codec selection, audio configuration, and complete implementation examples.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, C++, Windows, VCL, Capture, AVI
**API:** TVFVideoCapture

# Complete Guide to Video Capture to AVI Files in Delphi

When developing multimedia applications in Delphi, video capture functionality is often a critical requirement. This guide explores how to implement high-quality video capture to AVI files using the TVFVideoCapture component in Delphi applications. We'll cover everything from setting up codecs to configuring audio parameters and starting the capture process.

## Understanding AVI Video Capture in Delphi

The TVFVideoCapture component provides a powerful and flexible way to capture video directly to AVI format in Delphi applications. AVI (Audio Video Interleave) remains a popular video container format due to its broad compatibility and reliability for recording purposes.

When implementing video capture in your Delphi application, you'll need to consider several key aspects:

1. Selecting appropriate video and audio codecs
2. Configuring audio parameters
3. Setting the output format and capture mode
4. Managing the capture process

This guide provides detailed explanations and code samples for each of these steps.

## Working with Video and Audio Codecs

### Retrieving Available Codecs

Before capturing video, you'll need to populate your application with the available video and audio codecs. The TVFVideoCapture component makes this straightforward:

```
procedure TMyForm.PopulateCodecLists;
var
  I: Integer;
begin
  // Clear existing items
  cbVideoCodecs.Items.Clear;
  cbAudioCodecs.Items.Clear;

  // Populate video codecs
  for I := 0 to VideoCapture1.Video_Codecs_GetCount - 1 do
    cbVideoCodecs.Items.Add(VideoCapture1.Video_Codecs_GetItem(i));

  // Populate audio codecs
  for I := 0 to VideoCapture1.Audio_Codecs_GetCount - 1 do
    cbAudioCodecs.Items.Add(VideoCapture1.Audio_Codecs_GetItem(i));
end;
```

For developers using C++ MFC, the equivalent code would be:

```
void CMyDialog::PopulateCodecLists()
{
    // Clear existing items
    m_VideoCodecsCombo.ResetContent();
    m_AudioCodecsCombo.ResetContent();

    // Populate video codecs
    for (int i = 0; i < m_VideoCapture.Video_Codecs_GetCount(); i++) {
        CString codecName = m_VideoCapture.Video_Codecs_GetItem(i);
        m_VideoCodecsCombo.AddString(codecName);
    }

    // Populate audio codecs
    for (int i = 0; i < m_VideoCapture.Audio_Codecs_GetCount(); i++) {
        CString codecName = m_VideoCapture.Audio_Codecs_GetItem(i);
        m_AudioCodecsCombo.AddString(codecName);
    }
}
```

For VB6 developers, here's how to implement the same functionality:

```
Private Sub PopulateCodecLists()
    ' Clear existing items
    cboVideoCodecs.Clear
    cboAudioCodecs.Clear

    ' Populate video codecs
    Dim i As Integer
    For i = 0 To VideoCapture1.Video_Codecs_GetCount - 1
        cboVideoCodecs.AddItem VideoCapture1.Video_Codecs_GetItem(i)
    Next i

    ' Populate audio codecs
    For i = 0 To VideoCapture1.Audio_Codecs_GetCount - 1
        cboAudioCodecs.AddItem VideoCapture1.Audio_Codecs_GetItem(i)
    Next i
End Sub
```

### Selecting Codecs for Capture

Once you've populated the lists, you'll need to let users select their preferred codecs and apply those selections to the capture component:

```
procedure TMyForm.ApplyCodecSelections;
begin
  if cbVideoCodecs.ItemIndex >= 0 then
    VideoCapture1.Video_Codec := cbVideoCodecs.Items[cbVideoCodecs.ItemIndex];

  if cbAudioCodecs.ItemIndex >= 0 then
    VideoCapture1.Audio_Codec := cbAudioCodecs.Items[cbAudioCodecs.ItemIndex];
end;
```

C++ MFC implementation:

```
void CMyDialog::ApplyCodecSelections()
{
    int videoIndex = m_VideoCodecsCombo.GetCurSel();
    if (videoIndex >= 0) {
        CString videoCodec;
        m_VideoCodecsCombo.GetLBText(videoIndex, videoCodec);
        m_VideoCapture.Video_Codec = videoCodec;
    }

    int audioIndex = m_AudioCodecsCombo.GetCurSel();
    if (audioIndex >= 0) {
        CString audioCodec;
        m_AudioCodecsCombo.GetLBText(audioIndex, audioCodec);
        m_VideoCapture.Audio_Codec = audioCodec;
    }
}
```

VB6 implementation:

```
Private Sub ApplyCodecSelections()
    If cboVideoCodecs.ListIndex >= 0 Then
        VideoCapture1.Video_Codec = cboVideoCodecs.Text
    End If

    If cboAudioCodecs.ListIndex >= 0 Then
        VideoCapture1.Audio_Codec = cboAudioCodecs.Text
    End If
End Sub
```

## Configuring Audio Parameters

Quality audio capture requires proper configuration of three key parameters:

1. **Audio Channels**: Typically 1 (mono) or 2 (stereo)
2. **Bits Per Sample (BPS)**: Common values include 8, 16, or 24 bits
3. **Sample Rate**: Standard rates include 44100 Hz (CD quality) or 48000 Hz

Here's how to apply these settings in Delphi:

```
procedure TMyForm.ConfigureAudioSettings;
begin
  // Apply audio channel configuration (mono/stereo)
  VideoCapture1.Audio_Channels := StrToInt(cbChannels.Items[cbChannels.ItemIndex]);

  // Set bits per sample for audio quality
  VideoCapture1.Audio_BPS := StrToInt(cbBPS.Items[cbBPS.ItemIndex]);

  // Configure sample rate
  VideoCapture1.Audio_SampleRate := StrToInt(cbSampleRate.Items[cbSampleRate.ItemIndex]);
end;
```

C++ MFC implementation:

```
void CMyDialog::ConfigureAudioSettings()
{
    CString channelStr, bpsStr, sampleRateStr;

    // Get selected values from combo boxes
    m_ChannelsCombo.GetLBText(m_ChannelsCombo.GetCurSel(), channelStr);
    m_BpsCombo.GetLBText(m_BpsCombo.GetCurSel(), bpsStr);
    m_SampleRateCombo.GetLBText(m_SampleRateCombo.GetCurSel(), sampleRateStr);

    // Apply audio channel configuration
    m_VideoCapture.Audio_Channels = _ttoi(channelStr);

    // Set bits per sample
    m_VideoCapture.Audio_BPS = _ttoi(bpsStr);

    // Configure sample rate
    m_VideoCapture.Audio_SampleRate = _ttoi(sampleRateStr);
}
```

VB6 implementation:

```
Private Sub ConfigureAudioSettings()
    ' Apply audio channel configuration
    VideoCapture1.Audio_Channels = CInt(cboChannels.Text)

    ' Set bits per sample
    VideoCapture1.Audio_BPS = CInt(cboBPS.Text)

    ' Configure sample rate
    VideoCapture1.Audio_SampleRate = CInt(cboSampleRate.Text)
End Sub
```

## Configuring Output Format and Capture Mode

The next step is to configure the output format as AVI and set the appropriate capture mode:

```
procedure TMyForm.PrepareForCapture;
begin
  // Set AVI as the output format
  VideoCapture1.OutputFormat := Format_AVI;

  // Configure video capture mode
  VideoCapture1.Mode := Mode_Video_Capture;
end;
```

C++ MFC implementation:

```
void CMyDialog::PrepareForCapture()
{
    // Set AVI as the output format
    m_VideoCapture.OutputFormat = Format_AVI;

    // Configure video capture mode
    m_VideoCapture.Mode = Mode_Video_Capture;
}
```

VB6 implementation:

```
Private Sub PrepareForCapture()
    ' Set AVI as the output format
    VideoCapture1.OutputFormat = Format_AVI

    ' Configure video capture mode
    VideoCapture1.Mode = Mode_Video_Capture
End Sub
```

## Starting and Managing the Capture Process

Once everything is configured, you can start the capture process:

```
procedure TMyForm.StartCapture;
begin
  try
    // Set output filename
    VideoCapture1.Output_Filename := ExtractFilePath(Application.ExeName) + 'CapturedVideo.avi';

    // Begin capture process
    VideoCapture1.Start;

    // Update UI to show capture in progress
    btnStart.Enabled := False;
    btnStop.Enabled := True;
    lblStatus.Caption := 'Recording...';
  except
    on E: Exception do
      ShowMessage('Error starting capture: ' + E.Message);
  end;
end;
```

C++ MFC implementation:

```
void CMyDialog::StartCapture()
{
    try {
        TCHAR appPath[MAX_PATH];
        GetModuleFileName(NULL, appPath, MAX_PATH);
        CString appDir = appPath;
        int pos = appDir.ReverseFind('\\');
        if (pos != -1) {
            appDir = appDir.Left(pos + 1);
        }

        // Set output filename
        m_VideoCapture.Output_Filename = appDir + _T("CapturedVideo.avi");

        // Begin capture process
        m_VideoCapture.Start();

        // Update UI
        GetDlgItem(IDC_START_BUTTON)->EnableWindow(FALSE);
        GetDlgItem(IDC_STOP_BUTTON)->EnableWindow(TRUE);
        SetDlgItemText(IDC_STATUS_STATIC, _T("Recording..."));
    }
    catch (COleDispatchException* e) {
        CString errorMsg = _T("Error starting capture: ");
        errorMsg += e->m_strDescription;
        MessageBox(errorMsg, _T("Error"), MB_ICONERROR);
        e->Delete();
    }
}
```

VB6 implementation:

```
Private Sub StartCapture()
    On Error GoTo ErrorHandler

    ' Set output filename
    VideoCapture1.Output_Filename = App.Path & "\CapturedVideo.avi"

    ' Begin capture process
    VideoCapture1.Start

    ' Update UI
    btnStart.Enabled = False
    btnStop.Enabled = True
    lblStatus.Caption = "Recording..."

    Exit Sub

ErrorHandler:
    MsgBox "Error starting capture: " & Err.Description, vbExclamation
End Sub
```

## Handling Capture Completion

It's important to provide functionality to stop the capture process:

```
procedure TMyForm.StopCapture;
begin
  try
    // Stop the capture process
    VideoCapture1.Stop;

    // Update UI
    btnStart.Enabled := True;
    btnStop.Enabled := False;
    lblStatus.Caption := 'Capture completed';

    // Optionally open the captured file
    if FileExists(VideoCapture1.Output_Filename) and (MessageDlg('Open captured video?',
                                                       mtConfirmation, [mbYes, mbNo], 0) = mrYes) then
      ShellExecute(0, 'open', PChar(VideoCapture1.Output_Filename), nil, nil, SW_SHOW);
  except
    on E: Exception do
      ShowMessage('Error stopping capture: ' + E.Message);
  end;
end;
```

C++ MFC implementation:

```
void CMyDialog::StopCapture()
{
    try {
        // Stop the capture process
        m_VideoCapture.Stop();

        // Update UI
        GetDlgItem(IDC_START_BUTTON)->EnableWindow(TRUE);
        GetDlgItem(IDC_STOP_BUTTON)->EnableWindow(FALSE);
        SetDlgItemText(IDC_STATUS_STATIC, _T("Capture completed"));

        // Optionally open the captured file
        CString outputFile = m_VideoCapture.Output_Filename;
        if (PathFileExists(outputFile) &&
            MessageBox(_T("Open captured video?"), _T("Confirmation"),
                      MB_YESNO | MB_ICONQUESTION) == IDYES) {
            ShellExecute(NULL, _T("open"), outputFile, NULL, NULL, SW_SHOW);
        }
    }
    catch (COleDispatchException* e) {
        CString errorMsg = _T("Error stopping capture: ");
        errorMsg += e->m_strDescription;
        MessageBox(errorMsg, _T("Error"), MB_ICONERROR);
        e->Delete();
    }
}
```

VB6 implementation:

```
Private Sub StopCapture()
    On Error GoTo ErrorHandler

    ' Stop the capture process
    VideoCapture1.Stop

    ' Update UI
    btnStart.Enabled = True
    btnStop.Enabled = False
    lblStatus.Caption = "Capture completed"

    ' Optionally open the captured file
    If Dir(VideoCapture1.Output_Filename) <> "" Then
        If MsgBox("Open captured video?", vbQuestion + vbYesNo) = vbYes Then
            Shell "explorer.exe """ & VideoCapture1.Output_Filename & """", vbNormalFocus
        End If
    End If

    Exit Sub

ErrorHandler:
    MsgBox "Error stopping capture: " & Err.Description, vbExclamation
End Sub
```

## Conclusion

Implementing video capture to AVI files in Delphi applications using the TVFVideoCapture component is a straightforward process when you understand the key concepts. By following this guide, you can create robust multimedia applications with professional video capture functionality.

The TVFVideoCapture component provides a wide range of additional features and customization options beyond what's covered in this guide, including video effects, overlays, and device property configuration.

Remember to test your video capture implementation thoroughly with different codecs and audio configurations to ensure the best quality for your specific use case.

---

For additional code samples and implementation guidance, visit our GitHub repository. If you need further assistance with this tutorial, our support team is available to help.

---END OF PAGE---


## DV Video Capture in Delphi — Direct Stream and Recompressed
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/video-capture-dv/
**Description:** Implement DV video capture in Delphi - compressed and uncompressed formats with step-by-step implementation and working code examples.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture, Streaming

# Video Capture to DV File Format: Implementation Guide

Digital Video (DV) remains a reliable format for video capture applications, particularly when working with legacy systems or specific professional requirements. This guide explores how to implement DV video capture functionality in your Delphi applications, with additional C++ MFC and VB6 examples for cross-platform reference.

## Understanding DV Format Options

DV format offers several advantages for video capture applications:

- Consistent quality with minimal generation loss
- Efficient storage for professional video content
- Support for both PAL and NTSC standards
- Compatibility with professional video editing software
- Reliable audio synchronization

When implementing DV video capture, developers have two primary approaches:

1. **Direct Stream Capture** - Raw DV data without recompression
2. **Recompressed DV** - Processed video with customizable settings

Each approach serves different use cases depending on your application requirements.

## Direct Stream Capture Implementation

Direct stream capture provides the highest quality by avoiding any recompression of the video signal. This method is ideal for archival purposes and professional video production where maintaining the original signal integrity is crucial.

### Configuring DV Type Settings

The first step in implementing direct stream capture is setting the appropriate DV type configuration:

#### Delphi

```
VideoCapture1.DV_Capture_Type2 := rbDVType2.Checked;
```

#### C++ MFC

```
m_videoCapture.put_DV_Capture_Type2(m_rbDVType2.GetCheck() == BST_CHECKED);
```

#### VB6

```
VideoCapture1.DV_Capture_Type2 = rbDVType2.Value
```

The DV Type setting determines the specific format variation used for capture. Most modern applications use Type 2, which offers better compatibility with editing software.

### Setting Output Format for Direct Stream

For direct stream capture, you must specify the DirectStream\_DV format:

#### Delphi

```
VideoCapture1.OutputFormat := Format_DirectStream_DV;
```

#### C++ MFC

```
m_videoCapture.SetOutputFormat(Format_DirectStream_DV);
```

#### VB6

```
VideoCapture1.OutputFormat = Format_DirectStream_DV
```

This ensures the video data is stored without additional processing or compression.

### Configuring Capture Mode

Next, set the component to video capture mode:

#### Delphi

```
VideoCapture1.Mode := Mode_Video_Capture;
```

#### C++ MFC

```
m_videoCapture.SetMode(Mode_Video_Capture);
```

#### VB6

```
VideoCapture1.Mode = Mode_Video_Capture
```

This prepares the component for continuous video acquisition rather than single-frame capture.

### Initiating Direct Stream Capture

With all settings in place, you can begin the capture process:

#### Delphi

```
VideoCapture1.Start;
```

#### C++ MFC

```
m_videoCapture.Start();
```

#### VB6

```
VideoCapture1.Start
```

The component will now capture the video stream directly to the specified output location in DV format.

## Implementing DV Capture with Recompression

In some scenarios, you may need to modify the DV stream during capture. This approach allows for customization of audio parameters and video format standards.

### Configuring Audio Parameters

DV format supports multiple audio configurations. Set the channels and sample rate to match your requirements:

#### Delphi

```
VideoCapture1.DV_Capture_Audio_Channels := StrToInt(cbDVChannels.Items[cbDVChannels.ItemIndex]);
VideoCapture1.DV_Capture_Audio_SampleRate := StrToInt(cbDVSampleRate.Items[cbDVSampleRate.ItemIndex]);
```

#### C++ MFC

```
CString channelStr, sampleRateStr;
m_cbDVChannels.GetLBText(m_cbDVChannels.GetCurSel(), channelStr);
m_cbDVSampleRate.GetLBText(m_cbDVSampleRate.GetCurSel(), sampleRateStr);

m_videoCapture.put_DV_Capture_Audio_Channels(_ttoi(channelStr));
m_videoCapture.put_DV_Capture_Audio_SampleRate(_ttoi(sampleRateStr));
```

#### VB6

```
VideoCapture1.DV_Capture_Audio_Channels = CInt(cbDVChannels.List(cbDVChannels.ListIndex))
VideoCapture1.DV_Capture_Audio_SampleRate = CInt(cbDVSampleRate.List(cbDVSampleRate.ListIndex))
```

Standard DV audio options include:

- Channels: 1 (mono) or 2 (stereo)
- Sample rates: 32000 Hz, 44100 Hz, or 48000 Hz

### Setting Video Format Standard

DV supports both PAL and NTSC standards. Select the appropriate standard for your target region:

#### Delphi

```
if rbDVPAL.Checked then
  VideoCapture1.DV_Capture_Video_Format := DVF_PAL
else
  VideoCapture1.DV_Capture_Video_Format := DVF_NTSC;
```

#### C++ MFC

```
if (m_rbDVPAL.GetCheck() == BST_CHECKED)
  m_videoCapture.put_DV_Capture_Video_Format(DVF_PAL);
else
  m_videoCapture.put_DV_Capture_Video_Format(DVF_NTSC);
```

#### VB6

```
If rbDVPAL.Value Then
  VideoCapture1.DV_Capture_Video_Format = DVF_PAL
Else
  VideoCapture1.DV_Capture_Video_Format = DVF_NTSC
End If
```

Remember that:

- PAL: 720×576 resolution at 25 fps (used in Europe, Australia, parts of Asia)
- NTSC: 720×480 resolution at 29.97 fps (used in North America, Japan, parts of South America)

### DV Type Selection

As with direct streaming, specify the DV type for recompressed capture:

#### Delphi

```
VideoCapture1.DV_Capture_Type2 := rbDVType2.Checked;
```

#### C++ MFC

```
m_videoCapture.put_DV_Capture_Type2(m_rbDVType2.GetCheck() == BST_CHECKED);
```

#### VB6

```
VideoCapture1.DV_Capture_Type2 = rbDVType2.Value
```

### Setting Output Format for Recompression

For recompressed DV capture, specify the DV format rather than DirectStream\_DV:

#### Delphi

```
VideoCapture1.OutputFormat := Format_DV;
VideoCapture1.Mode := Mode_Video_Capture;
```

#### C++ MFC

```
m_videoCapture.SetOutputFormat(Format_DV);
m_videoCapture.SetMode(Mode_Video_Capture);
```

#### VB6

```
VideoCapture1.OutputFormat = Format_DV
VideoCapture1.Mode = Mode_Video_Capture
```

This tells the component to process the stream through the DV codec during capture.

### Starting Recompressed Capture

With all parameters configured, begin the capture process:

#### Delphi

```
VideoCapture1.Start;
```

#### C++ MFC

```
m_videoCapture.Start();
```

#### VB6

```
VideoCapture1.Start
```

## Best Practices for DV Capture Implementation

When implementing DV capture in your applications, consider these recommendations:

1. **Pre-allocate sufficient disk space** - DV format requires approximately 13 GB per hour of footage
2. **Implement capture time limits** - DV files have a 4 GB size limit on some file systems
3. **Monitor system resources** - DV capture requires consistent CPU and disk performance
4. **Provide format selection UI** - Let users choose between direct stream and recompressed options
5. **Test with various camera models** - DV implementation can vary between manufacturers

## Error Handling Considerations

Robust DV capture implementations should include error handling for these common scenarios:

- Device disconnection during capture
- Disk space exhaustion
- Buffer overrun conditions
- Invalid format settings
- Codec compatibility issues

## Conclusion

Implementing DV video capture in your Delphi, C++ MFC, or VB6 applications provides a solid foundation for professional video acquisition workflows. Whether you choose direct stream capture for maximum quality or recompressed capture for additional flexibility, the DV format offers reliable performance for specialized video applications.

By following the implementation examples in this guide, you can integrate professional-grade video capture capabilities into your custom software solutions.

---

Need additional assistance with your video capture implementation? Visit our [GitHub](https://github.com/visioforge/) page for more code samples or contact our [support team](https://support.visioforge.com/) for personalized guidance.

---END OF PAGE---


## Video Capture to WMV Format in Delphi, C++ MFC and VB6
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/video-capture-wmv/
**Description:** Capture video to WMV format - external profiles, output configuration, and implementation for Delphi, C++ MFC, and VB6 with code examples.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, C++, Windows, VCL, Capture, Streaming, Encoding, WMV

# Video Capture to Windows Media Video (WMV) Using External Profiles

## Introduction

Capturing video to Windows Media Video (WMV) format is a common requirement in many software applications. This guide provides a detailed walkthrough of implementing video capture functionality using external WMV profiles in Delphi, C++ MFC, and VB6 applications. The WMV format remains popular due to its compatibility with Windows platforms and efficient compression algorithms that balance quality and file size.

## Understanding WMV and External Profiles

Windows Media Video (WMV) is a compressed video file format developed by Microsoft as part of the Windows Media framework. When capturing video to WMV format, using external profiles allows for greater flexibility and customization of the output. External profiles contain pre-configured settings that define:

- Video resolution
- Bitrate
- Frame rate
- Compression quality
- Audio settings
- Other encoding parameters

By leveraging external profiles, developers can quickly implement different quality presets without having to manually configure each parameter in code.

## Implementation Steps

### Step 1: Setting Up Your Environment

Before implementing video capture functionality, ensure your development environment is properly configured:

1. Install the necessary video capture component
2. Add the component reference to your project
3. Design your user interface to include:
4. A file selector for choosing the WMV profile
5. Output file location selector
6. Video capture preview window
7. Start/Stop capture controls

### Step 2: Selecting a WMV Profile

The first step in the implementation is to specify which WMV profile to use for encoding. This profile contains all the encoding parameters that will be applied to the captured video.

> `WMV_Profile_Filename` expects the path to a `.prx` Windows Media profile (the encoding-parameters template) — NOT the path to the captured `.wmv` output file. Set the captured filename via `Output_Filename` (or the project's standard filename property).

#### Delphi

```
// Pascal string literals use single quotes.
VideoCapture1.WMV_Profile_Filename := 'C:\Profiles\HighQuality.prx';
```

#### C++ MFC

```
m_videoCapture.SetWMVProfileFilename(_T("C:\\Profiles\\HighQuality.prx"));
```

#### VB6

```
VideoCapture1.WMV_Profile_Filename = "C:\Profiles\HighQuality.prx"
```

### Step 3: Configuring the Output Format

Once the profile is selected, you need to configure the component to use WMV as the output format. This tells the capture component which encoder to use for processing the video stream.

#### Delphi

```
VideoCapture1.OutputFormat := Format_WMV;
```

#### C++ MFC

```
m_videoCapture.SetOutputFormat(FORMAT_WMV);
```

#### VB6

```
VideoCapture1.OutputFormat = FORMAT_WMV
```

### Step 4: Setting the Capture Mode

The capture component can operate in various modes, so it's important to explicitly set it to video capture mode.

#### Delphi

```
VideoCapture1.Mode := Mode_Video_Capture;
```

#### C++ MFC

```
m_videoCapture.SetMode(MODE_VIDEO_CAPTURE);
```

#### VB6

```
VideoCapture1.Mode = MODE_VIDEO_CAPTURE
```

This ensures that the component is configured for continuous video recording rather than other modes like snapshot capture or streaming.

### Step 5: Starting the Video Capture

With all the configuration in place, the final step is to start the actual capture process.

#### Delphi

```
VideoCapture1.Start;
```

#### C++ MFC

```
m_videoCapture.Start();
```

#### VB6

```
VideoCapture1.Start
```

This command begins the capture process using all the previously configured settings.

## Advanced Configuration Options

### Custom Output File Naming

You can implement custom file naming for your captured video files:

#### Delphi

```
VideoCapture1.Output_Filename := 'C:\Captures\Video_' + FormatDateTime('yyyymmdd_hhnnss', Now) + '.wmv';
```

#### C++ MFC

```
CTime currentTime = CTime::GetCurrentTime();
CString fileName;
fileName.Format(_T("C:\\Captures\\Video_%04d%02d%02d_%02d%02d%02d.wmv"),
                currentTime.GetYear(), currentTime.GetMonth(), currentTime.GetDay(),
                currentTime.GetHour(), currentTime.GetMinute(), currentTime.GetSecond());
m_videoCapture.SetOutputFilename(fileName);
```

#### VB6

```
VideoCapture1.Output_Filename = "C:\Captures\Video_" & Format(Now, "yyyymmdd_hhnnss") & ".wmv"
```

These examples create a timestamped filename to ensure each captured file has a unique name.

When designing your application, consider these best practices:

1. Always verify device availability before attempting capture
2. Provide feedback during long encoding operations
3. Include a preview window so users can see what's being captured
4. Implement a file size monitor for long recordings
5. Test with various WMV profiles to ensure compatibility

## Conclusion

Implementing video capture to WMV format using external profiles provides flexibility and control over the capture process. The approach outlined in this guide works effectively in Delphi, C++ MFC, and VB6 development environments, allowing you to integrate professional-grade video capture capabilities into your applications.

By using external profiles, you can quickly switch between different quality settings without changing your code, which is ideal for applications that need to adapt to different use cases or hardware capabilities.

---

For additional code samples, visit our GitHub repository. If you need technical assistance with implementation, our support team is available to help.

---END OF PAGE---


## Video Input Crossbar Selection in Delphi Applications
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/video-input-crossbar/
**Description:** Select video input sources in Delphi with crossbar - configure composite, S-Video, HDMI inputs with step-by-step code examples for Delphi.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture, Decoding, TV Tuner

# Selecting Video Input Sources with Crossbar Technology

## Introduction to Video Input Selection

When developing applications that capture video from external devices, you'll often need to handle multiple input sources. The crossbar is a crucial component in video capture systems that allows you to route different physical inputs (like composite, S-Video, HDMI) to your application. This guide walks you through the process of detecting, configuring, and selecting video inputs using the crossbar interface in Delphi, C++ MFC, and Visual Basic 6 applications.

## Understanding Crossbar Technology

Crossbar technology functions as a routing matrix in video capture devices, enabling the connection between various inputs and outputs. Modern capture cards and TV tuners frequently incorporate crossbar functionality to facilitate switching between different video sources such as:

- Composite video inputs
- S-Video connections
- Component video
- HDMI inputs
- TV tuner inputs
- Digital video interfaces

Properly configuring these connections programmatically is essential for applications that need to dynamically switch between different video sources.

## Implementation Steps Overview

The implementation process for configuring crossbar connections in your application involves three main steps:

1. Initializing the crossbar interface and verifying its availability
2. Enumerating available video inputs for selection
3. Connecting the selected input to the video decoder output

Let's examine each step in detail with sample code for Delphi, C++ MFC, and VB6 environments.

## Detailed Implementation Guide

### Step 1: Initialize the Crossbar Interface

Before you can work with input selection, you need to initialize the crossbar interface and verify it's available on the current capture device.

#### Delphi Implementation

```
// Initialize the crossbar interface
CrossBarFound := VideoCapture1.Video_CaptureDevice_CrossBar_Init;

// Check if crossbar functionality is available
if CrossBarFound then
  ShowMessage('Crossbar functionality detected and initialized')
else
  ShowMessage('No crossbar available on this capture device');
```

#### C++ MFC Implementation

```
// Initialize the crossbar interface
BOOL bCrossBarFound = m_videoCapture.Video_CaptureDevice_CrossBar_Init();

// Check if crossbar functionality is available
if (bCrossBarFound) {
    AfxMessageBox(_T("Crossbar functionality detected and initialized"));
} else {
    AfxMessageBox(_T("No crossbar available on this capture device"));
}
```

#### VB6 Implementation

```
' Initialize the crossbar interface
Dim CrossBarFound As Boolean
CrossBarFound = VideoCapture1.Video_CaptureDevice_CrossBar_Init()

' Check if crossbar functionality is available
If CrossBarFound Then
    MsgBox "Crossbar functionality detected and initialized"
Else
    MsgBox "No crossbar available on this capture device"
End If
```

The initialization function returns a boolean value indicating whether the crossbar functionality is available on the current capture device. Not all capture devices support crossbar functionality, so this check is crucial.

### Step 2: Enumerate Available Video Inputs

Once you've confirmed that the crossbar is available, the next step is to retrieve a list of available inputs for the "Video Decoder" output. This allows users to select from available physical connections.

#### Delphi Implementation

```
// Variables declared at the procedure level so the snippet compiles on any Delphi 6+ IDE
// (inline `var name: T := ...` requires Delphi 10.3 Rio or later).
procedure TForm1.PopulateCrossBarInputs;
var
  inputCount: Integer;
  inputName: String;
  i: Integer;
begin
  // Clear any existing connections and UI elements
  VideoCapture1.Video_CaptureDevice_CrossBar_ClearConnections;
  cbCrossbarVideoInput.Clear;

  // Get count of available inputs for the "Video Decoder" output
  inputCount := VideoCapture1.Video_CaptureDevice_CrossBar_GetInputsForOutput_GetCount('Video Decoder');

  // Populate UI with available inputs
  for i := 0 to inputCount - 1 do begin
    inputName := VideoCapture1.Video_CaptureDevice_CrossBar_GetInputsForOutput_GetItem('Video Decoder', i);
    cbCrossbarVideoInput.Items.Add(inputName);
  end;

  // Select the first item by default if available
  if cbCrossbarVideoInput.Items.Count > 0 then
    cbCrossbarVideoInput.ItemIndex := 0;
end;
```

#### C++ MFC Implementation

```
// Clear any existing connections and UI elements
m_videoCapture.Video_CaptureDevice_CrossBar_ClearConnections();
m_comboVideoInputs.ResetContent();

// Get count of available inputs for the "Video Decoder" output
int inputCount = m_videoCapture.Video_CaptureDevice_CrossBar_GetInputsForOutput_GetCount(_T("Video Decoder"));

// Populate UI with available inputs
for (int i = 0; i < inputCount; i++) {
    CString inputName = m_videoCapture.Video_CaptureDevice_CrossBar_GetInputsForOutput_GetItem(_T("Video Decoder"), i);
    m_comboVideoInputs.AddString(inputName);
}

// Select the first item by default if available
if (m_comboVideoInputs.GetCount() > 0) {
    m_comboVideoInputs.SetCurSel(0);
}
```

#### VB6 Implementation

```
' Clear any existing connections and UI elements
VideoCapture1.Video_CaptureDevice_CrossBar_ClearConnections
cboVideoInputs.Clear

' Get count of available inputs for the "Video Decoder" output
Dim inputCount As Integer
inputCount = VideoCapture1.Video_CaptureDevice_CrossBar_GetInputsForOutput_GetCount("Video Decoder")

' Populate UI with available inputs
Dim i As Integer
Dim inputName As String
For i = 0 To inputCount - 1
    inputName = VideoCapture1.Video_CaptureDevice_CrossBar_GetInputsForOutput_GetItem("Video Decoder", i)
    cboVideoInputs.AddItem inputName
Next i

' Select the first item by default if available
If cboVideoInputs.ListCount > 0 Then
    cboVideoInputs.ListIndex = 0
End If
```

Common input types you might encounter include:

- Composite
- S-Video
- HDMI
- Component
- TV Tuner

The exact list depends on your specific capture hardware capabilities.

### Step 3: Apply the Selected Input

After the user selects their desired input source, you need to apply this selection by establishing a connection between the selected input and the video decoder output.

#### Delphi Implementation

```
// Variables at procedure level — compatible with Delphi 6+ (avoids the inline `var`
// shorthand introduced in Delphi 10.3 Rio).
procedure TForm1.ApplySelectedCrossBarInput;
var
  selectedInput: String;
  success: Boolean;
begin
  // First clear any existing connections
  VideoCapture1.Video_CaptureDevice_CrossBar_ClearConnections;

  // Connect the selected input to the "Video Decoder" output
  // Parameters: input name, output name, automatic signal routing
  if cbCrossbarVideoInput.ItemIndex >= 0 then begin
    selectedInput := cbCrossbarVideoInput.Items[cbCrossbarVideoInput.ItemIndex];
    success := VideoCapture1.Video_CaptureDevice_CrossBar_Connect(selectedInput, 'Video Decoder', true);

    if success then
      ShowMessage('Successfully connected ' + selectedInput + ' to Video Decoder')
    else
      ShowMessage('Failed to establish connection');
  end;
end;
```

#### C++ MFC Implementation

```
// First clear any existing connections
m_videoCapture.Video_CaptureDevice_CrossBar_ClearConnections();

// Connect the selected input to the "Video Decoder" output
// Parameters: input name, output name, automatic signal routing
int selectedIndex = m_comboVideoInputs.GetCurSel();
if (selectedIndex >= 0) {
    CString selectedInput;
    m_comboVideoInputs.GetLBText(selectedIndex, selectedInput);

    BOOL success = m_videoCapture.Video_CaptureDevice_CrossBar_Connect(
        selectedInput, _T("Video Decoder"), TRUE);

    if (success) {
        CString msg;
        msg.Format(_T("Successfully connected %s to Video Decoder"), selectedInput);
        AfxMessageBox(msg);
    } else {
        AfxMessageBox(_T("Failed to establish connection"));
    }
}
```

#### VB6 Implementation

```
' First clear any existing connections
VideoCapture1.Video_CaptureDevice_CrossBar_ClearConnections

' Connect the selected input to the "Video Decoder" output
' Parameters: input name, output name, automatic signal routing
If cboVideoInputs.ListIndex >= 0 Then
    Dim selectedInput As String
    selectedInput = cboVideoInputs.Text

    Dim success As Boolean
    success = VideoCapture1.Video_CaptureDevice_CrossBar_Connect(selectedInput, "Video Decoder", True)

    If success Then
        MsgBox "Successfully connected " & selectedInput & " to Video Decoder"
    Else
        MsgBox "Failed to establish connection"
    End If
End If
```

The third parameter (`true`) enables automatic signal routing, which helps handle complex connection scenarios where intermediate routing might be required.

## Best Practices for Crossbar Implementation

For robust video input selection in your applications:

1. **Always initialize the crossbar first**: Check for availability before attempting operations
2. **Clear existing connections**: Before setting a new connection, clear any existing ones
3. **Handle missing crossbar gracefully**: Provide fallback options when crossbar functionality isn't available
4. **Validate selections**: Ensure a valid input is selected before attempting to establish connections
5. **Provide user feedback**: Inform users about successful or failed connection attempts

## Troubleshooting Common Issues

If you encounter problems with crossbar connections:

- Verify your capture device supports crossbar functionality
- Check that input and output names match exactly what the device reports
- Ensure proper device driver installation
- Use debug logging to track connection attempts
- Test with different input sources to isolate hardware-specific issues

## Conclusion

Proper implementation of crossbar technology in your video capture applications gives users the flexibility to work with multiple input sources. By following the steps outlined in this guide, you can create a robust and user-friendly video input selection system for your applications regardless of whether you're developing in Delphi, C++ MFC, or Visual Basic 6.

The code samples provided demonstrate how to initialize the crossbar, enumerate available inputs, and connect selected inputs to the video decoder output. With these fundamentals in place, you can build sophisticated video capture applications that support a wide range of input devices and connection types.

---

For additional assistance with implementing this functionality, explore our other documentation pages and code samples repository for more advanced techniques and solutions.

---END OF PAGE---


## Video Renderer Selection in Delphi — EVR, VMR9, and GDI
**URL:** https://www.visioforge.com/help/docs/delphi/videocapture/video-renderer/
**Description:** Select optimal video renderers in Delphi - Video Renderer, VMR9, EVR with code examples for performance and hardware acceleration on Windows.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Capture
**API:** TVFVideoCapture

# Video Renderer Selection Guide for TVFVideoCapture

## Overview of Available Renderers

When developing video capture applications with TVFVideoCapture, selecting the appropriate video renderer significantly impacts performance and compatibility. This guide provides detailed implementation examples for the three available renderer options in Delphi, C++, and VB6 environments.

## Standard Video Renderer

The standard Video Renderer utilizes GDI for drawing operations. This renderer option is primarily recommended for:

- Legacy systems
- Environments where Direct3D acceleration is unavailable
- Maximum compatibility with older hardware

```
// Delphi
VideoCapture1.Video_Renderer := VR_VideoRenderer;
```

```
// C++ MFC
m_VideoCapture.SetVideo_Renderer(VR_VideoRenderer);
```

```
' VB6
VideoCapture1.Video_Renderer = VR_VideoRenderer
```

## Video Mixing Renderer 9 (VMR9)

VMR9 represents a modern filtering solution capable of leveraging GPU capabilities for enhanced rendering. Key advantages include:

- Hardware-accelerated video processing
- Advanced deinterlacing options
- Improved performance for high-resolution content

```
// Delphi
VideoCapture1.Video_Renderer := VR_VMR9;
```

```
// C++ MFC
m_VideoCapture.SetVideo_Renderer(VR_VMR9);
```

```
' VB6
VideoCapture1.Video_Renderer = VR_VMR9
```

### Accessing Deinterlacing Modes

VMR9 supports multiple deinterlacing techniques. The following code demonstrates how to retrieve available deinterlacing options:

```
// Delphi
VideoCapture1.Video_Renderer_Deinterlace_Modes_Fill;
for I := 0 to VideoCapture1.Video_Renderer_Deinterlace_Modes_GetCount - 1 do
  cbDeinterlaceModes.Items.Add(VideoCapture1.Video_Renderer_Deinterlace_Modes_GetItem(i));
```

```
// C++ MFC
m_VideoCapture.Video_Renderer_Deinterlace_Modes_Fill();
for (int i = 0; i < m_VideoCapture.Video_Renderer_Deinterlace_Modes_GetCount(); i++) {
    m_DeinterlaceCombo.AddString(m_VideoCapture.Video_Renderer_Deinterlace_Modes_GetItem(i));
}
```

```
' VB6
VideoCapture1.Video_Renderer_Deinterlace_Modes_Fill
For i = 0 To VideoCapture1.Video_Renderer_Deinterlace_Modes_GetCount - 1
    cboDeinterlaceModes.AddItem VideoCapture1.Video_Renderer_Deinterlace_Modes_GetItem(i)
Next i
```

## Enhanced Video Renderer (EVR)

EVR is the recommended renderer for modern Windows environments (Vista and later). This advanced renderer provides:

- Superior video acceleration capabilities
- Optimal performance on Windows 7/10/11
- Better resource utilization

```
// Delphi
VideoCapture1.Video_Renderer := VR_EVR;
```

```
// C++ MFC
m_VideoCapture.SetVideo_Renderer(VR_EVR);
```

```
' VB6
VideoCapture1.Video_Renderer = VR_EVR
```

## Managing Aspect Ratio and Display Options

When displaying video content, you'll often need to handle aspect ratio differences between the source video and the display area.

### Stretching the Video Image

To stretch the video to fill the entire display area:

```
// Delphi
VideoCapture1.Screen_Stretch := true;
VideoCapture1.Screen_Update;
```

```
// C++ MFC
m_VideoCapture.SetScreen_Stretch(true);
m_VideoCapture.Screen_Update();
```

```
' VB6
VideoCapture1.Screen_Stretch = True
VideoCapture1.Screen_Update
```

### Using Letterbox Mode (Black Borders)

For preserving the original aspect ratio with black borders:

```
// Delphi
VideoCapture1.Screen_Stretch := false;
VideoCapture1.Screen_Update;
```

```
// C++ MFC
m_VideoCapture.SetScreen_Stretch(false);
m_VideoCapture.Screen_Update();
```

```
' VB6
VideoCapture1.Screen_Stretch = False
VideoCapture1.Screen_Update
```

## Performance Considerations

When selecting a renderer for your application, consider these factors:

1. Target operating system version
2. Hardware capabilities of end-user systems
3. Video resolution and processing requirements
4. Compatibility needs for your deployment environment

---

Please get in touch with [support](https://support.visioforge.com/) if you need technical assistance with this implementation. Visit our [GitHub](https://github.com/visioforge/) repository for additional code samples and resources.

---END OF PAGE---


## TVFVideoEdit Changelog - Delphi Video Editing SDK Updates
**URL:** https://www.visioforge.com/help/docs/delphi/videoedit/changelog/
**Description:** TVFVideoEdit version history from 2.1 to 10.0 with features, bug fixes, FFMPEG integration, Windows 8 support, and video effects updates.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Streaming, Editing
**API:** TVFVideoEdit

# TVFVideoEdit Library: Complete Version History

## Version 10.0 - Latest Release

### Core Improvements

- **Enhanced Media Compatibility**: Added dedicated MP3 splitter component to resolve playback issues with problematic MP3 files that fail with the default splitter
- **Audio Processing Enhancements**: Significantly improved information extraction and metadata reading for Speex audio files
- **Performance Optimization**: Fixed critical memory leak in FFMPEG source implementation for better resource management
- **Expanded Format Support**: YUV2RGB filter now fully supports HDYC format for professional video workflows

## Version 8.7 - Engine Updates

### Technical Enhancements

- **VLC Integration**: Updated VLC engine to latest stable release (libVLC 2.2.1.0) for improved codec support
- **Decoding Capabilities**: Implemented latest FFMPEG engine version with expanded format compatibility

## Version 8.6 - Stability Improvements

### Bug Fixes & Additions

- **Memory Management**: Resolved critical memory leak affecting long-running applications
- **File Handling**: Fixed issues with incorrectly closed input and output files that caused resource locking
- **WebM Support**: Added new high-performance WebM filters based on the official WebM project specifications

## Version 8.4 - Platform Expansion

### Development Environment Support

- **Modern Delphi**: Added full Delphi XE8 integration and compatibility
- **Architecture Expansion**: Introduced both Delphi and ActiveX 64-bit (x64) implementations

## Version 8.3.1 - Compatibility Update

### Development Tools

- **IDE Support**: Added complete Delphi XE7 compatibility and integration

## Version 8.3 - Performance Release

### Core Improvements

- **Decoder Update**: Substantially improved FFMPEG decoder implementation
- **Stability**: Fixed multiple bugs affecting reliability and performance

## Version 8.0 - Major Engine Upgrade

### Key Features

- **Playback Architecture**: Implemented VLC engine for enhanced video/audio file playback capabilities
- **Reliability**: Resolved several critical bugs affecting performance

## Version 7.15 - Security Features

### Media Protection

- **Content Security**: Added encrypted video file playback functionality
- **Stability**: Implemented minor bug fixes for improved reliability

## Version 7.2 - Effects & Performance

### Visual Enhancements

- **FFMPEG Implementation**: Updated FFMPEG decoder for better format support
- **Video Effects**: Added professional pan/zoom video effect capabilities
- **Reliability**: Fixed minor bugs for improved stability

## Version 7.0 - Windows 8 & FFMPEG

### Platform Support

- **Operating System**: Added full Windows 8 RTM support
- **Media Handling**: Integrated comprehensive FFMPEG decoding capabilities
- **Visual Effects**: Substantially improved video effects processing quality

## Version 6.0 - Windows 8 Preview

### Platform Expansion

- **Early Adoption**: Added Windows 8 Developer Preview compatibility
- **Visual Processing**: Enhanced quality and performance of video effects

## Version 3.4 - Maintenance Release

### Stability Improvements

- **Bug Fixes**: Resolved multiple issues affecting reliability

## Version 3.3 - Delphi XE2 Support

### Developer Tools

- **IDE Compatibility**: Added full Delphi XE2 support and integration
- **Stability**: Implemented various bug fixes for improved reliability

## Version 3.2 - Effects & Demos

### Enhanced Capabilities

- **Visual Effects**: Significantly improved video effects processing
- **Developer Resources**: Added additional demo applications for easier implementation

## Version 3.1 - Effects Upgrade

### Visual Processing

- **Effects Engine**: Enhanced video effects processing capabilities
- **Stability**: Fixed multiple bugs for improved reliability

## Version 3.0 - Feature Expansion

### Major Enhancements

- **Effects System**: Substantially improved effects filter functionality
- **Streaming**: Added MMS / WMV stream playback support
- **Video Analysis**: Implemented motion detection capabilities
- **Compositing**: Added professional chroma-key functionality
- **Core Performance**: Significantly improved underlying engine

## Version 2.2 - Effects Update

### Visual Processing

- **Effects Quality**: Enhanced effects filter implementation for better visual results

## Version 2.1 - Initial Effects

### First Implementations

- **Visual Processing**: Introduced initial effects filter capabilities

---END OF PAGE---


## Deploy TVFVideoEdit in Delphi and ActiveX Applications
**URL:** https://www.visioforge.com/help/docs/delphi/videoedit/deployment/
**Description:** Deploy TVFVideoEdit in Delphi and ActiveX applications with automatic installers or manual setup for required components and dependencies.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, DirectShow, Windows, VCL, Encoding, Editing, IP Camera, MP4, WebM, H.264, AAC
**API:** TVFVideoEdit

# TVFVideoEdit Library Deployment Guide

## Introduction

The TVFVideoEdit library provides powerful video editing capabilities for your Delphi and ActiveX applications. This guide explains how to properly deploy all necessary components to ensure your application functions correctly on end-user systems without requiring the full development framework.

## Deployment Options

You have two primary methods for deploying the TVFVideoEdit library components: automatic installers or manual installation. Each approach has specific advantages depending on your distribution requirements.

### Automatic Silent Installers

For streamlined deployment, we offer silent installer packages that handle all necessary component installation without user interaction:

#### Required Base Package

- **Base components** (always required):
- [Delphi version](https://files.visioforge.com/redists_delphi/redist_video_edit_base_delphi.exe)
- [ActiveX version](https://files.visioforge.com/redists_delphi/redist_video_edit_base_ax.exe)

#### Optional Feature Packages

- **FFMPEG package** (required for file and IP camera support (only for FFMPEG source engine)):
- [x86 architecture](https://files.visioforge.com/redists_delphi/redist_video_edit_ffmpeg.exe)
- **MP4 output package** (for MP4 video creation):
- [x86 architecture](https://files.visioforge.com/redists_delphi/redist_video_edit_mp4.exe)

### Manual Installation Process

For situations where you need precise control over component deployment, follow these detailed steps:

1. **Install Visual C++ Dependencies**
2. Install VC++ 2010 SP1 redistributable:

   - [x86 version](https://files.visioforge.com/shared/vcredist_2010_x86.exe)
   - [x64 version](https://files.visioforge.com/shared/vcredist_2010_x64.exe)
3. **Deploy Core Media Foundation Components**
4. Copy all MFP DLLs from the `Redist\Filters` directory to your application folder
5. **Register DirectShow Filters**
6. Copy and COM-register these essential DirectShow filters using [regsvr32.exe](https://support.microsoft.com/en-us/topic/how-to-use-the-regsvr32-tool-and-troubleshoot-regsvr32-error-messages-a98d960a-7392-e6fe-d90a-3f4e0cb543e5).
7. **Bitness:** the bare filename is the **x86 (32-bit)** filter; the matching **x64 (64-bit)** filter has the `_x64` suffix (for example `VisioForge_Video_Effects_Pro_x64.ax`). Both ship in the redistributable; deploy and register the variant that matches your application's target architecture. 64-bit applications must register the `_x64` variants.
   - `VisioForge_Audio_Effects_4.ax`
   - `VisioForge_Dump.ax`
   - `VisioForge_RGB2YUV.ax`
   - `VisioForge_Video_Effects_Pro.ax`
   - `VisioForge_Video_Mixer.ax`
   - `VisioForge_Video_Resize.ax`
   - `VisioForge_WavDest.ax`
   - `VisioForge_YUV2RGB.ax`
   - `VisioForge_FFMPEG_Source.ax`

Screen-capture functionality (formerly delivered as `VisioForge_Screen_Capture.ax`) is now part of the base filters and does not require a separate registration step.

1. **Configure Path Settings**
2. Add the folder containing these filters to the system environment variable `PATH` if your application executable resides in a different directory

## Additional Components Installation

### FFMPEG Integration

To enable advanced media format support:

- Copy all files from the `Redist\FFMPEG` folder
- Add this folder to the Windows system `PATH` variable
- Register all .ax files from the `Redist\FFMPEG` folder

### VLC Support

For extended format compatibility:

- Copy all files from the `Redist\VLC` folder
- COM-register the .ax file using regsvr32.exe
- Create an environment variable named `VLC_PLUGIN_PATH`
- Set its value to point to the `VLC\plugins` folder

### Audio Output Support

For MP3 encoding capabilities:

- Copy the lame.ax file from the `Redist\Formats` folder
- Register the lame.ax file using regsvr32.exe

### WebM Format Support

For WebM encoding and decoding:

- Install the necessary free codecs available from the [xiph.org website](https://www.xiph.org/dshow/)

### Matroska Container Support

For MKV format compatibility:

- Install [Haali Matroska Splitter](https://haali.net/mkv/) for proper encoding and decoding

### MP4 H264/AAC Output - Modern Encoder

For high-quality MP4 creation with modern codecs:

- Copy `libmfxsw32.dll` / `libmfxsw64.dll` files
- Register these DirectShow filters:
- `VisioForge_H264_Encoder.ax`
- `VisioForge_MP4_Muxer.ax`
- `VisioForge_AAC_Encoder.ax`
- `VisioForge_Video_Resize.ax`

### MP4 H264/AAC Output - Legacy Encoder

For compatibility with older systems:

- Copy `libmfxxp32.dll` / `libmfxxp64.dll` files
- Register these DirectShow filters:
- `VisioForge_H264_Encoder_XP.ax`
- `VisioForge_MP4_Muxer_XP.ax`
- `VisioForge_AAC_Encoder_XP.ax`
- `VisioForge_Video_Resize.ax`

## Bulk Registration Utility

To simplify the registration process for multiple DirectShow filters:

- Place the `reg_special.exe` utility from the redistributable package into the folder containing your filters
- Run it with administrator privileges to register all compatible filters in that directory

## Troubleshooting Tips

Common issues during deployment often include:

- Missing dependencies
- Incorrect registration of COM components
- Path configuration problems
- Insufficient user permissions

Ensure all required files are properly deployed and registered before launching your application.

---

Please contact [our support team](https://support.visioforge.com/) if you encounter any issues with this deployment process. Visit our [GitHub repository](https://github.com/visioforge/) for additional code samples and implementation examples.

---END OF PAGE---


## TVFVideoEdit - Video Editing SDK for Delphi and ActiveX
**URL:** https://www.visioforge.com/help/docs/delphi/videoedit/
**Description:** Build video editing software in Delphi with TVFVideoEdit - supporting multiple formats, effects, transitions, timeline editing, and encryption.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Editing
**API:** TVFVideoEdit

# TVFVideoEdit for Delphi / ActiveX Development

## Introduction to TVFVideoEdit

The TVFVideoEdit library empowers Delphi developers to integrate sophisticated video editing functionality into their applications. This robust SDK provides a complete framework for handling diverse media operations while maintaining excellent performance and stability across projects of varying complexity.

## Core Capabilities

### Format Support

TVFVideoEdit accommodates a wide array of video and audio formats, enabling seamless work with most industry-standard media types. This extensive compatibility ensures your application can process virtually any file users might import.

### Video Processing

The library excels in fundamental video manipulation tasks, offering precise control over:

- Resolution adjustment
- Frame rate conversion
- Aspect ratio modification
- Color correction tools
- Quality enhancement algorithms

### Effects and Transitions

Enhance your application with:

- Professional visual effects
- Smooth transitions between clips
- Custom animation capabilities
- Real-time preview functionality
- Text overlay with font control
- Image compositing
- Watermarking capabilities
- Custom graphic insertion

#### Audio Processing

Create complete multimedia solutions with:

- Volume normalization
- Equalization tools
- Audio effects application
- Voice enhancement options

## Technical Advantages

### Output Flexibility

Export finished projects in multiple formats with customizable quality settings to meet specific distribution requirements.

### Timeline Precision

The timeline-based editing framework gives developers granular control over media positioning, transitions, and effects timing.

### Multi-Platform Compatibility

Deploy your video editing solutions across different Windows environments with consistent performance and reliability.

### Distribution Rights

TVFVideoEdit supports royalty-free distribution, making it a cost-effective solution for commercial software development.

## Resources for Developers

Accelerate your development with these valuable resources:

- [Product Information](https://www.visioforge.com/all-in-one-media-framework)
- [API Documentation](https://api.visioforge.org/delphi/video_edit_sdk/index.html)
- [Changelog](changelog/)
- [Installation Guide](install/)
- [Deployment Instructions](deployment/)
- [License Agreement](../../eula/)

---END OF PAGE---


## Install TVFVideoEdit ActiveX Control in C++ Builder
**URL:** https://www.visioforge.com/help/docs/delphi/videoedit/install/builder/
**Description:** Import and configure TVFVideoEdit ActiveX components in C++ Builder 5/6, 2006, and newer versions with package and control setup.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Editing
**API:** TVFVideoEdit

# Complete Guide to TVFVideoEdit Installation in C++ Builder

> Related products: [VisioForge All-in-One Media Framework (Delphi / ActiveX)](https://www.visioforge.com/all-in-one-media-framework)

## Introduction to TVFVideoEdit for C++ Builder

The TVFVideoEdit library provides powerful media processing capabilities for C++ Builder applications. This guide walks you through the installation process across different C++ Builder versions. Before you begin development, you'll need to properly install the ActiveX control into your IDE environment where it will be accessible through the component palette.

## Installation Process for Borland C++ Builder 5/6

### Accessing the Import Menu

Begin the installation process by navigating to the Component menu in your IDE:

1. Launch your Borland C++ Builder 5/6 environment
2. From the main menu, select **Component -> Import ActiveX Controls**

### Selecting the Video Edit Control

In the Import ActiveX Control dialog:

1. Locate and select the **"VisioForge Video Edit Control"** from the available controls list
2. Click the **Install** button to begin the import process

### Confirming Installation

The system will prompt you to confirm the installation:

1. A confirmation dialog will appear
2. Click the **Yes** button to proceed with the installation

### Verifying Successful Installation

After installation completes:

1. The control will be added to your component palette
2. You can now use it in your C++ Builder projects

## Installation Guide for C++ Builder 2006 and Later Versions

Modern versions of C++ Builder require a different installation approach using packages.

### Creating a New Package

First, you'll need to create a package for the component:

1. Open C++ Builder 2006 or later
2. Select **File -> New -> Package**
3. This will create the foundation for adding the ActiveX control

### Importing the ActiveX Component

Next, import the ActiveX control into your environment:

1. Navigate to **Component → Import Component** in the main menu
2. This opens the import wizard for adding new components

### Selecting Import Type

In the import wizard:

1. Select the **Import ActiveX Control** radio button option
2. Click the **Next** button to proceed to component selection

### Choosing the Video Edit Control

From the available ActiveX controls:

1. Find and select the **"VisioForge Video Edit Control"** from the list
2. Click **Next** to continue with the import process

### Configuring Output Location

Specify where the component files should be stored:

1. Choose an appropriate package output folder for your development environment
2. Click **Next** to proceed with configuration

### Finalizing Component Import

Complete the import process:

1. Select the **Add unit to…** radio button option
2. Click the **Finish** button to create the component wrapper

### Saving the Package Project

After import completion:

1. The system will prompt you to save your package project
2. Choose an appropriate location and name for your package files

### Installing the Component Package

To make the component available in the IDE:

1. Right-click on the package in the Project Manager
2. Select **Install** from the context menu
3. This compiles and registers the package with the IDE

### Verification and Usage

Once installed:

1. The TVFVideoEdit control appears in your component palette
2. It's now ready to use in your C++ Builder applications
3. You can drag and drop it onto forms just like native components

## Additional Resources and Support

### Getting Help with Implementation

If you encounter any issues during installation or implementation:

1. Our technical support team is available to assist
2. Contact [support](https://support.visioforge.com/) with specific questions
3. Provide details about your Builder version and installation environment

### Code Examples and Documentation

To accelerate your development process:

1. Visit our [GitHub repository](https://github.com/visioforge/) for code samples
2. Find implementation examples for common media processing tasks
3. Access additional documentation on component features and usage

## Troubleshooting Common Installation Issues

When installing the TVFVideoEdit component, developers may encounter several common issues:

1. **Missing Dependencies**: Ensure all required dependencies are installed
2. **Registration Problems**: Verify ActiveX registration status in Windows registry
3. **IDE Compatibility**: Check compatibility between component and Builder version
4. **Package Conflicts**: Resolve any conflicts with existing packages

By following this detailed guide, you'll have TVFVideoEdit successfully integrated into your C++ Builder environment and ready for implementing advanced media functionality in your applications.

---END OF PAGE---


## Install TVFVideoEdit in Delphi - Setup and Configuration
**URL:** https://www.visioforge.com/help/docs/delphi/videoedit/install/delphi/
**Description:** Install TVFVideoEdit packages in Delphi 6/7, 2005+, and 11+ with library paths, package building, and troubleshooting configuration.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Editing
**API:** TVFVideoEdit

# Install TVFVideoEdit in Delphi

> Related products: [VisioForge All-in-One Media Framework (Delphi / ActiveX)](https://www.visioforge.com/all-in-one-media-framework)

## Installation Requirements

Before beginning the installation process, ensure that you have:

1. Appropriate Delphi version installed and properly configured
2. Administrative rights for package installation
3. Downloaded the latest version of the TVFVideoEdit library

## Installing in Borland Delphi 6/7

### Step 1: Configure Library Paths

Begin by opening the "Options" window in your Delphi IDE.

Navigate to the Library section and add the package folder (`Video Edit\Packages\Delphi <version>`, which holds the precompiled `.dcu` units) to both the library and browsing paths. This ensures that Delphi can locate the necessary files.

### Step 2: Open and Install the Package

Locate and open the main package file from the library.

Install the package by clicking the Install button in the IDE. This registers the components with Delphi's component palette.

### Architecture Considerations

The library includes both x86 and x64 architecture versions. However, for Delphi 6/7, you must use the x86 version as these Delphi versions do not support 64-bit development.

## Installing in Delphi 2005 and Later

### Step 1: Launch with Administrative Privileges

For Delphi 2005 and later versions, launch the IDE with administrative rights to ensure proper installation permissions.

### Step 2: Configure Library Paths

Open the Options window and navigate to the Library section. Add the package folder (`Video Edit\Packages\Delphi <version>`, which holds the precompiled `.dcu` units) to both the library and browsing paths.

### Step 3: Install the Package

Open the main package file `VisioForge_Video_Edit_Package.dpk` from the `Video Edit\Packages\Delphi <version>` folder.

Click the Install button to register the components with Delphi's component palette.

### Architecture Support

For Delphi 2005 and later versions, both x86 and x64 versions are available. You can utilize the 64-bit version if you need to develop 64-bit applications. Note that the IDE itself may require the x86 version for design-time operations.

## Installing in Delphi 11 and Later

Modern Delphi versions feature a streamlined installation process:

1. Open the `VisioForge_Video_Edit_Package.dproj` package project located in the `Video Edit\Packages\Delphi <version>` folder after installation
2. Select the Release build configuration from the dropdown menu
3. Build and install the package using the IDE's build commands
4. The components will be registered and ready to use

## Project Configuration Best Practices

You can install both x86 and x64 packages based on your project requirements. Ensure you've properly configured your application's library path settings:

1. Add the correct library folder path to your project options
2. Configure the path to properly locate `.dcu` files
3. Verify architecture compatibility between your project and the installed packages

## Troubleshooting Common Installation Issues

If you encounter problems during installation, check these common issues:

### Delphi 64-bit Package Installation Problems

Some specific issues can occur when installing 64-bit packages. See our [detailed troubleshooting guide](../../../general/install-64bit/) for solutions.

### Issues with .otares Files

Installation problems related to `.otares` files are documented in our [dedicated troubleshooting page](../../../general/install-otares/).

## Additional Resources and Support

For additional code examples and implementations, visit our [GitHub repository](https://github.com/visioforge/) where we maintain a collection of sample projects.

If you need personalized assistance with installation or implementation, please contact our [technical support team](https://support.visioforge.com/) who can provide guidance specific to your development environment.

---

For technical questions or installation assistance with this library, please reach out to our [development support team](https://support.visioforge.com/). Browse additional code samples and resources on our [GitHub](https://github.com/visioforge/) page.

---END OF PAGE---


## Install TVFVideoEdit in Delphi, VB6, and C++ Builder
**URL:** https://www.visioforge.com/help/docs/delphi/videoedit/install/
**Description:** Install TVFVideoEdit library in Delphi and ActiveX-compatible IDEs including MFC, VB6, and C++ Builder with package and control setup.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Editing
**API:** TVFVideoEdit

# TVFVideoEdit library installation guide

The library is available as a Delphi package exclusively for Delphi developers, offering tailored functionality and integration. Additionally, the ActiveX control version is versatile and can be used in MFC, VB6, or any other ActiveX-compatible IDEs, providing broad compatibility and flexibility for developers across different platforms. This ensures a robust and adaptable development experience regardless of your preferred environment.

## Installation

1. **Download the latest version of the All-in-One Media Framework**: Visit the [product page](https://www.visioforge.com/all-in-one-media-framework) and download the most recent version of the framework that is suitable for your needs.
2. **Run the setup file**: Once the download is complete, locate the setup file in your download directory and run it. This will start the installation process.
3. **Follow the installation wizard instructions**: The installation wizard will guide you through each step of the process. Carefully read and follow the prompts, accept the license agreement, select the installation directory, and continue by clicking the "Next" button.
4. **Completion**: After the installation is complete, navigate to the installation folder. Here, you will find various library samples and comprehensive documentation designed to assist you in getting started with integrating the library into your projects.

### Delphi packages installation

For detailed instructions on installing the TVFVideoEdit packages in your Delphi IDE, please refer to the following [Delphi installation guide](delphi/).

### ActiveX installation

#### C++ Builder

For [C++ Builder](builder/), the installation process involves importing the ActiveX control into your project. This straightforward process ensures that you can quickly start using the TVFVideoEdit library in your C++ Builder projects.

#### Visual Basic 6

In [Visual Basic 6](visual-basic-6/), open your project and go to the "Project" menu. Select "Components" item, then click "Browse" and find `VisioForge_Video_Edit.ocx` in the `Redist` folder of the installation. Add it to your project to make the components available in your toolbox.

#### Visual Studio 2010 and later

For [Visual Studio 2010 and newer](visual-studio/) versions, open your project in the IDE, right-click on the toolbox, and select "Choose Items". Navigate to the COM components tab, click "Browse", and select `VisioForge_Video_Edit.ocx` from the `Redist` folder (or `Redist\x64` for 64-bit) of the framework's installation directory. This will add the components to your toolbox, allowing their use in your Visual Studio projects.

## Conclusion

By following this detailed guide, you can successfully install and integrate the TVFVideoEdit library into your preferred development environment. If you encounter any issues or need further assistance, please refer to the documentation provided with the framework or contact our support team for help.

---END OF PAGE---


## Install TVFVideoEdit ActiveX Control in Visual Basic 6
**URL:** https://www.visioforge.com/help/docs/delphi/videoedit/install/visual-basic-6/
**Description:** Install TVFVideoEdit ActiveX control in Visual Basic 6 with x86 compatibility for video editing features in legacy applications.
**Tags:** All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Editing
**API:** TVFVideoEdit

# Installing TVFVideoEdit ActiveX Control in Visual Basic 6

## Introduction

Visual Basic 6 remains a popular development environment for creating Windows applications. By leveraging our TVFVideoEdit library as an ActiveX control, developers can incorporate advanced video editing and processing capabilities into their VB6 applications without extensive coding.

## Technical Requirements and Limitations

Microsoft Visual Basic 6 operates as a 32-bit development platform and cannot produce 64-bit applications. Due to this architectural constraint, only the x86 (32-bit) version of our library is compatible with VB6 projects. Despite this limitation, the 32-bit implementation delivers excellent performance and provides full access to the library's extensive feature set.

## Installation Process

Follow these detailed steps to properly install the TVFVideoEdit ActiveX control in your Visual Basic 6 environment:

### Step 1: Create a New Project

Begin by launching Visual Basic 6 and creating a new project:

1. Open Visual Basic 6 IDE
2. Select "New Project" from the File menu
3. Choose "Standard EXE" as the project type
4. Click "OK" to create the baseline project

### Step 2: Access Components Dialog

Next, you need to register the ActiveX control within your development environment:

1. In the menu, navigate to "Project"
2. Select "Components" to open the components dialog

### Step 3: Select the TVFVideoEdit Control

From the Components dialog:

1. Scroll through the available controls
2. Locate and check the box for "VisioForge Video Edit Control"
3. Click "OK" to confirm your selection

### Step 4: Verify Control Registration

After successful registration:

1. The TVFVideoEdit control icon appears in your toolbox
2. This confirms the control is ready for use in your application

### Step 5: Implement the Control

To begin using the control in your application:

1. Select the TVFVideoEdit control from the toolbox
2. Click and drag on your form to place an instance of the control
3. Size the control appropriately for your interface
4. Access properties and methods through the Properties window and code

## Advanced Implementation Tips

- Set appropriate control properties before loading media files
- Handle events for user interaction and processing notifications
- Consider memory management when working with large video files
- Test your application thoroughly with various media formats

---

For technical questions or implementation challenges, contact our [support team](https://support.visioforge.com/). Access additional code examples and resources on our [GitHub repository](https://github.com/visioforge/).

---END OF PAGE---


## Install TVFVideoEdit ActiveX Control in Visual Studio
**URL:** https://www.visioforge.com/help/docs/delphi/videoedit/install/visual-studio/
**Description:** Install TVFVideoEdit ActiveX controls in Visual Studio 2010+ for C++, C#, and VB.NET projects with wrapper assembly configuration.
**Tags:** Video Edit SDK, All-in-One Media Framework, Delphi, ActiveX, Windows, VCL, Editing
**API:** TVFVideoEdit

# Install TVFVideoEdit in Visual Studio

## Overview

> Related products: [All-in-One Media Framework (Delphi / ActiveX)](https://www.visioforge.com/all-in-one-media-framework)

TVFVideoEdit provides powerful video editing capabilities through ActiveX controls that integrate smoothly with various development environments. This guide walks you through the installation process specifically for Visual Studio 2010 and later versions.

## Compatibility Information

The ActiveX control can be used directly in C++ projects without additional wrappers. For C# or VB.Net development, Visual Studio automatically creates a custom wrapper assembly that enables the ActiveX API in managed code environments.

## Prerequisites

Before beginning the installation process, ensure you have:

- Visual Studio 2010 or later installed on your development machine
- Administrative privileges (required for ActiveX registration)
- Both x86 and x64 ActiveX controls registered (Visual Studio might use x86 for the UI designer even when targeting x64)

## Step-by-Step Installation Guide

### Creating a New Project

1. Start Visual Studio and create a new project using C++, C#, or Visual Basic.
2. For this demonstration, we'll use a C# Windows Forms application, but the process applies similarly to VB.Net and C++ MFC projects.

### Adding the ActiveX Control to Your Toolbox

1. Right-click on the Toolbox panel in Visual Studio
2. Select the "Choose Items" option from the context menu that appears

### Selecting the Video Edit Control

1. In the Choose Toolbox Items dialog, locate the COM Components tab
2. Browse through the list or use the search functionality
3. Find and select the "VisioForge Video Edit Control" item
4. Click OK to add the control to your toolbox

### Implementing the Control in Your Form

1. Locate the newly added control in your toolbox
2. Click and drag it onto your form design surface
3. The control is now ready for implementation in your application

## Advanced Integration Options

### .NET Development Recommendations

For developers working with .NET applications, we strongly recommend considering the native [.NET SDK](https://www.visioforge.com/video-edit-sdk-net) as an alternative to ActiveX integration. The .NET SDK offers several advantages:

- Enhanced performance and stability
- Native support for WinForms, WPF, and MAUI controls
- Broader feature set and API capabilities
- Simpler integration with modern development practices

## Troubleshooting Common Issues

When integrating TVFVideoEdit, you might encounter these common challenges:

- Registration issues: Ensure you have administrative privileges
- Architecture mismatches: Verify both x86 and x64 versions are properly registered
- Reference errors: Check that all required dependencies are included in your project

## Additional Resources

If you encounter any difficulties following this tutorial or need specialized assistance with your implementation, our development team is available to provide technical guidance.

- Access additional code samples on our [GitHub repository](https://github.com/visioforge/)
- Contact our [technical support team](https://support.visioforge.com/) for personalized assistance

---END OF PAGE---


## Register DirectShow Filters — regsvr32, C++, and C# Methods
**URL:** https://www.visioforge.com/help/docs/directshow/deployment/filter-registration/
**Description:** Register VisioForge DirectShow filters using manual regsvr32, programmatic methods, and installer automation with troubleshooting tips.
**Tags:** DirectShow, C++, Windows, Encoding, Mixing, MP4, H.264, AAC, C#
**API:** FFMPEGSource, IBaseFilter

# DirectShow Filter Registration Guide

## Overview

DirectShow filters must be registered with Windows before they can be used in applications. This guide covers all registration methods for VisioForge DirectShow filters.

---

## Registration Methods

### Method 1: Automatic Registration (Installer)

The recommended method for end-users is to use the official installer. **Available Installers**: - `visioforge_ffmpeg_source_filter_setup.exe` - FFMPEG Source Filter - `visioforge_vlc_source_filter_setup.exe` - VLC Source Filter - `visioforge_processing_filters_pack_setup.exe` - Processing Filters Pack - `visioforge_encoding_filters_pack_setup.exe` - Encoding Filters Pack - `visioforge_virtual_camera_sdk_setup.exe` - Virtual Camera SDK **Installation Steps**: 1. Run installer as Administrator 2. Follow installation wizard 3. Filters are automatically registered 4. No additional steps required

---

### Method 2: Manual Registration (regsvr32)

For development and testing, you can manually register filters using Windows `regsvr32` utility.

#### Registration Command

```
# Open Command Prompt as Administrator
# Right-click Start → Command Prompt (Admin)

# Register x86 (32-bit) filter
regsvr32 "C:\Path\To\Filter.ax"

# Register x64 (64-bit) filter
regsvr32 "C:\Path\To\Filter_x64.ax"

# Unregister filter
regsvr32 /u "C:\Path\To\Filter.ax"
```

#### SDK-Specific Examples

**FFMPEG Source Filter**:

```
# x86
regsvr32 "C:\Program Files (x86)\VisioForge\FFMPEG Source\VisioForge_FFMPEG_Source.ax"

# x64
regsvr32 "C:\Program Files\VisioForge\FFMPEG Source\VisioForge_FFMPEG_Source_x64.ax"
```

**VLC Source Filter**:

```
# x86 only
regsvr32 "C:\Program Files (x86)\VisioForge\VLC Source\VisioForge_VLC_Source.ax"
```

**Processing Filters Pack** (multiple filters):

```
# Video Effects
regsvr32 "C:\Program Files\VisioForge\Processing Filters\VisioForge_Video_Effects_Pro.ax"
regsvr32 "C:\Program Files\VisioForge\Processing Filters\VisioForge_Video_Effects_Pro_x64.ax"

# Video Mixer
regsvr32 "C:\Program Files\VisioForge\Processing Filters\VisioForge_Video_Mixer.ax"
regsvr32 "C:\Program Files\VisioForge\Processing Filters\VisioForge_Video_Mixer_x64.ax"

# Audio Enhancer
regsvr32 "C:\Program Files\VisioForge\Processing Filters\VisioForge_Audio_Enhancer.ax"
regsvr32 "C:\Program Files\VisioForge\Processing Filters\VisioForge_Audio_Enhancer_x64.ax"
```

**Encoding Filters Pack** (multiple filters):

```
# NVENC Encoder
regsvr32 "C:\Program Files\VisioForge\Encoding Filters\VisioForge_NVENC.ax"
regsvr32 "C:\Program Files\VisioForge\Encoding Filters\VisioForge_NVENC_x64.ax"

# H.264 Encoder
regsvr32 "C:\Program Files\VisioForge\Encoding Filters\VisioForge_H264_Encoder.ax"
regsvr32 "C:\Program Files\VisioForge\Encoding Filters\VisioForge_H264_Encoder_x64.ax"

# AAC Encoder
regsvr32 "C:\Program Files\VisioForge\Encoding Filters\VisioForge_AAC_Encoder.ax"
regsvr32 "C:\Program Files\VisioForge\Encoding Filters\VisioForge_AAC_Encoder_x64.ax"

# MP4 Muxer
regsvr32 "C:\Program Files\VisioForge\Encoding Filters\VisioForge_MP4_Muxer.ax"
regsvr32 "C:\Program Files\VisioForge\Encoding Filters\VisioForge_MP4_Muxer_x64.ax"
```

**Virtual Camera SDK**:

```
# Virtual Camera Driver
regsvr32 "C:\Program Files\VisioForge\Virtual Camera\VisioForge_Virtual_Camera.ax"
regsvr32 "C:\Program Files\VisioForge\Virtual Camera\VisioForge_Virtual_Camera_x64.ax"

# Push Source Filter
regsvr32 "C:\Program Files\VisioForge\Virtual Camera\VisioForge_Push_Video_Source.ax"
regsvr32 "C:\Program Files\VisioForge\Virtual Camera\VisioForge_Push_Video_Source_x64.ax"
```

---

### Method 3: Programmatic Registration (C++)

Register filters programmatically from your application code.

#### Using LoadLibrary and DllRegisterServer

```
#include <windows.h>
#include <iostream>
typedef HRESULT (STDAPICALLTYPE *LPFNDLLREGISTERSERVER)();
HRESULT RegisterFilter(const wchar_t* filterPath)
{
    HMODULE hModule = LoadLibraryW(filterPath);
    if (!hModule)
    {
        DWORD error = GetLastError();
        std::wcerr << L"Failed to load filter: " << filterPath << std::endl;
        std::wcerr << L"Error code: " << error << std::endl;
        return HRESULT_FROM_WIN32(error);
    }
    LPFNDLLREGISTERSERVER pfnDllRegisterServer =
        (LPFNDLLREGISTERSERVER)GetProcAddress(hModule, "DllRegisterServer");
    if (!pfnDllRegisterServer)
    {
        FreeLibrary(hModule);
        return E_FAIL;
    }
    HRESULT hr = pfnDllRegisterServer();
    FreeLibrary(hModule);
    if (SUCCEEDED(hr))
    {
        std::wcout << L"Filter registered successfully: " << filterPath << std::endl;
    }
    else
    {
        std::wcerr << L"Registration failed with HRESULT: " << std::hex << hr << std::endl;
    }
    return hr;
}
HRESULT UnregisterFilter(const wchar_t* filterPath)
{
    HMODULE hModule = LoadLibraryW(filterPath);
    if (!hModule)
    {
        return HRESULT_FROM_WIN32(GetLastError());
    }
    typedef HRESULT (STDAPICALLTYPE *LPFNDLLUNREGISTERSERVER)();
    LPFNDLLUNREGISTERSERVER pfnDllUnregisterServer =
        (LPFNDLLUNREGISTERSERVER)GetProcAddress(hModule, "DllUnregisterServer");
    if (!pfnDllUnregisterServer)
    {
        FreeLibrary(hModule);
        return E_FAIL;
    }
    HRESULT hr = pfnDllUnregisterServer();
    FreeLibrary(hModule);
    return hr;
}
// Usage
int main()
{
    const wchar_t* filterPath = L"C:\\Program Files\\VisioForge\\FFMPEG Source\\VisioForge_FFMPEG_Source_x64.ax";
    HRESULT hr = RegisterFilter(filterPath);
    if (SUCCEEDED(hr))
    {
        std::cout << "Filter registered successfully!" << std::endl;
    }
    else
    {
        std::cout << "Failed to register filter" << std::endl;
    }
    return 0;
}
```

#### Using reg\_special.exe Utility

VisioForge SDKs include a `reg_special.exe` utility for simplified registration:

```
#include <windows.h>
#include <shellapi.h>
HRESULT RegisterWithUtility(const wchar_t* filterPath)
{
    // Build command line
    wchar_t cmdLine[MAX_PATH * 2];
    swprintf_s(cmdLine, L"reg_special.exe /regserver \"%s\"", filterPath);
    // Execute registration utility
    SHELLEXECUTEINFO sei = { sizeof(sei) };
    sei.lpVerb = L"runas";  // Run as administrator
    sei.lpFile = L"reg_special.exe";
    sei.lpParameters = cmdLine;
    sei.nShow = SW_HIDE;
    sei.fMask = SEE_MASK_NOCLOSEPROCESS;
    if (!ShellExecuteEx(&sei))
    {
        return HRESULT_FROM_WIN32(GetLastError());
    }
    // Wait for completion
    WaitForSingleObject(sei.hProcess, INFINITE);
    DWORD exitCode;
    GetExitCodeProcess(sei.hProcess, &exitCode);
    CloseHandle(sei.hProcess);
    return (exitCode == 0) ? S_OK : E_FAIL;
}
```

---

### Method 4: Programmatic Registration (.NET/C#)

Register filters from .NET applications using P/Invoke.

```
using System;
using System.Runtime.InteropServices;
using System.ComponentModel;

public class FilterRegistration
{
    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    private static extern IntPtr LoadLibrary(string lpFileName);

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool FreeLibrary(IntPtr hModule);

    [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
    private static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DllRegisterServerDelegate();

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DllUnregisterServerDelegate();

    public static void RegisterFilter(string filterPath)
    {
        IntPtr hModule = LoadLibrary(filterPath);
        if (hModule == IntPtr.Zero)
        {
            throw new Win32Exception(Marshal.GetLastWin32Error(),
                $"Failed to load filter: {filterPath}");
        }

        try
        {
            IntPtr procAddress = GetProcAddress(hModule, "DllRegisterServer");
            if (procAddress == IntPtr.Zero)
            {
                throw new Exception("DllRegisterServer function not found");
            }

            DllRegisterServerDelegate registerServer =
                Marshal.GetDelegateForFunctionPointer<DllRegisterServerDelegate>(procAddress);

            int result = registerServer();

            if (result != 0)
            {
                throw new COMException($"Registration failed with HRESULT: 0x{result:X8}");
            }

            Console.WriteLine($"Filter registered successfully: {filterPath}");
        }
        finally
        {
            FreeLibrary(hModule);
        }
    }

    public static void UnregisterFilter(string filterPath)
    {
        IntPtr hModule = LoadLibrary(filterPath);
        if (hModule == IntPtr.Zero)
        {
            throw new Win32Exception(Marshal.GetLastWin32Error());
        }

        try
        {
            IntPtr procAddress = GetProcAddress(hModule, "DllUnregisterServer");
            if (procAddress == IntPtr.Zero)
            {
                throw new Exception("DllUnregisterServer function not found");
            }

            DllUnregisterServerDelegate unregisterServer =
                Marshal.GetDelegateForFunctionPointer<DllUnregisterServerDelegate>(procAddress);

            int result = unregisterServer();

            if (result != 0)
            {
                throw new COMException($"Unregistration failed with HRESULT: 0x{result:X8}");
            }

            Console.WriteLine($"Filter unregistered successfully: {filterPath}");
        }
        finally
        {
            FreeLibrary(hModule);
        }
    }

    // Alternative: Use Process.Start with regsvr32
    public static void RegisterFilterWithRegsvr32(string filterPath)
    {
        var startInfo = new System.Diagnostics.ProcessStartInfo
        {
            FileName = "regsvr32.exe",
            Arguments = $"/s \"{filterPath}\"",  // /s = silent
            Verb = "runas",  // Run as administrator
            UseShellExecute = true,
            CreateNoWindow = true
        };

        using (var process = System.Diagnostics.Process.Start(startInfo))
        {
            process.WaitForExit();

            if (process.ExitCode != 0)
            {
                throw new Exception($"regsvr32 failed with exit code: {process.ExitCode}");
            }
        }
    }
}

// Usage example
class Program
{
    static void Main(string[] args)
    {
        string filterPath = @"C:\Program Files\VisioForge\FFMPEG Source\VisioForge_FFMPEG_Source_x64.ax";

        try
        {
            FilterRegistration.RegisterFilter(filterPath);
            Console.WriteLine("Filter registered successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}
```

---

## Registration Verification

### Method 1: Using GraphEdit/GraphStudioNext

1. Launch GraphEdit (Windows SDK) or GraphStudioNext
2. Click "Graph" → "Insert Filters"
3. Search for filter name (e.g., "FFMPEG Source", "VLC Source")
4. If filter appears in list, registration succeeded

### Method 2: Using Registry Editor

```
# Open Registry Editor
regedit
# Navigate to:
HKEY_CLASSES_ROOT\CLSID\{GUID}
# Example for FFMPEG Source:
# HKEY_CLASSES_ROOT\CLSID\{1974D893-83E4-4F89-9908-795C524CC17E}
```

### Method 3: Programmatic Verification (C++)

```
#include <dshow.h>
bool IsFilterRegistered(const CLSID& filterClsid)
{
    IBaseFilter* pFilter = nullptr;
    HRESULT hr = CoCreateInstance(filterClsid, NULL, CLSCTX_INPROC_SERVER,
        IID_IBaseFilter, (void**)&pFilter);
    if (SUCCEEDED(hr) && pFilter)
    {
        pFilter->Release();
        return true;
    }
    return false;
}
// Usage
int main()
{
    CoInitialize(NULL);
    // FFMPEG Source Filter CLSID
    CLSID ffmpegSourceClsid =
        { 0x1974D893, 0x83E4, 0x4F89, { 0x99, 0x08, 0x79, 0x5C, 0x52, 0x4C, 0xC1, 0x7E } };
    if (IsFilterRegistered(ffmpegSourceClsid))
    {
        std::cout << "FFMPEG Source filter is registered" << std::endl;
    }
    else
    {
        std::cout << "FFMPEG Source filter is NOT registered" << std::endl;
    }
    CoUninitialize();
    return 0;
}
```

### Method 4: Programmatic Verification (.NET/C#)

## ``` using System; using System.Runtime.InteropServices; public static bool IsFilterRegistered(Guid clsid) { try { Type comType = Type.GetTypeFromCLSID(clsid, throwOnError: false); if (comType == null) return false; object instance = Activator.CreateInstance(comType); if (instance != null) { Marshal.ReleaseComObject(instance); return true; } } catch { return false; } return false; } // Usage Guid ffmpegSourceClsid = new Guid("1974D893-83E4-4F89-9908-795C524CC17E"); if (IsFilterRegistered(ffmpegSourceClsid)) { Console.WriteLine("FFMPEG Source filter is registered"); } ```

## Troubleshooting

### Issue: "DllRegisterServer failed" or "Error 0x80004005"

**Causes**: - Not running as Administrator - Missing dependencies (DLLs) - Wrong architecture (x86 vs x64)

**Solutions**:

1. **Run as Administrator**:

   ```
   # Right-click Command Prompt → Run as Administrator
   regsvr32 "C:\Path\To\Filter.ax"
   ```
2. **Check Dependencies**: Use Dependency Walker or Dependencies.exe to check for missing DLLs:

   ```
   # Download Dependencies from: https://github.com/lucasg/Dependencies
   Dependencies.exe "C:\Path\To\Filter.ax"
   ```
3. **Verify Architecture**:

   ```
   # For 32-bit application, register 32-bit filter
   regsvr32 "C:\Path\To\Filter.ax"

   # For 64-bit application, register 64-bit filter
   regsvr32 "C:\Path\To\Filter_x64.ax"
   ```

### Issue: "The module was loaded but the entry-point was not found"

**Cause**: File is not a valid DirectShow filter or is corrupted.

**Solutions**: - Verify file integrity - Re-download or reinstall SDK - Check if file is a DirectShow filter (.ax extension)

### Issue: Filter registered but not found in applications

**Causes**: - 32-bit/64-bit mismatch - Filter registered in wrong HKEY (per-user vs system-wide)

**Solutions**:

1. **Match Application Architecture**:
2. 32-bit app needs 32-bit filter
3. 64-bit app needs 64-bit filter
4. **System-Wide Registration**:

   ```
   # Run Command Prompt as Administrator
   # This registers system-wide (HKEY_LOCAL_MACHINE)
   regsvr32 "C:\Path\To\Filter.ax"
   ```
5. **Check Both Registries**:
6. `HKEY_LOCAL_MACHINE\SOFTWARE\Classes\CLSID`
7. `HKEY_CURRENT_USER\SOFTWARE\Classes\CLSID`

### Issue: Access Denied

**Cause**: Insufficient permissions.

**Solution**:

```
# Always run as Administrator for filter registration
# Right-click Command Prompt → Run as Administrator
```

### Issue: Registration succeeds but filter doesn't work

**Causes**: - Missing license key - Missing runtime dependencies - Incorrect installation path

**Solutions**:

1. **Verify License**:
2. Check if trial license is expired
3. Ensure license key is properly activated
4. **Check Runtime Dependencies**:
5. FFMPEG Source: Requires FFmpeg DLLs (avcodec, avformat, etc.)
6. VLC Source: Requires VLC libraries (libvlc.dll, libvlccore.dll, plugins/)
7. NVENC: Requires NVIDIA GPU and drivers
8. Processing/Encoding: May require Visual C++ Redistributables
9. **Verify File Locations**: All dependent DLLs must be in same directory as .ax file or in system PATH.

---

## Registration-Free COM (Advanced)

For xcopy deployment without registration, use registration-free COM with manifest files.

### Creating Manifest File

**filter.manifest** (place next to .ax file):

```
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
  <assemblyIdentity
    type="win32"
    name="VisioForge.FFMPEGSource"
    version="1.0.0.0"/>
  <file name="VisioForge_FFMPEG_Source_x64.ax">
    <comClass
      clsid="{1974D893-83E4-4F89-9908-795C524CC17E}"
      threadingModel="Both"/>
  </file>
</assembly>
```

**application.exe.manifest** (place next to your .exe):

```
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
  <assemblyIdentity
    type="win32"
    name="YourApplication"
    version="1.0.0.0"/>
  <dependency>
    <dependentAssembly>
      <assemblyIdentity
        type="win32"
        name="VisioForge.FFMPEGSource"
        version="1.0.0.0"/>
    </dependentAssembly>
  </dependency>
</assembly>
```

**Limitations**: - More complex to set up - Requires manifest files - May not work with all DirectShow filters - System-registered filters take precedence

---

## Batch Registration Scripts

### Register All Filters (Batch Script)

```
@echo off
echo Registering VisioForge DirectShow Filters...
echo.

REM Check for Administrator privileges
net session >nul 2>&1
if %errorLevel% neq 0 (
    echo ERROR: This script must be run as Administrator!
    pause
    exit /b 1
)

REM Set installation path
set INSTALL_PATH=C:\Program Files\VisioForge

REM Register FFMPEG Source
echo Registering FFMPEG Source...
regsvr32 /s "%INSTALL_PATH%\FFMPEG Source\VisioForge_FFMPEG_Source_x64.ax"
if %errorLevel% equ 0 (
    echo   [OK] FFMPEG Source registered
) else (
    echo   [FAILED] FFMPEG Source registration failed
)

REM Register VLC Source
echo Registering VLC Source...
regsvr32 /s "%INSTALL_PATH%\VLC Source\VisioForge_VLC_Source.ax"
if %errorLevel% equ 0 (
    echo   [OK] VLC Source registered
) else (
    echo   [FAILED] VLC Source registration failed
)

REM Register Processing Filters
echo Registering Processing Filters...
regsvr32 /s "%INSTALL_PATH%\Processing Filters\VisioForge_Video_Effects_Pro_x64.ax"
regsvr32 /s "%INSTALL_PATH%\Processing Filters\VisioForge_Video_Mixer_x64.ax"
regsvr32 /s "%INSTALL_PATH%\Processing Filters\VisioForge_Audio_Enhancer_x64.ax"
echo   [OK] Processing Filters registered

REM Register Encoding Filters
echo Registering Encoding Filters...
regsvr32 /s "%INSTALL_PATH%\Encoding Filters\VisioForge_NVENC_x64.ax"
regsvr32 /s "%INSTALL_PATH%\Encoding Filters\VisioForge_H264_Encoder_x64.ax"
regsvr32 /s "%INSTALL_PATH%\Encoding Filters\VisioForge_AAC_Encoder_x64.ax"
regsvr32 /s "%INSTALL_PATH%\Encoding Filters\VisioForge_MP4_Muxer_x64.ax"
echo   [OK] Encoding Filters registered

echo.
echo Registration complete!
pause
```

### Unregister All Filters

```
@echo off
echo Unregistering VisioForge DirectShow Filters...
echo.

REM Check for Administrator privileges
net session >nul 2>&1
if %errorLevel% neq 0 (
    echo ERROR: This script must be run as Administrator!
    pause
    exit /b 1
)

set INSTALL_PATH=C:\Program Files\VisioForge

REM Unregister all filters
regsvr32 /s /u "%INSTALL_PATH%\FFMPEG Source\VisioForge_FFMPEG_Source_x64.ax"
regsvr32 /s /u "%INSTALL_PATH%\VLC Source\VisioForge_VLC_Source.ax"
regsvr32 /s /u "%INSTALL_PATH%\Processing Filters\VisioForge_Video_Effects_Pro_x64.ax"
regsvr32 /s /u "%INSTALL_PATH%\Processing Filters\VisioForge_Video_Mixer_x64.ax"
regsvr32 /s /u "%INSTALL_PATH%\Encoding Filters\VisioForge_NVENC_x64.ax"

echo Unregistration complete!
pause
```

---

## See Also

- [Redistributable Files](../redistributable-files/) - Complete file list for each SDK
- [Installer Integration](../installer-integration/) - Creating custom installers
- [Deployment Overview](../) - Main deployment guide

---END OF PAGE---


## Deploy and Register DirectShow COM Filters on Windows
**URL:** https://www.visioforge.com/help/docs/directshow/deployment/
**Description:** Deploy DirectShow filters with COM registration, WiX/NSIS/Inno Setup installer integration, redistributable files list, and troubleshooting tips.
**Tags:** DirectShow, C++, Windows, Streaming

# DirectShow SDKs - Deployment Guide

## Overview

This comprehensive deployment guide covers everything you need to know about deploying VisioForge DirectShow SDKs in production environments. From filter registration to creating professional installers, this guide ensures your applications deploy smoothly.

---

## What's Covered

### Core Deployment Topics

#### [Filter Registration](filter-registration/)

Learn how to register DirectShow filters using multiple methods.

**Topics**:

- Manual registration with regsvr32
- Programmatic registration (C++, C#)
- Batch scripts for automation
- Verification techniques
- Troubleshooting registration issues
- Registration-free COM

**When to Read**: Essential for all deployment scenarios

---

#### [Redistributable Files](redistributable-files/)

Complete reference of files to include in your deployment.

**Topics**:

- FFMPEG Source Filter files (~80-100MB)
- VLC Source Filter files (~150-200MB)
- Processing Filters Pack files (~20-180MB)
- Encoding Filters Pack files (~40-300MB)
- Virtual Camera SDK files (~15-35MB)
- Dependencies and directory structures

**When to Read**: Before creating installers or deployment packages

---

#### [Installer Integration](installer-integration/)

Create professional installers with WiX, NSIS, InstallShield, and Inno Setup.

**Topics**:

- WiX Toolset (MSI)
- NSIS scripts
- InstallShield projects
- Inno Setup scripts
- Custom actions for registration
- Silent installation
- Prerequisite bundling

**When to Read**: When creating automated installation packages

---

## Quick Start

### Deployment Workflow

Follow this recommended workflow for deploying DirectShow filters:

```
graph TD
    A[Identify Required SDKs] --> B[Collect Redistributable Files]
    B --> C[Choose Deployment Method]
    C --> D{Installation Method?}
    D -->|Manual| E[Create Batch Scripts]
    D -->|Installer| F[Create Installer Package]
    E --> G[Register Filters]
    F --> G
    G --> H[Test Deployment]
    H --> I{Works?}
    I -->|No| J[Troubleshoot]
    I -->|Yes| K[Deploy to Production]
    J --> H
```

### Step-by-Step Quick Start

#### Step 1: Identify Your SDKs

Determine which SDKs your application uses:

| SDK | Purpose | Key File |
| --- | --- | --- |
| **FFMPEG Source** | Media playback, streaming | VisioForge\_FFMPEG\_Source\_x64.ax |
| **VLC Source** | Multi-track playback | VisioForge\_VLC\_Source.ax |
| **Processing Filters** | Effects, mixing | VisioForge\_Video\_Effects\_Pro\_x64.ax |
| **Encoding Filters** | Video encoding | VisioForge\_NVENC\_x64.ax |
| **Virtual Camera** | Virtual devices | VisioForge\_Virtual\_Camera\_x64.ax |

[View Complete File Lists →](redistributable-files/)

---

#### Step 2: Collect Files

Create deployment folder structure:

```
YourApp\
├── YourApp.exe
├── YourApp.exe.config
└── Filters\
    ├── VisioForge_FFMPEG_Source_x64.ax
    ├── avcodec-58.dll
    ├── avformat-58.dll
    └── ... (other dependencies)
```

[View Directory Structures →](redistributable-files/#installation-directory-structure)

---

#### Step 3: Choose Deployment Method

| Method | Best For | Complexity |
| --- | --- | --- |
| **Batch Script** | Internal deployment, testing | Low |
| **WiX (MSI)** | Enterprise, IT automation | Medium-High |
| **NSIS** | Small installers, custom UI | Medium |
| **InstallShield** | Commercial apps, advanced features | Medium |
| **Inno Setup** | Simple installers, open-source | Low-Medium |

[View Installer Comparisons →](#choosing-an-installer-technology)

---

#### Step 4: Register Filters

**Option A: Manual Registration (Development/Testing)**

```
@echo off
cd /d "%~dp0Filters"
regsvr32 /s VisioForge_FFMPEG_Source_x64.ax
if %ERRORLEVEL% EQU 0 (
    echo Registration successful
) else (
    echo Registration failed
)
```

**Option B: Installer Custom Action (Production)**

See [Installer Integration Guide](installer-integration/) for WiX, NSIS, and other examples.

[View All Registration Methods →](filter-registration/)

---

#### Step 5: Test Deployment

**Verification Checklist**:

- [ ] Install on clean test machine
- [ ] Verify all files copied correctly
- [ ] Check filter registration in registry
- [ ] Test filter with GraphEdit/GraphStudioNext
- [ ] Run application end-to-end test
- [ ] Verify uninstall removes all components
- [ ] Test on Windows 10 and Windows 11
- [ ] Test both x64 and x86 (if applicable)

[View Testing Procedures →](#testing-deployments)

---

## Choosing an Installer Technology

### WiX Toolset

**Pros**:

- Industry-standard MSI format
- Excellent for enterprise deployment
- Group Policy support
- Strong Windows Installer integration
- Active community and documentation

**Cons**:

- XML-based syntax has learning curve
- Requires compilation step
- Less flexible UI than custom installers

**Recommended For**:

- Enterprise applications
- IT-managed deployments
- Applications requiring Group Policy deployment
- Organizations with existing MSI infrastructure

[View WiX Examples →](installer-integration/#wix-toolset-examples)

---

### NSIS

**Pros**:

- Very small installer size
- Fast execution
- Highly customizable UI
- Simple scripting language
- No external dependencies

**Cons**:

- Not MSI-based (may not suit all enterprises)
- Less Windows Installer integration
- Manual upgrade management

**Recommended For**:

- Consumer applications
- Small to medium installers
- Applications requiring custom UI
- Portable application creation

[View NSIS Examples →](installer-integration/#nsis-examples)

---

### InstallShield

**Pros**:

- Professional GUI designer
- Comprehensive feature set
- Visual Studio integration
- Advanced prerequisite handling
- Suite/bundle creation

**Cons**:

- Commercial license required (except Limited Edition)
- Can be complex for simple installers
- Larger learning curve

**Recommended For**:

- Commercial software products
- Complex installation requirements
- Professional installer appearance
- Organizations with InstallShield expertise

[View InstallShield Guide →](installer-integration/#installshield-integration)

---

### Inno Setup

**Pros**:

- Free and open-source
- Easy to learn Pascal scripting
- Good documentation
- Unicode support
- Active development

**Cons**:

- Not MSI-based
- Fewer advanced features than commercial tools
- Limited enterprise features

**Recommended For**:

- Open-source projects
- Simple installers
- Small applications
- Budget-conscious deployments

[View Inno Setup Examples →](installer-integration/#inno-setup-examples)

---

## Common Deployment Scenarios

### Scenario 1: Media Player Application

**Requirements**:

- FFMPEG Source Filter
- Processing Filters (video effects)
- User-friendly installer

**Recommended Approach**:

1. Use **NSIS** or **Inno Setup** for consumer-friendly installer
2. Include Visual C++ Redistributable check
3. Register filters during installation
4. Create desktop shortcut
5. Associate media file types (optional)

**Files to Deploy** (~100-150MB):

- VisioForge\_FFMPEG\_Source\_x64.ax + FFmpeg DLLs
- VisioForge\_Video\_Effects\_Pro\_x64.ax + dependencies

[View Complete File List →](redistributable-files/#ffmpeg-source-filter)

---

### Scenario 2: Enterprise Video Processing

**Requirements**:

- FFMPEG Source + Encoding Filters
- Silent installation support
- MSI-based deployment
- Group Policy deployment

**Recommended Approach**:

1. Use **WiX Toolset** for MSI creation
2. Bundle Visual C++ Redistributable
3. Support silent installation parameters
4. Implement proper logging
5. Create deployment documentation

**Example**:

```
msiexec /i EnterpriseVideoApp.msi /quiet /norestart /l*v install.log
```

[View WiX Bundle Examples →](installer-integration/#advanced-wix-self-extracting-bundle)

---

### Scenario 3: Virtual Camera Solution

**Requirements**:

- Virtual Camera SDK
- Driver installation
- System-level access

**Recommended Approach**:

1. Use **WiX** or **InstallShield** for driver support
2. Require administrator privileges
3. Install virtual camera drivers
4. Register DirectShow filters
5. Provide clear installation instructions

**Special Considerations**:

- Drivers require digital signatures
- May need system restart
- Enhanced security warnings

[View Virtual Camera Files →](redistributable-files/#virtual-camera-sdk)

---

### Scenario 4: Development SDK Redistribution

**Requirements**:

- Include filters with your SDK
- Support both x86 and x64
- Flexible integration

**Recommended Approach**:

1. Provide separate x86/x64 packages
2. Include registration batch scripts
3. Provide documentation for developers
4. Consider NuGet package distribution
5. Include header files and type libraries

**Package Structure**:

```
YourSDK\
├── bin\
│   ├── x86\
│   │   └── Filters\
│   └── x64\
│       └── Filters\
├── docs\
├── samples\
└── tools\
    └── register_filters.bat
```

---

## Prerequisites and Dependencies

### Visual C++ Redistributable

**Required Version**: Visual C++ 2015-2022 Redistributable

**Download Links**:

- x64: <https://aka.ms/vs/17/release/vc_redist.x64.exe>
- x86: <https://aka.ms/vs/17/release/vc_redist.x86.exe>

**Detection Registry Keys**:

```
x64: HKLM\SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\x64
x86: HKLM\SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\x86
Value: "Installed" = 1 (DWORD)
```

**Installer Integration**:

See [Bundling Dependencies](installer-integration/#bundling-dependencies) for WiX, NSIS, and other examples.

---

### .NET Requirements

If your application uses .NET:

- **.NET Framework 4.8** - For .NET Framework applications
- **.NET 8.0 Runtime** - For modern .NET applications

**Detection**:

- .NET Framework: Check registry `HKLM\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full`
- .NET 8.0: Check for `dotnet --list-runtimes`

---

### Hardware Requirements (Optional)

For hardware acceleration features:

| Feature | Requirement |
| --- | --- |
| **NVENC Encoding** | NVIDIA GPU (GTX 600+) |
| **QuickSync** | Intel CPU with integrated graphics |
| **DXVA Decoding** | DirectX 11 compatible GPU |

Document hardware requirements in your installer or documentation.

---

## Testing Deployments

### Test Environment Setup

Create isolated test environments:

1. **Clean Windows 10 VM** - Test on fresh installation
2. **Clean Windows 11 VM** - Test latest OS
3. **Minimal Installation** - No Visual Studio or dev tools
4. **Different User Accounts** - Test standard user vs. admin

### Testing Checklist

#### Installation Testing

- [ ] Installer runs without errors
- [ ] All files copied to correct locations
- [ ] Filters registered successfully
- [ ] Start menu shortcuts created
- [ ] Registry entries created
- [ ] Prerequisites detected/installed
- [ ] User can launch application
- [ ] Application functions correctly

#### Uninstallation Testing

- [ ] Uninstaller runs without errors
- [ ] All files removed
- [ ] Filters unregistered
- [ ] Registry entries cleaned
- [ ] Start menu shortcuts removed
- [ ] No orphaned files remain

#### Upgrade Testing

- [ ] Upgrade from previous version works
- [ ] User data preserved
- [ ] Settings maintained
- [ ] Old filters replaced with new versions

#### Silent Installation Testing

```
REM Install silently
MyAppSetup.exe /S

REM Verify installation
reg query "HKLM\SOFTWARE\MyApp" /v InstallDir

REM Uninstall silently
"%ProgramFiles%\MyApp\Uninstall.exe" /S
```

### Automated Testing Script

```
# PowerShell deployment test script
param(
    [string]$InstallerPath,
    [string]$FilterCLSID
)

Write-Host "Testing installation..." -ForegroundColor Cyan

# Install
Start-Process $InstallerPath -ArgumentList "/S" -Wait

# Verify filter registration
$regPath = "HKLM:\SOFTWARE\Classes\CLSID\$FilterCLSID"
if (Test-Path $regPath) {
    Write-Host "✓ Filter registered" -ForegroundColor Green
} else {
    Write-Host "✗ Filter NOT registered" -ForegroundColor Red
    Exit 1
}

# Test with GraphEdit
$graphEdit = "C:\Program Files (x86)\Windows Kits\10\bin\*\x64\graphedt.exe"
if (Test-Path $graphEdit) {
    Write-Host "✓ Testing with GraphEdit..." -ForegroundColor Cyan
    # Add GraphEdit automation here
}

# Uninstall
$uninstaller = Get-ChildItem "C:\Program Files\MyApp\Uninstall.exe" -ErrorAction SilentlyContinue
if ($uninstaller) {
    Start-Process $uninstaller.FullName -ArgumentList "/S" -Wait
    Write-Host "✓ Uninstall completed" -ForegroundColor Green
}

# Verify cleanup
if (Test-Path $regPath) {
    Write-Host "✗ Filter still registered after uninstall" -ForegroundColor Red
    Exit 1
} else {
    Write-Host "✓ Filter unregistered successfully" -ForegroundColor Green
}

Write-Host "All tests passed!" -ForegroundColor Green
```

---

## Architecture Considerations

### x86 vs x64 Deployment

**x64 Applications**:

- Use x64 filters only
- Install to `C:\Program Files\YourApp`
- Register in 64-bit registry view

**x86 Applications**:

- Use x86 filters only
- Install to `C:\Program Files (x86)\YourApp`
- Register in 32-bit registry view (regsvr32 handles automatically)

**Mixed Applications**:

- Include both x86 and x64 filters
- Separate subdirectories: `Filters\x86` and `Filters\x64`
- Conditional registration based on process architecture

### Registry Considerations

**64-bit Windows Registry Views**:

```
HKLM\SOFTWARE\Classes\CLSID\{GUID}           ← 64-bit view
HKLM\SOFTWARE\Wow6432Node\Classes\CLSID\{GUID} ← 32-bit view
```

**Important**: regsvr32 automatically uses correct registry view:

- `C:\Windows\System32\regsvr32.exe` → 64-bit registry
- `C:\Windows\SysWOW64\regsvr32.exe` → 32-bit registry

---

## Security Considerations

### Code Signing

**Recommended**: Sign all executables and installers with Authenticode certificate.

```
REM Sign installer with certificate
signtool sign /f MyCert.pfx /p password /t https://timestamp.digicert.com MyAppSetup.exe
```

**Benefits**:

- Removes SmartScreen warnings
- Establishes trust with users
- Required for kernel-mode drivers (Virtual Camera)

### Permission Requirements

**Filter Registration Requires**:

- Administrator privileges
- Write access to HKLM registry
- Write access to System32 (if registering there)

**Best Practices**:

- Always request elevation in installer manifest
- Check privileges before registration
- Provide clear error messages for permission issues

```
<!-- Installer manifest requiring elevation -->
<requestedExecutionLevel level="requireAdministrator" />
```

---

## Troubleshooting Common Issues

### Issue: Filter Registration Fails

**Symptoms**: regsvr32 returns error, filter not in registry

**Possible Causes**:

1. Missing dependencies (Visual C++ Runtime, DLLs)
2. Insufficient privileges
3. Corrupted filter file
4. Architecture mismatch

**Solutions**:

1. Use Dependency Walker to check dependencies
2. Run installer as administrator
3. Verify file integrity (checksums)
4. Ensure x86 app uses x86 filter, x64 uses x64 filter

[View Complete Troubleshooting →](filter-registration/#troubleshooting)

---

### Issue: Application Can't Find Filter

**Symptoms**: Application fails to create filter graph, CLSID not found

**Possible Causes**:

1. Filter not registered
2. Wrong CLSID used
3. 32-bit app looking for 64-bit filter

**Solutions**:

```
// Verify filter registration programmatically
HRESULT hr = CoCreateInstance(CLSID_FFMPEGSource, NULL, CLSCTX_INPROC_SERVER,
                               IID_IBaseFilter, (void**)&pFilter);
if (hr == REGDB_E_CLASSNOTREG) {
    // Filter not registered - prompt user
}
```

---

### Issue: Silent Installation Hangs

**Symptoms**: Installer stops responding during silent install

**Possible Causes**:

1. Waiting for user input
2. Reboot required
3. Prerequisite installation prompting

**Solutions**:

```
# Add /norestart parameter
msiexec /i MyApp.msi /quiet /norestart

# NSIS: Check silent mode in script
${IfSilent}
  # Skip UI interactions
${EndIf}
```

---

### Issue: Uninstall Leaves Files

**Symptoms**: Application directory still exists after uninstall

**Possible Causes**:

1. Files created after installation not tracked
2. Open file handles preventing deletion
3. Uninstall custom action not running

**Solutions**:

- Use Windows Installer RemoveFile table for dynamic files
- Implement file cleanup in uninstall custom action
- Ensure application not running during uninstall

---

## Best Practices Summary

### DO

✅ **Always** require administrator privileges for installation ✅ **Always** bundle or check for Visual C++ Redistributable ✅ **Always** test on clean machines before release ✅ **Always** implement proper uninstall ✅ **Always** log installation steps for troubleshooting ✅ **Always** verify filter registration after install ✅ **Do** support silent installation for enterprise deployments ✅ **Do** sign installers with Authenticode certificate ✅ **Do** provide clear error messages ✅ **Do** document system requirements

### DON'T

❌ **Never** register filters to System32 directory ❌ **Never** overwrite newer files with older versions ❌ **Never** fail installation if registration fails (warn instead) ❌ **Never** leave registry entries after uninstall ❌ **Never** require user to manually register filters ❌ **Don't** skip prerequisite checks ❌ **Don't** use hardcoded paths ❌ **Don't** forget to test upgrade scenarios ❌ **Don't** ignore HRESULT return values ❌ **Don't** deploy debug builds to production

---

## Deployment Checklist

Use this checklist before releasing your installer:

### Pre-Release

- [ ] All redistributable files identified
- [ ] Correct architecture (x86/x64) selected
- [ ] Dependencies documented
- [ ] Installer created and tested
- [ ] Silent installation tested
- [ ] Uninstall tested completely
- [ ] Code signing completed
- [ ] Installation guide written
- [ ] System requirements documented

### Testing

- [ ] Tested on Windows 10 (21H2 or later)
- [ ] Tested on Windows 11
- [ ] Tested on clean VM without dev tools
- [ ] Tested with standard user account
- [ ] Tested upgrade from previous version
- [ ] Tested uninstall cleanup
- [ ] Tested silent installation
- [ ] Verified filter registration
- [ ] Tested application functionality

### Documentation

- [ ] Installation instructions written
- [ ] Uninstallation instructions provided
- [ ] Troubleshooting section included
- [ ] System requirements listed
- [ ] Support contact information provided

---

## Additional Resources

### Documentation

- [Filter Registration Guide](filter-registration/) - Complete registration reference
- [Redistributable Files](redistributable-files/) - All SDK files listed
- [Installer Integration](installer-integration/) - WiX, NSIS, InstallShield examples

### External Resources

- [DirectShow Registration (Microsoft)](https://learn.microsoft.com/en-us/windows/win32/directshow/how-to-register-directshow-filters)
- [Windows Installer Best Practices](https://learn.microsoft.com/en-us/windows/win32/msi/windows-installer-best-practices)
- [WiX Toolset](https://www.firegiant.com/wixtoolset/)
- [NSIS](https://nsis.sourceforge.io/Main_Page)
- [Inno Setup](https://jrsoftware.org/isinfo.php)

### Tools

- **GraphEdit** - Filter testing (Windows SDK)
- **GraphStudioNext** - Advanced filter testing
- **Dependency Walker** - DLL dependency analysis
- **Process Monitor** - Installation troubleshooting
- **Registry Editor** - Registration verification

---

## Support

For deployment assistance:

1. Check [Troubleshooting](#troubleshooting-common-issues) section
2. Review [Filter Registration](filter-registration/#troubleshooting)
3. Contact VisioForge support: [support@visioforge.com](mailto:support@visioforge.com)
4. Visit: <https://www.visioforge.com/>

---END OF PAGE---


## Deploy DirectShow Filters with WiX, NSIS, and Inno Setup
**URL:** https://www.visioforge.com/help/docs/directshow/deployment/installer-integration/
**Description:** Step-by-step installer integration for VisioForge DirectShow filters. WiX, NSIS, Inno Setup, and InstallShield examples with COM registration custom actions.
**Tags:** DirectShow, C++, Windows

# Installer Integration Guide

## Overview

This guide provides comprehensive instructions for integrating VisioForge DirectShow filters into Windows installers. It covers multiple installer technologies, custom actions for filter registration, dependency management, and best practices.

---

## Prerequisites

Before creating an installer, ensure you understand: - [Redistributable Files](../redistributable-files/) - Files to include in installer - [Filter Registration](../filter-registration/) - Registration mechanisms - Target platform architecture (x86/x64) - Visual C++ Redistributable requirements

---

## Installer Technologies Overview

### WiX Toolset

**Best For**: Enterprise applications, MSI-based deployments, IT automation

**Advantages**:

- XML-based declarative syntax
- Native MSI support
- Excellent Windows Installer integration
- Group Policy deployment support
- Active development and community

**Requirements**:

- WiX Toolset 3.x or 4.x
- Visual Studio integration (optional)
- .wixproj project files

[View WiX Examples →](#wix-toolset-examples)

---

### NSIS (Nullsoft Scriptable Install System)

**Best For**: Lightweight installers, custom UI, portable applications **Advantages**: - Small installer size - Highly customizable - Simple scripting language - No runtime dependencies - Fast execution **Requirements**: - NSIS 3.x compiler - .nsi script files [View NSIS Examples →](#nsis-examples)

---

### InstallShield

**Best For**: Commercial applications, complex installations, advanced features

**Advantages**:

- Professional GUI designer
- Built-in prerequisites detection
- Multi-platform support
- Suite/bundle creation
- Visual Studio integration

**Requirements**:

- InstallShield Limited Edition (Visual Studio) or Professional
- .ism project files

[View InstallShield Guide →](#installshield-integration)

---

### Inno Setup

**Best For**: Simple installers, small applications, freeware **Advantages**: - Free and open-source - Pascal scripting support - Unicode support - Good documentation - Active community **Requirements**: - Inno Setup 6.x compiler - .iss script files [View Inno Setup Examples →](#inno-setup-examples)

---

## WiX Toolset Examples

### Basic Filter Installation

Create a complete WiX installer for a DirectShow filter with automatic registration.

#### Product.wxs

```
<?xml version="1.0" encoding="UTF-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
  <Product Id="*"
           Name="MyApp with DirectShow Filters"
           Language="1033"
           Version="1.0.0.0"
           Manufacturer="Your Company"
           UpgradeCode="YOUR-GUID-HERE">

    <Package InstallerVersion="200"
             Compressed="yes"
             InstallScope="perMachine"
             Platform="x64" />

    <MajorUpgrade DowngradeErrorMessage="A newer version is already installed." />

    <MediaTemplate EmbedCab="yes" />

    <!-- Installation directory structure -->
    <Directory Id="TARGETDIR" Name="SourceDir">
      <Directory Id="ProgramFiles64Folder">
        <Directory Id="INSTALLFOLDER" Name="MyApp">
          <Directory Id="FilterFolder" Name="Filters" />
        </Directory>
      </Directory>
    </Directory>

    <!-- Feature definition -->
    <Feature Id="ProductFeature" Title="MyApp" Level="1">
      <ComponentGroupRef Id="FilterComponents" />
      <ComponentGroupRef Id="ApplicationComponents" />
    </Feature>

    <!-- Custom actions for registration -->
    <CustomAction Id="RegisterFilters"
                  Directory="FilterFolder"
                  ExeCommand="cmd.exe /c regsvr32 /s VisioForge_FFMPEG_Source_x64.ax"
                  Execute="deferred"
                  Impersonate="no"
                  Return="check" />

    <CustomAction Id="UnregisterFilters"
                  Directory="FilterFolder"
                  ExeCommand="cmd.exe /c regsvr32 /s /u VisioForge_FFMPEG_Source_x64.ax"
                  Execute="deferred"
                  Impersonate="no"
                  Return="ignore" />

    <InstallExecuteSequence>
      <Custom Action="RegisterFilters" After="InstallFiles">NOT Installed</Custom>
      <Custom Action="UnregisterFilters" Before="RemoveFiles">Installed</Custom>
    </InstallExecuteSequence>

  </Product>
</Wix>
```

#### Filters.wxs (Component Definition)

```
<?xml version="1.0" encoding="UTF-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
  <Fragment>
    <ComponentGroup Id="FilterComponents" Directory="FilterFolder">

      <!-- FFMPEG Source Filter -->
      <Component Id="FFMPEGSourceFilter" Guid="YOUR-GUID-1">
        <File Id="FFMPEGSourceAX"
              Source="$(var.SourceDir)\VisioForge_FFMPEG_Source_x64.ax"
              KeyPath="yes" />
      </Component>

      <!-- FFmpeg Dependencies -->
      <Component Id="FFMPEGLibraries" Guid="YOUR-GUID-2">
        <File Id="avcodec58" Source="$(var.SourceDir)\avcodec-58.dll" />
        <File Id="avdevice58" Source="$(var.SourceDir)\avdevice-58.dll" />
        <File Id="avfilter7" Source="$(var.SourceDir)\avfilter-7.dll" />
        <File Id="avformat58" Source="$(var.SourceDir)\avformat-58.dll" />
        <File Id="avutil56" Source="$(var.SourceDir)\avutil-56.dll" />
        <File Id="swresample3" Source="$(var.SourceDir)\swresample-3.dll" />
        <File Id="swscale5" Source="$(var.SourceDir)\swscale-5.dll" />
      </Component>

    </ComponentGroup>
  </Fragment>
</Wix>
```

#### VCRedist.wxs (Prerequisite Check)

```
<?xml version="1.0" encoding="UTF-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
  <Fragment>

    <!-- Detect Visual C++ Redistributable 2015-2022 -->
    <Property Id="VCREDIST2022_X64">
      <RegistrySearch Id="VCRedist2022x64"
                      Root="HKLM"
                      Key="SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\x64"
                      Name="Installed"
                      Type="raw" />
    </Property>

    <Condition Message="This application requires Visual C++ 2015-2022 Redistributable (x64). Please install it from https://aka.ms/vs/17/release/vc_redist.x64.exe">
      <![CDATA[Installed OR VCREDIST2022_X64]]>
    </Condition>

  </Fragment>
</Wix>
```

#### Building WiX Installer

```
# Using WiX 3.x command line
candle.exe Product.wxs Filters.wxs VCRedist.wxs -ext WixUIExtension
light.exe -out MyApp.msi Product.wixobj Filters.wixobj VCRedist.wixobj -ext WixUIExtension

# Using WiX 4.x (newer syntax)
wix build Product.wxs Filters.wxs VCRedist.wxs -ext WixToolset.UI.wixext -out MyApp.msi
```

---

### Advanced WiX: Self-Extracting Bundle

Create a bundle that includes Visual C++ Redistributable.

#### Bundle.wxs

```
<?xml version="1.0" encoding="UTF-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi"
     xmlns:bal="http://schemas.microsoft.com/wix/BalExtension"
     xmlns:util="http://schemas.microsoft.com/wix/UtilExtension">
  <Bundle Name="MyApp Complete Setup"
          Version="1.0.0.0"
          Manufacturer="Your Company"
          UpgradeCode="YOUR-BUNDLE-GUID">
    <BootstrapperApplicationRef Id="WixStandardBootstrapperApplication.RtfLicense">
      <bal:WixStandardBootstrapperApplication
        LicenseFile="License.rtf"
        LogoFile="Logo.png" />
    </BootstrapperApplicationRef>
    <Chain>
      <!-- Install VC++ Redistributable first -->
      <PackageGroupRef Id="VCRedist2022x64" />
      <!-- Then install main application -->
      <MsiPackage SourceFile="MyApp.msi"
                  DisplayName="MyApp"
                  Vital="yes" />
    </Chain>
  </Bundle>
  <!-- VC++ Redistributable package group -->
  <Fragment>
    <PackageGroup Id="VCRedist2022x64">
      <ExePackage Id="VCRedist2022x64"
                  Cache="no"
                  Compressed="yes"
                  PerMachine="yes"
                  Permanent="yes"
                  Vital="yes"
                  SourceFile="VC_redist.x64.exe"
                  InstallCommand="/install /quiet /norestart"
                  DetectCondition="VCREDIST2022_X64"
                  InstallCondition="NOT VCREDIST2022_X64" />
    </PackageGroup>
  </Fragment>
</Wix>
```

Build bundle:

```
# WiX 3.x
candle.exe Bundle.wxs -ext WixBalExtension
light.exe -out MyAppSetup.exe Bundle.wixobj -ext WixBalExtension
# WiX 4.x
wix build Bundle.wxs -ext WixToolset.Bal.wixext -out MyAppSetup.exe
```

---

### WiX: Custom C++ DLL for Registration

For more control, create a custom action DLL.

#### CustomActions.cpp

```
#include <windows.h>
#include <msiquery.h>
#include <strsafe.h>

#pragma comment(lib, "msi.lib")

// Forward declarations
typedef HRESULT (STDAPICALLTYPE *LPFNDLLREGISTERSERVER)();
typedef HRESULT (STDAPICALLTYPE *LPFNDLLUNREGISTERSERVER)();

// Helper function to write to MSI log
void LogMessage(MSIHANDLE hInstall, LPCTSTR message)
{
    PMSIHANDLE hRecord = MsiCreateRecord(1);
    MsiRecordSetString(hRecord, 0, message);
    MsiProcessMessage(hInstall, INSTALLMESSAGE_INFO, hRecord);
}

// Custom action: Register DirectShow filters
extern "C" __declspec(dllexport) UINT __stdcall RegisterDirectShowFilters(MSIHANDLE hInstall)
{
    TCHAR installDir[MAX_PATH];
    DWORD installDirSize = MAX_PATH;

    // Get INSTALLFOLDER property
    if (MsiGetProperty(hInstall, TEXT("INSTALLFOLDER"), installDir, &installDirSize) != ERROR_SUCCESS)
    {
        LogMessage(hInstall, TEXT("Failed to get INSTALLFOLDER property"));
        return ERROR_INSTALL_FAILURE;
    }

    LogMessage(hInstall, TEXT("Registering DirectShow filters..."));

    // Build path to filter
    TCHAR filterPath[MAX_PATH];
    StringCchCopy(filterPath, MAX_PATH, installDir);
    StringCchCat(filterPath, MAX_PATH, TEXT("Filters\\VisioForge_FFMPEG_Source_x64.ax"));

    // Load filter DLL
    HMODULE hModule = LoadLibrary(filterPath);
    if (!hModule)
    {
        TCHAR errorMsg[512];
        StringCchPrintf(errorMsg, 512, TEXT("Failed to load filter: %s (Error: %d)"),
                       filterPath, GetLastError());
        LogMessage(hInstall, errorMsg);
        return ERROR_INSTALL_FAILURE;
    }

    // Get DllRegisterServer function
    LPFNDLLREGISTERSERVER pfnRegister =
        (LPFNDLLREGISTERSERVER)GetProcAddress(hModule, "DllRegisterServer");

    if (!pfnRegister)
    {
        LogMessage(hInstall, TEXT("DllRegisterServer not found in filter"));
        FreeLibrary(hModule);
        return ERROR_INSTALL_FAILURE;
    }

    // Register filter
    HRESULT hr = pfnRegister();
    FreeLibrary(hModule);

    if (SUCCEEDED(hr))
    {
        LogMessage(hInstall, TEXT("DirectShow filters registered successfully"));
        return ERROR_SUCCESS;
    }
    else
    {
        TCHAR errorMsg[256];
        StringCchPrintf(errorMsg, 256, TEXT("Filter registration failed: HRESULT 0x%08X"), hr);
        LogMessage(hInstall, errorMsg);
        return ERROR_INSTALL_FAILURE;
    }
}

// Custom action: Unregister DirectShow filters
extern "C" __declspec(dllexport) UINT __stdcall UnregisterDirectShowFilters(MSIHANDLE hInstall)
{
    TCHAR installDir[MAX_PATH];
    DWORD installDirSize = MAX_PATH;

    if (MsiGetProperty(hInstall, TEXT("INSTALLFOLDER"), installDir, &installDirSize) != ERROR_SUCCESS)
    {
        // Don't fail uninstall if we can't get the path
        return ERROR_SUCCESS;
    }

    LogMessage(hInstall, TEXT("Unregistering DirectShow filters..."));

    TCHAR filterPath[MAX_PATH];
    StringCchCopy(filterPath, MAX_PATH, installDir);
    StringCchCat(filterPath, MAX_PATH, TEXT("Filters\\VisioForge_FFMPEG_Source_x64.ax"));

    HMODULE hModule = LoadLibrary(filterPath);
    if (!hModule)
    {
        // Filter may already be deleted, don't fail
        return ERROR_SUCCESS;
    }

    LPFNDLLUNREGISTERSERVER pfnUnregister =
        (LPFNDLLUNREGISTERSERVER)GetProcAddress(hModule, "DllUnregisterServer");

    if (pfnUnregister)
    {
        pfnUnregister();
    }

    FreeLibrary(hModule);
    LogMessage(hInstall, TEXT("DirectShow filters unregistered"));

    return ERROR_SUCCESS;
}

// DLL entry point
BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID reserved)
{
    return TRUE;
}
```

#### CustomActions.wxs

```
<?xml version="1.0" encoding="UTF-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
  <Fragment>

    <!-- Binary for custom actions -->
    <Binary Id="CustomActionsDLL" SourceFile="$(var.CustomActions.TargetPath)" />

    <!-- Define custom actions -->
    <CustomAction Id="RegisterFiltersCA"
                  BinaryKey="CustomActionsDLL"
                  DllEntry="RegisterDirectShowFilters"
                  Execute="deferred"
                  Impersonate="no"
                  Return="check" />

    <CustomAction Id="UnregisterFiltersCA"
                  BinaryKey="CustomActionsDLL"
                  DllEntry="UnregisterDirectShowFilters"
                  Execute="deferred"
                  Impersonate="no"
                  Return="ignore" />

    <!-- Schedule custom actions -->
    <InstallExecuteSequence>
      <Custom Action="RegisterFiltersCA" After="InstallFiles">
        NOT Installed
      </Custom>
      <Custom Action="UnregisterFiltersCA" Before="RemoveFiles">
        Installed
      </Custom>
    </InstallExecuteSequence>

  </Fragment>
</Wix>
```

---

## NSIS Examples

### Basic NSIS Installer

Create a complete NSIS installer script.

#### Installer.nsi

```
; MyApp Installer with DirectShow Filters
; NSIS 3.x script
;--------------------------------
; Includes
!include "MUI2.nsh"
!include "x64.nsh"
;--------------------------------
; General
Name "MyApp"
OutFile "MyAppSetup.exe"
Unicode True
; Default installation folder
InstallDir "$PROGRAMFILES64\MyApp"
; Get installation folder from registry if available
InstallDirRegKey HKLM "Software\MyApp" "InstallDir"
; Request application privileges
RequestExecutionLevel admin
;--------------------------------
; Interface Settings
!define MUI_ABORTWARNING
!define MUI_ICON "installer.ico"
!define MUI_UNICON "uninstaller.ico"
;--------------------------------
; Pages
!insertmacro MUI_PAGE_LICENSE "License.txt"
!insertmacro MUI_PAGE_COMPONENTS
!insertmacro MUI_PAGE_DIRECTORY
!insertmacro MUI_PAGE_INSTFILES
!insertmacro MUI_PAGE_FINISH
!insertmacro MUI_UNPAGE_CONFIRM
!insertmacro MUI_UNPAGE_INSTFILES
;--------------------------------
; Languages
!insertmacro MUI_LANGUAGE "English"
;--------------------------------
; Version Information
VIProductVersion "1.0.0.0"
VIAddVersionKey "ProductName" "MyApp"
VIAddVersionKey "CompanyName" "Your Company"
VIAddVersionKey "FileDescription" "MyApp Installer"
VIAddVersionKey "FileVersion" "1.0.0.0"
;--------------------------------
; Installer Sections
Section "MyApp (required)" SecMain
  SectionIn RO
  ; Set output path
  SetOutPath "$INSTDIR"
  ; Install main application files
  File "MyApp.exe"
  File "MyApp.exe.config"
  ; Create Filters subdirectory
  CreateDirectory "$INSTDIR\Filters"
  SetOutPath "$INSTDIR\Filters"
  ; Install FFMPEG Source Filter
  File "Filters\VisioForge_FFMPEG_Source_x64.ax"
  File "Filters\avcodec-58.dll"
  File "Filters\avdevice-58.dll"
  File "Filters\avfilter-7.dll"
  File "Filters\avformat-58.dll"
  File "Filters\avutil-56.dll"
  File "Filters\swresample-3.dll"
  File "Filters\swscale-5.dll"
  ; Register DirectShow filter
  DetailPrint "Registering DirectShow filters..."
  ExecWait 'regsvr32 /s "$INSTDIR\Filters\VisioForge_FFMPEG_Source_x64.ax"' $0
  ${If} $0 != 0
    MessageBox MB_OK|MB_ICONEXCLAMATION "Filter registration failed. Code: $0"
  ${EndIf}
  ; Store installation folder
  WriteRegStr HKLM "Software\MyApp" "InstallDir" $INSTDIR
  ; Create uninstaller
  WriteUninstaller "$INSTDIR\Uninstall.exe"
  ; Create Start Menu shortcuts
  CreateDirectory "$SMPROGRAMS\MyApp"
  CreateShortcut "$SMPROGRAMS\MyApp\MyApp.lnk" "$INSTDIR\MyApp.exe"
  CreateShortcut "$SMPROGRAMS\MyApp\Uninstall.lnk" "$INSTDIR\Uninstall.exe"
  ; Add/Remove Programs entry
  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\MyApp" "DisplayName" "MyApp"
  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\MyApp" "UninstallString" "$INSTDIR\Uninstall.exe"
  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\MyApp" "DisplayIcon" "$INSTDIR\MyApp.exe"
  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\MyApp" "Publisher" "Your Company"
  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\MyApp" "DisplayVersion" "1.0.0.0"
  WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\MyApp" "NoModify" 1
  WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\MyApp" "NoRepair" 1
SectionEnd
;--------------------------------
; Optional Sections
Section "VLC Source Filter" SecVLC
  SetOutPath "$INSTDIR\Filters"
  ; Install VLC Source filter
  File "Filters\VisioForge_VLC_Source.ax"
  File "Filters\libvlc.dll"
  File "Filters\libvlccore.dll"
  ; Install VLC plugins directory
  SetOutPath "$INSTDIR\Filters\plugins"
  File /r "Filters\plugins\*.*"
  ; Register VLC Source filter
  DetailPrint "Registering VLC Source filter..."
  ExecWait 'regsvr32 /s "$INSTDIR\Filters\VisioForge_VLC_Source.ax"'
SectionEnd
;--------------------------------
; Section Descriptions
!insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
  !insertmacro MUI_DESCRIPTION_TEXT ${SecMain} "Main application files and FFMPEG Source filter (required)"
  !insertmacro MUI_DESCRIPTION_TEXT ${SecVLC} "VLC Source filter for additional format support (optional)"
!insertmacro MUI_FUNCTION_DESCRIPTION_END
;--------------------------------
; Installer Functions
Function .onInit
  ; Check if 64-bit Windows
  ${If} ${RunningX64}
    ; OK
  ${Else}
    MessageBox MB_OK|MB_ICONSTOP "This application requires 64-bit Windows."
    Abort
  ${EndIf}
  ; Check for Visual C++ Redistributable 2015-2022
  ReadRegDWORD $0 HKLM "SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\x64" "Installed"
  ${If} $0 != 1
    MessageBox MB_YESNO|MB_ICONQUESTION "Visual C++ 2015-2022 Redistributable (x64) is required.$\n$\nDownload and install now?" IDYES download IDNO skip
    download:
      ExecShell "open" "https://aka.ms/vs/17/release/vc_redist.x64.exe"
      Abort
    skip:
  ${EndIf}
FunctionEnd
;--------------------------------
; Uninstaller Section
Section "Uninstall"
  ; Unregister filters
  DetailPrint "Unregistering DirectShow filters..."
  ExecWait 'regsvr32 /s /u "$INSTDIR\Filters\VisioForge_FFMPEG_Source_x64.ax"'
  ExecWait 'regsvr32 /s /u "$INSTDIR\Filters\VisioForge_VLC_Source.ax"'
  ; Remove files
  Delete "$INSTDIR\MyApp.exe"
  Delete "$INSTDIR\MyApp.exe.config"
  Delete "$INSTDIR\Uninstall.exe"
  ; Remove Filters directory
  Delete "$INSTDIR\Filters\*.ax"
  Delete "$INSTDIR\Filters\*.dll"
  RMDir /r "$INSTDIR\Filters\plugins"
  RMDir "$INSTDIR\Filters"
  ; Remove installation directory
  RMDir "$INSTDIR"
  ; Remove Start Menu shortcuts
  Delete "$SMPROGRAMS\MyApp\MyApp.lnk"
  Delete "$SMPROGRAMS\MyApp\Uninstall.lnk"
  RMDir "$SMPROGRAMS\MyApp"
  ; Remove registry keys
  DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\MyApp"
  DeleteRegKey HKLM "Software\MyApp"
SectionEnd
```

#### Building NSIS Installer

## ``` # Compile with NSIS makensis.exe Installer.nsi # Or use NSIS compiler GUI # File > Load Script > Select Installer.nsi > Test Installer ```

### NSIS: Silent Installation Support

Add silent installation parameters.

```
; Add to .onInit function

; Check for silent mode
${GetParameters} $R0
${GetOptions} $R0 "/S" $0
${IfNot} ${Errors}
  ; Silent mode - skip prerequisite checks
  Goto silent_mode
${EndIf}

; Normal checks here...

silent_mode:
  ; Continue with installation

; For silent uninstall, add to uninstaller:
; Run with: Uninstall.exe /S
```

---

### NSIS: Custom Plugin for Registration

Create a custom NSIS plugin for more control.

#### FilterRegistration.cpp (NSIS Plugin)

```
#include <windows.h>
#include "pluginapi.h"
typedef HRESULT (STDAPICALLTYPE *LPFNDLLREGISTERSERVER)();
// Register filter function
extern "C" void __declspec(dllexport) RegisterFilter(
    HWND hwndParent,
    int string_size,
    TCHAR *variables,
    stack_t **stacktop,
    extra_parameters *extra)
{
    EXDLL_INIT();
    // Pop filter path from stack
    TCHAR filterPath[MAX_PATH];
    popstring(filterPath);
    // Load DLL
    HMODULE hModule = LoadLibrary(filterPath);
    if (!hModule)
    {
        pushstring(_T("ERROR"));
        return;
    }
    // Get registration function
    LPFNDLLREGISTERSERVER pfnRegister =
        (LPFNDLLREGISTERSERVER)GetProcAddress(hModule, "DllRegisterServer");
    if (!pfnRegister)
    {
        FreeLibrary(hModule);
        pushstring(_T("ERROR"));
        return;
    }
    // Register
    HRESULT hr = pfnRegister();
    FreeLibrary(hModule);
    pushstring(SUCCEEDED(hr) ? _T("OK") : _T("ERROR"));
}
BOOL WINAPI DllMain(HANDLE hInst, ULONG ul_reason_for_call, LPVOID lpReserved)
{
    return TRUE;
}
```

Usage in NSIS script:

```
; Load plugin
FilterRegistration::RegisterFilter "$INSTDIR\Filters\VisioForge_FFMPEG_Source_x64.ax"
Pop $0
${If} $0 == "ERROR"
    MessageBox MB_OK "Filter registration failed"
${EndIf}
```

---

## InstallShield Integration

### Basic InstallShield Project Setup

1. **Create New Project**:
2. File > New Project
3. Select "Basic MSI Project"
4. Set project name and location
5. **Add Files**:
6. Application Files view
7. Add filter files to `[INSTALLDIR]\Filters`
8. Add application executables
9. **Add Custom Action**:

#### Method 1: Using regsvr32

1. Go to **Behavior and Logic** > **Custom Actions**
2. Right-click **Install** > **New Custom Action**
3. Set properties:
4. Name: `Register DirectShow Filters`
5. Type: `Stored in the Directory Table`
6. Working Directory: `[INSTALLDIR]Filters`
7. Filename: `regsvr32.exe`
8. Command Line: `/s VisioForge_FFMPEG_Source_x64.ax`
9. Run: `Deferred Execution in System Context`
10. Condition: `NOT Installed`
11. For uninstall:
12. Name: `Unregister DirectShow Filters`
13. Command Line: `/s /u VisioForge_FFMPEG_Source_x64.ax`
14. Sequence: Before **RemoveFiles**
15. Condition: `Installed`

#### Method 2: Using Custom DLL

1. Create C++ DLL with registration code (similar to WiX example above)
2. Add DLL to **Support Files** in InstallShield
3. Create custom action:
4. Type: `DLL from the installation`
5. DLL Name: `CustomActions.dll`
6. Function: `RegisterDirectShowFilters`

### InstallShield: Prerequisite Configuration

1. Go to **Redistributables** view
2. Add **Microsoft Visual C++ 2015-2022 Redistributable (x64)**:
3. Right-click > **Add Prerequisite**
4. Browse to `VC_redist.x64.exe`
5. Set: **Install Before This Application**

---

## Inno Setup Examples

### Basic Inno Setup Script

#### Setup.iss

```
; MyApp Setup Script for Inno Setup 6.x
[Setup]
AppName=MyApp
AppVersion=1.0
DefaultDirName={autopf}\MyApp
DefaultGroupName=MyApp
UninstallDisplayIcon={app}\MyApp.exe
Compression=lzma2
SolidCompression=yes
OutputDir=Output
OutputBaseFilename=MyAppSetup
ArchitecturesInstallIn64BitMode=x64
PrivilegesRequired=admin
MinVersion=10.0
[Files]
; Main application
Source: "MyApp.exe"; DestDir: "{app}"; Flags: ignoreversion
; FFMPEG Source Filter
Source: "Filters\VisioForge_FFMPEG_Source_x64.ax"; DestDir: "{app}\Filters"; Flags: ignoreversion regserver restartreplace uninsrestartdelete
Source: "Filters\avcodec-58.dll"; DestDir: "{app}\Filters"; Flags: ignoreversion
Source: "Filters\avdevice-58.dll"; DestDir: "{app}\Filters"; Flags: ignoreversion
Source: "Filters\avfilter-7.dll"; DestDir: "{app}\Filters"; Flags: ignoreversion
Source: "Filters\avformat-58.dll"; DestDir: "{app}\Filters"; Flags: ignoreversion
Source: "Filters\avutil-56.dll"; DestDir: "{app}\Filters"; Flags: ignoreversion
Source: "Filters\swresample-3.dll"; DestDir: "{app}\Filters"; Flags: ignoreversion
Source: "Filters\swscale-5.dll"; DestDir: "{app}\Filters"; Flags: ignoreversion
[Icons]
Name: "{group}\MyApp"; Filename: "{app}\MyApp.exe"
Name: "{group}\Uninstall MyApp"; Filename: "{uninstallexe}"
[Run]
; Optionally launch application after install
Filename: "{app}\MyApp.exe"; Description: "Launch MyApp"; Flags: nowait postinstall skipifsilent
[Registry]
Root: HKLM; Subkey: "Software\MyApp"; ValueType: string; ValueName: "InstallDir"; ValueData: "{app}"; Flags: uninsdeletekey
[Code]
// Check for Visual C++ Redistributable
function InitializeSetup(): Boolean;
var
  ResultCode: Integer;
  VCInstalled: Cardinal;
begin
  Result := True;
  // Check if VC++ 2015-2022 is installed
  if not RegQueryDWordValue(HKLM, 'SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\x64',
                            'Installed', VCInstalled) or (VCInstalled <> 1) then
  begin
    if MsgBox('Visual C++ 2015-2022 Redistributable (x64) is required.' + #13#10 +
              'Download and install now?', mbConfirmation, MB_YESNO) = IDYES then
    begin
      ShellExec('open', 'https://aka.ms/vs/17/release/vc_redist.x64.exe', '', '', SW_SHOW, ewNoWait, ResultCode);
      Result := False;  // Abort installation
    end;
  end;
end;
```

#### Advanced Inno Setup: Custom Registration

## ``` [Files] ; Don't use regserver flag - we'll register manually Source: "Filters\VisioForge_FFMPEG_Source_x64.ax"; DestDir: "{app}\Filters"; Flags: ignoreversion [Code] // Import Windows API functions function LoadLibrary(lpFileName: String): THandle; external 'LoadLibraryW@kernel32.dll stdcall'; function FreeLibrary(hModule: THandle): Boolean; external 'FreeLibrary@kernel32.dll stdcall'; function GetProcAddress(hModule: THandle; lpProcName: AnsiString): Longword; external 'GetProcAddress@kernel32.dll stdcall'; type TDllRegisterServer = function: HRESULT; // Register DirectShow filter function RegisterDirectShowFilter(FilterPath: String): Boolean; var hModule: THandle; DllRegisterServer: TDllRegisterServer; RegisterFunc: Longword; hr: HRESULT; begin Result := False; hModule := LoadLibrary(FilterPath); if hModule = 0 then begin Log('Failed to load filter: ' + FilterPath); Exit; end; try RegisterFunc := GetProcAddress(hModule, 'DllRegisterServer'); if RegisterFunc = 0 then begin Log('DllRegisterServer not found'); Exit; end; @DllRegisterServer := Pointer(RegisterFunc); hr := DllRegisterServer(); Result := Succeeded(hr); if Result then Log('Filter registered successfully') else Log('Filter registration failed: ' + IntToHex(hr, 8)); finally FreeLibrary(hModule); end; end; // Called after installation procedure CurStepChanged(CurStep: TSetupStep); var FilterPath: String; begin if CurStep = ssPostInstall then begin FilterPath := ExpandConstant('{app}\Filters\VisioForge_FFMPEG_Source_x64.ax'); if not RegisterDirectShowFilter(FilterPath) then begin MsgBox('Warning: DirectShow filter registration failed.' + #13#10 + 'You may need to register it manually.', mbError, MB_OK); end; end; end; // Called before uninstallation procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep); var ResultCode: Integer; FilterPath: String; begin if CurUninstallStep = usUninstall then begin FilterPath := ExpandConstant('{app}\Filters\VisioForge_FFMPEG_Source_x64.ax'); // Unregister using regsvr32 Exec('regsvr32.exe', '/s /u "' + FilterPath + '"', '', SW_HIDE, ewWaitUntilTerminated, ResultCode); end; end; ```

## Silent Installation

### Silent Installation Parameters

#### MSI (WiX, InstallShield MSI)

```
# Silent install
msiexec /i MyApp.msi /quiet /norestart

# Silent install with log
msiexec /i MyApp.msi /quiet /norestart /l*v install.log

# Silent uninstall
msiexec /x MyApp.msi /quiet /norestart

# Silent install with custom install directory
msiexec /i MyApp.msi /quiet INSTALLFOLDER="C:\CustomPath\MyApp"
```

#### NSIS

```
# Silent install
MyAppSetup.exe /S

# Silent install with custom directory
MyAppSetup.exe /S /D=C:\CustomPath\MyApp

# Silent uninstall
Uninstall.exe /S
```

#### Inno Setup

```
# Silent install
MyAppSetup.exe /SILENT

# Very silent (no progress)
MyAppSetup.exe /VERYSILENT

# Silent with custom directory
MyAppSetup.exe /SILENT /DIR="C:\CustomPath\MyApp"

# Silent uninstall
unins000.exe /SILENT
```

---

## Bundling Dependencies

### Visual C++ Redistributable

#### Option 1: Download Bootstrapper

```
<!-- WiX Bundle.wxs -->
<ExePackage Id="VCRedist2022"
            DownloadUrl="https://aka.ms/vs/17/release/vc_redist.x64.exe"
            InstallCommand="/install /quiet /norestart"
            DetectCondition="VCREDIST2022_X64" />
```

#### Option 2: Include Redistributable

```
; NSIS
Section "VC++ Redistributable"
  File "Prerequisites\VC_redist.x64.exe"
  ExecWait '"$INSTDIR\VC_redist.x64.exe" /install /quiet /norestart'
  Delete "$INSTDIR\VC_redist.x64.exe"
SectionEnd
```

#### Option 3: Merge Modules (WiX)

## ``` <DirectoryRef Id="TARGETDIR"> <Merge Id="VCRedist" SourceFile="$(var.VCRedistMergeModule)" DiskId="1" Language="0"/> </DirectoryRef> <Feature Id="VCRedist" Title="Visual C++ Runtime" AllowAdvertise="no" Display="hidden" Level="1"> <MergeRef Id="VCRedist"/> </Feature> ```

## Best Practices

### Registration Timing

1. **Install Sequence**:

```
InstallFiles
↓
Register Filters (Custom Action)
↓
InstallFinalize
```

1. **Uninstall Sequence**:

```
Unregister Filters (Custom Action)
↓
RemoveFiles
↓
UninstallFinalize
```

### Error Handling

**Always**:

- Log registration attempts
- Check HRESULT values
- Provide user feedback on failure
- Don't fail entire installation if registration fails
- Allow manual registration post-install

**Example error handling**:

```
HRESULT hr = RegisterFilter(filterPath);
if (FAILED(hr))
{
    if (hr == REGDB_E_CLASSNOTREG)
        LogError("Class not registered - check dependencies");
    else if (hr == E_ACCESSDENIED)
        LogError("Access denied - requires admin privileges");
    else
        LogError("Registration failed with HRESULT: 0x%08X", hr);
}
```

### Rollback Support

Ensure proper rollback if installation fails:

```
<!-- WiX rollback example -->
<CustomAction Id="RegisterFiltersRollback"
              Directory="FilterFolder"
              ExeCommand="regsvr32 /s /u VisioForge_FFMPEG_Source_x64.ax"
              Execute="rollback"
              Impersonate="no" />

<InstallExecuteSequence>
  <Custom Action="RegisterFiltersRollback" Before="RegisterFiltersCA">
    NOT Installed
  </Custom>
  <Custom Action="RegisterFiltersCA" After="InstallFiles">
    NOT Installed
  </Custom>
</InstallExecuteSequence>
```

### Admin Privileges

**Always require** admin/elevated privileges:

```
<!-- WiX -->
<Package InstallScope="perMachine" InstallPrivileges="elevated" />
```

```
; NSIS
RequestExecutionLevel admin
```

```
{ Inno Setup }
PrivilegesRequired=admin
```

### Architecture Considerations

```
<!-- WiX: Separate packages for x86/x64 -->
<Product Platform="x64">
  <!-- x64 content -->
</Product>

<Product Platform="x86">
  <!-- x86 content -->
</Product>
```

```
; NSIS: Runtime architecture detection
${If} ${RunningX64}
  File "Filters\VisioForge_FFMPEG_Source_x64.ax"
${Else}
  File "Filters\VisioForge_FFMPEG_Source.ax"
${EndIf}
```

---

## Testing Installation

### Manual Testing Checklist

- [ ] Install on clean Windows 10/11
- [ ] Verify all files copied
- [ ] Check filter registration (GraphEdit/GraphStudioNext)
- [ ] Test application functionality
- [ ] Uninstall completely
- [ ] Verify no files remain
- [ ] Check registry cleanup
- [ ] Test upgrade scenario
- [ ] Test repair functionality
- [ ] Test silent installation
- [ ] Test on different user accounts

### Automated Testing

## ``` # PowerShell test script $installerPath = ".\MyAppSetup.msi" $logPath = ".\install_test.log" # Install silently Start-Process msiexec.exe -ArgumentList "/i `"$installerPath`" /quiet /l*v `"$logPath`"" -Wait # Check if filter registered $filterCLSID = "{1974D893-83E4-4F89-9908-795C524CC17E}" $regPath = "HKLM:\SOFTWARE\Classes\CLSID\$filterCLSID" if (Test-Path $regPath) { Write-Host "Filter registered successfully" -ForegroundColor Green } else { Write-Host "Filter registration failed" -ForegroundColor Red Exit 1 } # Uninstall Start-Process msiexec.exe -ArgumentList "/x `"$installerPath`" /quiet" -Wait # Verify cleanup if (Test-Path $regPath) { Write-Host "Filter not unregistered" -ForegroundColor Red Exit 1 } else { Write-Host "Uninstall successful" -ForegroundColor Green } ```

## Troubleshooting

### Common Issues

#### Registration Fails with Access Denied

**Cause**: Insufficient privileges

**Solution**:

```
<!-- Ensure deferred execution with system context -->
<CustomAction Execute="deferred" Impersonate="no" />
```

#### Filter Works in Development but not After Install

**Cause**: Missing dependencies or incorrect paths

**Solution**:

- Use Dependency Walker to check all DLL dependencies
- Ensure all DLLs in same directory as filter
- Check PATH environment variable

#### Silent Install Hangs

**Cause**: User interaction required

**Solution**:

```
# Add /norestart parameter
msiexec /i MyApp.msi /quiet /norestart
```

#### Uninstall Leaves Registry Entries

**Cause**: Unregistration custom action not running

**Solution**:

```
<!-- Set Return="ignore" for unregistration -->
<CustomAction Return="ignore" />
```

---

## See Also

### Documentation

- [Filter Registration](../filter-registration/) - Manual registration methods
- [Redistributable Files](../redistributable-files/) - Files to include in installer
- [Deployment Overview](../) - Complete deployment guide

### External Resources

- [WiX Toolset Documentation](https://docs.firegiant.com/wix/)
- [NSIS Documentation](https://nsis.sourceforge.io/Docs/)
- [Inno Setup Documentation](https://jrsoftware.org/ishelp/)
- [Windows Installer (MSI) Documentation](https://learn.microsoft.com/en-us/windows/win32/Msi/windows-installer-portal)

---END OF PAGE---


## DirectShow SDK Redistributable Files for Deployment
**URL:** https://www.visioforge.com/help/docs/directshow/deployment/redistributable-files/
**Description:** Complete list of redistributable files for VisioForge DirectShow SDKs with dependencies, architecture files, and deployment requirements.
**Tags:** DirectShow, C++, Windows, Streaming, Encoding, Decoding, Mixing, Screen Capture, WebM, H.264, MP3

# DirectShow SDKs - Redistributable Files Reference

## Overview

This document provides a complete list of files required to redistribute each DirectShow SDK with your application. All files must be included in your installer or deployment package.

---

## FFMPEG Source Filter

### Core Files

#### x86 (32-bit)

**Filter**: - `VisioForge_FFMPEG_Source.ax` - Main DirectShow filter **FFmpeg Libraries** (required): - `avcodec-58.dll` - Video/audio codec library - `avdevice-58.dll` - Device handling - `avfilter-7.dll` - Audio/video filtering - `avformat-58.dll` - Container format handling - `avutil-56.dll` - Utility functions - `swresample-3.dll` - Audio resampling - `swscale-5.dll` - Video scaling and color conversion **Total Size**: ~80-100 MB

#### x64 (64-bit)

**Filter**: - `VisioForge_FFMPEG_Source_x64.ax` - Main DirectShow filter (64-bit) **FFmpeg Libraries** (required): - `avcodec-58.dll` - 64-bit version - `avdevice-58.dll` - 64-bit version - `avfilter-7.dll` - 64-bit version - `avformat-58.dll` - 64-bit version - `avutil-56.dll` - 64-bit version - `swresample-3.dll` - 64-bit version - `swscale-5.dll` - 64-bit version **Total Size**: ~90-110 MB

### Installation Directory Structure

```
YourApp\
├── VisioForge_FFMPEG_Source.ax          (x86)
├── VisioForge_FFMPEG_Source_x64.ax      (x64)
├── avcodec-58.dll
├── avdevice-58.dll
├── avfilter-7.dll
├── avformat-58.dll
├── avutil-56.dll
├── swresample-3.dll
└── swscale-5.dll
```

### License Files

- `license.rtf` - SDK license agreement (include in installer)

### Dependencies

- **Visual C++ Redistributable 2015-2022** (x86 or x64)
- Download: https://aka.ms/vs/17/release/vc\_redist.x64.exe

---

## VLC Source Filter

### Core Files

#### x86 (32-bit) Only

**Filter**: - `VisioForge_VLC_Source.ax` - Main DirectShow filter

**VLC Libraries** (required): - `libvlc.dll` - VLC core library - `libvlccore.dll` - VLC core functionality

**VLC Plugins Directory** (required): - `plugins\` - Complete VLC plugins folder (~100+ plugin DLLs) - `plugins\access\` - Input protocols - `plugins\audio_filter\` - Audio processing - `plugins\audio_mixer\` - Audio mixing - `plugins\audio_output\` - Audio output - `plugins\codec\` - Codecs - `plugins\control\` - Control interfaces - `plugins\demux\` - Demultiplexers - `plugins\misc\` - Miscellaneous - `plugins\packetizer\` - Packetizers - `plugins\services_discovery\` - Service discovery - `plugins\stream_filter\` - Stream filters - `plugins\stream_out\` - Stream output - `plugins\text_renderer\` - Text rendering - `plugins\video_chroma\` - Color conversion - `plugins\video_filter\` - Video filters - `plugins\video_output\` - Video output - `plugins\visualization\` - Visualizations

**VLC Data Directories**: - `locale\` - Localization files (optional, ~50+ language folders) - `lua\` - Lua scripts for playlists and extensions - `hrtfs\` - HRTF audio files - `dodeca_and_7channel_3DSL_HRTF.sofa`

**Total Size**: ~150-200 MB (with all plugins and locales)

### Installation Directory Structure

```
YourApp\
├── VisioForge_VLC_Source.ax
├── libvlc.dll
├── libvlccore.dll
├── plugins\
│   ├── access\
│   ├── audio_filter\
│   ├── codec\
│   └── ... (all plugin directories)
├── locale\           (optional)
├── lua\
└── hrtfs\
```

### License Files

- `license.rtf` - SDK license agreement

### Dependencies

- **Visual C++ Redistributable 2015-2022** (x86)

### Important Notes

- **All VLC plugins must be included** - Missing plugins will cause playback failures for certain formats
- **Maintain directory structure** - VLC expects plugins in `plugins\` subdirectory
- **No x64 version** - VLC Source Filter is 32-bit only

---

## Processing Filters Pack

### Core Filters

#### x86 (32-bit)

**Video Processing**: - `VisioForge_Video_Effects_Pro.ax` - Video effects filter (35+ effects) - `VisioForge_Video_Mixer.ax` - Multi-source video mixer - `VisioForge_Screen_Capture_DD.ax` - DirectDraw screen capture **Audio Processing**: - `VisioForge_Audio_Enhancer.ax` - Audio enhancement filter - `VisioForge_Audio_Effects_4.ax` - Audio effects (optional) - `VisioForge_Audio_Mixer.ax` - Audio mixer **Base Filters** (required): - `VisioForge_BaseFilters.ax` - Core base filter library - `VisioForge_AsyncEx.ax` - Async file reader (optional) **Helper Libraries**: - `VisioForge_MFP.dll` - Media Foundation helper - `VisioForge_MFPX.dll` - Extended MF functions

#### x64 (64-bit)

**Video Processing**: - `VisioForge_Video_Effects_Pro_x64.ax` - `VisioForge_Video_Mixer_x64.ax` - `VisioForge_Screen_Capture_DD_x64.ax` **Audio Processing**: - `VisioForge_Audio_Enhancer_x64.ax` - `VisioForge_Audio_Mixer_x64.ax` **Base Filters** (required): - `VisioForge_BaseFilters_x64.ax` - `VisioForge_AsyncEx_x64.ax` (optional) **Helper Libraries**: - `VisioForge_MFP64.dll` - `VisioForge_MFPX64.dll`

### LAV Filters (Optional but Recommended)

LAV Filters provide additional codec support and are included with Processing Filters Pack.

#### x86

**LAV Filters**: - `LAVSplitter.ax` - Source splitter - `LAVVideo.ax` - Video decoder - `LAVAudio.ax` - Audio decoder **FFmpeg Libraries for LAV**: - `avcodec-lav-58.dll` - `avformat-lav-58.dll` - `avfilter-lav-7.dll` - `avresample-lav-4.dll` - `avutil-lav-56.dll` - `swscale-lav-5.dll` **Additional Libraries**: - `libbluray.dll` - Blu-ray support - `IntelQuickSyncDecoder.dll` - Intel QuickSync hardware decoding **Manifest**: - `LAVFilters.Dependencies.manifest` **License**: - `COPYING` - LAV Filters license (LGPL)

#### x64

Same files as x86 but 64-bit versions.

### Installation Directory Structure

```
YourApp\
├── Filters\
│   ├── VisioForge_Video_Effects_Pro.ax
│   ├── VisioForge_Video_Effects_Pro_x64.ax
│   ├── VisioForge_Video_Mixer.ax
│   ├── VisioForge_Video_Mixer_x64.ax
│   ├── VisioForge_Audio_Enhancer.ax
│   ├── VisioForge_Audio_Enhancer_x64.ax
│   ├── VisioForge_BaseFilters.ax
│   ├── VisioForge_BaseFilters_x64.ax
│   ├── VisioForge_MFP.dll
│   ├── VisioForge_MFP64.dll
│   ├── VisioForge_MFPX.dll
│   └── VisioForge_MFPX64.dll
└── LAV\
    ├── x86\
    │   ├── LAVSplitter.ax
    │   ├── LAVVideo.ax
    │   ├── LAVAudio.ax
    │   ├── avcodec-lav-58.dll
    │   └── ... (other LAV files)
    └── x64\
        ├── LAVSplitter.ax
        ├── LAVVideo.ax
        └── ... (other LAV files)
```

### License Files

- `license.rtf` - VisioForge SDK license
- `VisioForge_AsyncEx_license.htm` - Async filter license
- `VisioForge_Audio_Effects_4_note.txt` - Audio effects notes
- `COPYING` - LAV Filters license (in LAV directory)

### Total Size

- **Without LAV Filters**: ~20-30 MB
- **With LAV Filters**: ~80-100 MB

---

## Encoding Filters Pack

### Core Filters

#### x86 (32-bit)

**Video Encoders**: - `VisioForge_NVENC.ax` - NVIDIA hardware encoder - `VisioForge_H264_Encoder.ax` - H.264 software encoder - `VisioForge_H264_Encoder_v9.ax` - H.264 encoder v9 - `VisioForge_H264_Decoder.ax` - H.264 decoder - `VisioForge_WebM_VP8_Encoder.ax` - VP8 encoder - `VisioForge_WebM_VP9_Encoder.ax` - VP9 encoder (in x64) - `VisioForge_WebM_VP8_Decoder.ax` - VP8 decoder - `VisioForge_WebM_VP9_Decoder.ax` - VP9 decoder

**Audio Encoders**: - `VisioForge_AAC_Encoder.ax` - AAC encoder - `VisioForge_AAC_Encoder_v10.ax` - AAC encoder v10 - `VisioForge_LAME.ax` - MP3 encoder (LAME) - `VisioForge_WebM_Vorbis_Encoder.ax` - Vorbis encoder - `VisioForge_WebM_Vorbis_Decoder.ax` - Vorbis decoder

**Muxers/Demuxers**: - `VisioForge_MP4_Muxer.ax` - MP4 container muxer - `VisioForge_MP4_Muxer_v10.ax` - MP4 muxer v10 - `VisioForge_MF_Mux.ax` - Media Foundation muxer - `VisioForge_WebM_Mux.ax` - WebM muxer - `VisioForge_WebM_Split.ax` - WebM splitter - `VisioForge_WebM_Source.ax` - WebM source - `VisioForge_WebM_Ogg_Source.ax` - Ogg source - `VisioForge_SSF_Muxer.ax` - SSF muxer

**Network**: - `VisioForge_RTSP_Sink.ax` - RTSP sink - `VisioForge_RTSP_Source_Live555.ax` - RTSP source

**Base Filters** (required): - `VisioForge_BaseFilters.ax`

**Helper Libraries** (required): - `VisioForge_MFP.dll` - Media Foundation helper - `VisioForge_MFP64.dll` - 64-bit MF helper - `VisioForge_MFPX.dll` - Extended MF functions - `VisioForge_MFPX64.dll` - 64-bit extended MF - `VisioForge_MFT.dll` - Media Foundation Transform

**Intel QuickSync** (optional): - `libmfxsw32.dll` - QuickSync software library - `libmfxxp32.dll` - QuickSync XP library

#### x64 (64-bit)

**Video Encoders**: - `VisioForge_NVENC_x64.ax` - `VisioForge_H264_Encoder_x64.ax` - `VisioForge_H264_Encoder_v9_x64.ax` - `VisioForge_H264_Decoder_x64.ax` - `VisioForge_WebM_VP8_Encoder_x64.ax` - `VisioForge_WebM_VP9_Encoder_x64.ax` - `VisioForge_WebM_VP8_Decoder_x64.ax` - `VisioForge_WebM_VP9_Decoder_x64.ax`

**Audio Encoders**: - `VisioForge_AAC_Encoder_x64.ax` - `VisioForge_AAC_Encoder_v10_x64.ax` - `VisioForge_LAME_x64.ax` - `VisioForge_WebM_Vorbis_Encoder_x64.ax` - `VisioForge_WebM_Vorbis_Decoder_x64.ax`

**Muxers/Demuxers**: - `VisioForge_MP4_Muxer_x64.ax` - `VisioForge_MP4_Muxer_v10_x64.ax` - `VisioForge_MF_Mux_x64.ax` - `VisioForge_WebM_Mux_x64.ax` - `VisioForge_WebM_Split_x64.ax` - `VisioForge_WebM_Source_x64.ax` - `VisioForge_WebM_Ogg_Source_x64.ax` - `VisioForge_SSF_Muxer_x64.ax`

**Network**: - `VisioForge_RTSP_Sink_x64.ax` - `VisioForge_RTSP_Source_Live555_x64.ax`

**Base Filters** (required): - `VisioForge_BaseFilters_x64.ax`

**Helper Libraries** (same as x86): - `VisioForge_MFP64.dll` - `VisioForge_MFPX64.dll` - `VisioForge_MFT64.dll`

**Intel QuickSync** (optional): - `libmfxsw64.dll` - `libmfxxp64.dll`

### FFMPEG Encoder

The FFMPEG Encoder has its own set of FFmpeg libraries:

#### x86

**Filter**: - `VisioForge_FFMPEG_Encoder.ax`

**FFmpeg Libraries**: - `avcodec-58.dll` - `avdevice-58.dll` - `avfilter-7.dll` - `avformat-58.dll` - `avutil-56.dll` - `swresample-3.dll` - `swscale-5.dll` - `ffmedia.dll` - VisioForge FFmpeg wrapper

**Info**: - `vfffmpeg_info.txt` - FFmpeg build information

#### x64

Same files as x86 but 64-bit versions.

### Installation Directory Structure

```
YourApp\
├── Filters\
│   ├── VisioForge_NVENC.ax
│   ├── VisioForge_NVENC_x64.ax
│   ├── VisioForge_H264_Encoder.ax
│   ├── VisioForge_H264_Encoder_x64.ax
│   ├── VisioForge_AAC_Encoder.ax
│   ├── VisioForge_AAC_Encoder_x64.ax
│   ├── VisioForge_MP4_Muxer.ax
│   ├── VisioForge_MP4_Muxer_x64.ax
│   ├── VisioForge_BaseFilters.ax
│   ├── VisioForge_BaseFilters_x64.ax
│   ├── VisioForge_MFP.dll
│   ├── VisioForge_MFP64.dll
│   ├── VisioForge_MFPX.dll
│   ├── VisioForge_MFPX64.dll
│   ├── VisioForge_MFT.dll
│   ├── VisioForge_MFT64.dll
│   ├── libmfxsw32.dll        (QuickSync)
│   ├── libmfxsw64.dll        (QuickSync)
│   └── ... (other filters)
└── FFMPEG\
    ├── x86\
    │   ├── VisioForge_FFMPEG_Encoder.ax
    │   ├── avcodec-58.dll
    │   ├── avformat-58.dll
    │   ├── ffmedia.dll
    │   └── ... (other FFmpeg DLLs)
    └── x64\
        ├── VisioForge_FFMPEG_Encoder_x64.ax
        └── ... (FFmpeg DLLs)
```

### License Files

- `license.rtf` - SDK license

### Total Size

- **Core Filters Only**: ~40-60 MB
- **With FFMPEG Encoder**: ~120-150 MB
- **Complete Pack**: ~150-180 MB

### Hardware Requirements

- **NVENC**: Requires NVIDIA GPU (GeForce GTX 600+ or Quadro K+) and drivers
- **QuickSync**: Requires Intel CPU with integrated graphics (4th gen+)

---

## Virtual Camera SDK

### Core Files

#### x86 (32-bit)

**Virtual Camera Drivers**: - `VisioForge_Virtual_Camera.ax` - Virtual camera device driver - `VisioForge_Virtual_Audio_Card.ax` - Virtual audio device driver **Source Filters**: - `VisioForge_Push_Video_Source.ax` - Push source for streaming to virtual camera - `VisioForge_Screen_Capture_DD.ax` - DirectDraw screen capture **Processing** (included): - `VisioForge_Video_Effects_Pro.ax` - Video effects **Base Filters** (required): - `VisioForge_BaseFilters.ax` **Helper Libraries** (required): - `VisioForge_MFP.dll` - `VisioForge_MFPX.dll` **Runtime** (required): - `vcomp140.dll` - Visual C++ OpenMP runtime

#### x64 (64-bit)

**Virtual Camera Drivers**: - `VisioForge_Virtual_Camera_x64.ax` - `VisioForge_Virtual_Audio_Card_x64.ax` **Source Filters**: - `VisioForge_Push_Video_Source_x64.ax` - `VisioForge_Screen_Capture_DD_x64.ax` **Processing**: - `VisioForge_Video_Effects_Pro_x64.ax` **Base Filters** (required): - `VisioForge_BaseFilters_x64.ax` **Helper Libraries** (required): - `VisioForge_MFP64.dll` - `VisioForge_MFPX64.dll`

### Installation Directory Structure

```
YourApp\
├── VisioForge_Virtual_Camera.ax
├── VisioForge_Virtual_Camera_x64.ax
├── VisioForge_Virtual_Audio_Card.ax
├── VisioForge_Virtual_Audio_Card_x64.ax
├── VisioForge_Push_Video_Source.ax
├── VisioForge_Push_Video_Source_x64.ax
├── VisioForge_Screen_Capture_DD.ax
├── VisioForge_Screen_Capture_DD_x64.ax
├── VisioForge_Video_Effects_Pro.ax
├── VisioForge_Video_Effects_Pro_x64.ax
├── VisioForge_BaseFilters.ax
├── VisioForge_BaseFilters_x64.ax
├── VisioForge_MFP.dll
├── VisioForge_MFP64.dll
├── VisioForge_MFPX.dll
├── VisioForge_MFPX64.dll
└── vcomp140.dll
```

### License Files

- `license.rtf` - SDK license

### Total Size

~15-20 MB

### Important Notes

- Virtual camera devices appear in video conferencing apps (Zoom, Teams, Skype, etc.)
- Supports up to 4 virtual camera instances
- Requires driver installation (included in installer)

---

## Common Dependencies

### Visual C++ Redistributables

All SDKs require Visual C++ Redistributable 2015-2022.

**Download Links**: - x86: https://aka.ms/vs/17/release/vc\_redist.x86.exe - x64: https://aka.ms/vs/17/release/vc\_redist.x64.exe

**Installation Check** (programmatic):

```
// Check if VC++ Redistributable is installed
bool IsVCRedistInstalled()
{
    HKEY hKey;
    LONG result = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
        L"SOFTWARE\\Microsoft\\VisualStudio\\14.0\\VC\\Runtimes\\x64",
        0, KEY_READ, &hKey);

    if (result == ERROR_SUCCESS)
    {
        RegCloseKey(hKey);
        return true;
    }
    return false;
}
```

### Registration Utility

All SDKs include: - `reg_special.exe` - Custom registration utility

This tool can be used instead of `regsvr32` for filter registration.

---

## Deployment Checklist

### Minimum Required Files

For each SDK, you must include: 1. ✅ **Filter Files** - All .ax files for your architecture (x86/x64) 2. ✅ **Base Filters** - VisioForge\_BaseFilters.ax (if required by SDK) 3. ✅ **Helper DLLs** - VisioForge\_MFP*.dll, VisioForge\_MFPX*.dll 4. ✅ **Dependencies** - FFmpeg DLLs, VLC libraries, etc. 5. ✅ **License File** - license.rtf (display in installer) 6. ✅ **VC++ Redistributable** - Bundle or download in installer

### Optional Files

- 📄 **LAV Filters** - Enhanced codec support (Processing Filters Pack)
- 📄 **QuickSync DLLs** - Intel hardware encoding (Encoding Filters Pack)
- 📄 **VLC Locale** - Multi-language support (VLC Source)
- 📄 **Registration Utility** - reg\_special.exe (alternative to regsvr32)

### Architecture Considerations

**32-bit Application**: - Include only x86 (.ax) files - No need for x64 versions **64-bit Application**: - Include only x64 (\_x64.ax) files - No need for x86 versions **AnyCPU/.NET Application**: - Include both x86 and x64 versions - Register both during installation - Application will use appropriate architecture at runtime

---

## File Size Summary

| SDK | Minimum Size | With All Options |
| --- | --- | --- |
| **FFMPEG Source** | ~80 MB (x86) | ~190 MB (both arch) |
| **VLC Source** | ~150 MB | ~200 MB (with locales) |
| **Processing Filters** | ~20 MB | ~180 MB (with LAV) |
| **Encoding Filters** | ~40 MB | ~300 MB (complete) |
| **Virtual Camera** | ~15 MB | ~35 MB (both arch) |

---

## Testing Deployment Package

Before releasing, verify all files are included:

```
@echo off
echo Testing Filter Registration...
REM Test each filter
regsvr32 /s "VisioForge_FFMPEG_Source_x64.ax"
if %errorLevel% neq 0 (
    echo ERROR: FFMPEG Source failed to register
    echo Check if all FFmpeg DLLs are present
    exit /b 1
)
REM Test filter creation
YourTestApp.exe
echo All filters registered successfully!
```

---

## See Also

- [Filter Registration](../filter-registration/) - How to register filters
- [Installer Integration](../installer-integration/) - Creating installers
- [Deployment Overview](../) - Main deployment guide

---END OF PAGE---


## FFmpeg Source Filter DirectShow Examples - C++, C#, VB.NET
**URL:** https://www.visioforge.com/help/docs/directshow/ffmpeg-source-filters/examples/
**Description:** Build DirectShow graphs with FFmpeg Source Filter — file playback, hardware decoding, network streaming, and custom buffering in C++, C#, and VB.NET.
**Tags:** DirectShow, C++, Windows, WinForms, Playback, Streaming, Decoding, RTSP, HLS, MP4, MKV, AVI, MOV, C#, VB.NET
**API:** IFileSourceFilter, IFFMPEGSourceSettings, IBaseFilter, IVFRegister

# Code Examples

## Overview

This page provides practical code examples for using the FFMPEG Source Filter in DirectShow applications. Examples are provided in C++, C#, and VB.NET.

## Complete Working Samples

**Official GitHub Repository**: All examples shown on this page are available as complete, working Visual Studio projects in our GitHub samples repository:

🔗 **[DirectShow Samples Repository](https://github.com/visioforge/directshow-samples)**

### FFMPEG Source Filter Samples

- **[C# Sample](https://github.com/visioforge/directshow-samples/tree/master/FFMPEG%20Source%20Filter/dotnet/cs)** - Full-featured media player with all filter capabilities
- **[VB.NET Sample](https://github.com/visioforge/directshow-samples/tree/master/FFMPEG%20Source%20Filter/dotnet/vbnet)** - VB.NET implementation
- **[C++Builder Sample](https://github.com/visioforge/directshow-samples/tree/master/FFMPEG%20Source%20Filter/cpp_builder)** - C++ implementation

Each sample includes: - Complete Visual Studio/C++Builder project files - Working code for playback, stream selection, and configuration - Hardware acceleration examples - Network streaming (RTSP/HLS) examples

---

## Prerequisites

### C++ Projects

```
#include <dshow.h>
#include <streams.h>
#include "IFFMPEGSourceSettings.h"  // From SDK
#pragma comment(lib, "strmiids.lib")
```

### C# Projects

```
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;
using System.Runtime.InteropServices;
```

**NuGet Packages**: - VisioForge.DirectShowAPI - MediaFoundationCore

---

## Example 1: Basic File Playback

Play a local media file with default settings.

### C++ Implementation

```
#include <dshow.h>
#include <windows.h>
#include "IFFMPEGSourceSettings.h"

// CLSID for FFMPEG Source Filter
DEFINE_GUID(CLSID_VFFFMPEGSource,
    0x1974d893, 0x83e4, 0x4f89, 0x99, 0x8, 0x79, 0x5c, 0x52, 0x4c, 0xc1, 0x7e);

HRESULT PlayFile(LPCWSTR filename, HWND hVideoWindow)
{
    IGraphBuilder* pGraph = NULL;
    IMediaControl* pControl = NULL;
    IMediaEventEx* pEvent = NULL;
    IBaseFilter* pSourceFilter = NULL;
    IFileSourceFilter* pFileSource = NULL;
    IVideoWindow* pVideoWindow = NULL;

    HRESULT hr = S_OK;

    // Create Filter Graph
    hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
                         IID_IGraphBuilder, (void**)&pGraph);
    if (FAILED(hr)) return hr;

    // Create FFMPEG Source Filter
    hr = CoCreateInstance(CLSID_VFFFMPEGSource, NULL, CLSCTX_INPROC_SERVER,
                         IID_IBaseFilter, (void**)&pSourceFilter);
    if (FAILED(hr)) goto cleanup;

    // Add filter to graph
    hr = pGraph->AddFilter(pSourceFilter, L"FFMPEG Source");
    if (FAILED(hr)) goto cleanup;

    // Load file
    hr = pSourceFilter->QueryInterface(IID_IFileSourceFilter, (void**)&pFileSource);
    if (FAILED(hr)) goto cleanup;

    hr = pFileSource->Load(filename, NULL);
    if (FAILED(hr)) goto cleanup;

    // Render streams automatically
    hr = pGraph->QueryInterface(IID_IGraphBuilder, (void**)&pGraph);

    ICaptureGraphBuilder2* pBuild = NULL;
    hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER,
                         IID_ICaptureGraphBuilder2, (void**)&pBuild);
    if (SUCCEEDED(hr))
    {
        hr = pBuild->SetFiltergraph(pGraph);

        // Render video stream
        hr = pBuild->RenderStream(NULL, &MEDIATYPE_Video, pSourceFilter, NULL, NULL);

        // Render audio stream
        hr = pBuild->RenderStream(NULL, &MEDIATYPE_Audio, pSourceFilter, NULL, NULL);

        pBuild->Release();
    }

    // Set video window
    hr = pGraph->QueryInterface(IID_IVideoWindow, (void**)&pVideoWindow);
    if (SUCCEEDED(hr))
    {
        pVideoWindow->put_Owner((OAHWND)hVideoWindow);
        pVideoWindow->put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS);

        RECT rc;
        GetClientRect(hVideoWindow, &rc);
        pVideoWindow->SetWindowPosition(0, 0, rc.right, rc.bottom);
    }

    // Get control interface
    hr = pGraph->QueryInterface(IID_IMediaControl, (void**)&pControl);
    if (FAILED(hr)) goto cleanup;

    // Run the graph
    hr = pControl->Run();

cleanup:
    if (pFileSource) pFileSource->Release();
    if (pVideoWindow) pVideoWindow->Release();
    if (pControl) pControl->Release();
    if (pSourceFilter) pSourceFilter->Release();
    if (pGraph) pGraph->Release();

    return hr;
}
```

### C# Implementation

```
using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;

public class FFMPEGSourceBasicExample
{
    private IFilterGraph2 filterGraph;
    private IMediaControl mediaControl;
    private IVideoWindow videoWindow;
    private IBaseFilter sourceFilter;

    public void PlayFile(string filename, IntPtr videoWindowHandle)
    {
        try
        {
            // Create filter graph
            filterGraph = (IFilterGraph2)new FilterGraph();
            mediaControl = (IMediaControl)filterGraph;
            videoWindow = (IVideoWindow)filterGraph;

            // Create and add FFMPEG Source filter
            sourceFilter = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFFFMPEGSource,
                "FFMPEG Source");

            // Load file
            var fileSource = sourceFilter as IFileSourceFilter;
            int hr = fileSource.Load(filename, null);
            DsError.ThrowExceptionForHR(hr);

            // Render streams
            ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
            hr = captureGraph.SetFiltergraph(filterGraph);
            DsError.ThrowExceptionForHR(hr);

            // Render video
            hr = captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
            // Render audio
            hr = captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);

            // Set video window
            videoWindow.put_Owner(videoWindowHandle);
            videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);
            videoWindow.put_Visible(OABool.True);

            // Run graph
            mediaControl.Run();

            Marshal.ReleaseComObject(captureGraph);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Error: {ex.Message}", "Playback Error");
        }
    }

    public void Stop()
    {
        if (mediaControl != null)
        {
            mediaControl.Stop();
        }

        if (videoWindow != null)
        {
            videoWindow.put_Visible(OABool.False);
            videoWindow.put_Owner(IntPtr.Zero);
        }

        FilterGraphTools.RemoveAllFilters(filterGraph);

        if (sourceFilter != null) Marshal.ReleaseComObject(sourceFilter);
        if (videoWindow != null) Marshal.ReleaseComObject(videoWindow);
        if (mediaControl != null) Marshal.ReleaseComObject(mediaControl);
        if (filterGraph != null) Marshal.ReleaseComObject(filterGraph);
    }
}
```

### VB.NET Implementation

```
Imports System.Runtime.InteropServices
Imports VisioForge.DirectShowAPI
Imports VisioForge.DirectShowLib

Public Class FFMPEGSourceBasicExample
    Private filterGraph As IFilterGraph2
    Private mediaControl As IMediaControl
    Private videoWindow As IVideoWindow
    Private sourceFilter As IBaseFilter

    Public Sub PlayFile(filename As String, videoWindowHandle As IntPtr)
        Try
            ' Create filter graph
            filterGraph = DirectCast(New FilterGraph(), IFilterGraph2)
            mediaControl = DirectCast(filterGraph, IMediaControl)
            videoWindow = DirectCast(filterGraph, IVideoWindow)

            ' Create and add FFMPEG Source filter
            sourceFilter = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFFFMPEGSource,
                "FFMPEG Source")

            ' Load file
            Dim fileSource = DirectCast(sourceFilter, IFileSourceFilter)
            Dim hr As Integer = fileSource.Load(filename, Nothing)
            DsError.ThrowExceptionForHR(hr)

            ' Render streams
            Dim captureGraph As ICaptureGraphBuilder2 = DirectCast(New CaptureGraphBuilder2(), ICaptureGraphBuilder2)
            hr = captureGraph.SetFiltergraph(filterGraph)
            DsError.ThrowExceptionForHR(hr)

            ' Render video and audio
            captureGraph.RenderStream(Nothing, MediaType.Video, sourceFilter, Nothing, Nothing)
            captureGraph.RenderStream(Nothing, MediaType.Audio, sourceFilter, Nothing, Nothing)

            ' Set video window
            videoWindow.put_Owner(videoWindowHandle)
            videoWindow.put_WindowStyle(WindowStyle.Child Or WindowStyle.ClipSiblings)
            videoWindow.put_Visible(OABool.True)

            ' Run graph
            mediaControl.Run()

            Marshal.ReleaseComObject(captureGraph)
        Catch ex As Exception
            MessageBox.Show($"Error: {ex.Message}", "Playback Error")
        End Try
    End Sub

    Public Sub [Stop]()
        If mediaControl IsNot Nothing Then
            mediaControl.Stop()
        End If

        If videoWindow IsNot Nothing Then
            videoWindow.put_Visible(OABool.False)
            videoWindow.put_Owner(IntPtr.Zero)
        End If

        FilterGraphTools.RemoveAllFilters(filterGraph)

        If sourceFilter IsNot Nothing Then Marshal.ReleaseComObject(sourceFilter)
        If videoWindow IsNot Nothing Then Marshal.ReleaseComObject(videoWindow)
        If mediaControl IsNot Nothing Then Marshal.ReleaseComObject(mediaControl)
        If filterGraph IsNot Nothing Then Marshal.ReleaseComObject(filterGraph)
    End Sub
End Class
```

---

## Example 2: Hardware Acceleration

Enable GPU decoding for better performance.

### C++ with Hardware Acceleration

```
HRESULT PlayFileWithGPU(LPCWSTR filename)
{
    IBaseFilter* pSourceFilter = NULL;
    IFFMPEGSourceSettings* pSettings = NULL;
    // Create source filter
    HRESULT hr = CoCreateInstance(CLSID_VFFFMPEGSource, NULL, CLSCTX_INPROC_SERVER,
                                  IID_IBaseFilter, (void**)&pSourceFilter);
    if (FAILED(hr)) return hr;
    // Get configuration interface
    hr = pSourceFilter->QueryInterface(IID_IFFMPEGSourceSettings, (void**)&pSettings);
    if (FAILED(hr))
    {
        pSourceFilter->Release();
        return hr;
    }
    // Enable hardware acceleration (NVDEC/QuickSync/DXVA)
    hr = pSettings->SetHWAccelerationEnabled(TRUE);
    if (FAILED(hr))
    {
        pSettings->Release();
        pSourceFilter->Release();
        return hr;
    }
    // Load file
    IFileSourceFilter* pFileSource = NULL;
    hr = pSourceFilter->QueryInterface(IID_IFileSourceFilter, (void**)&pFileSource);
    if (SUCCEEDED(hr))
    {
        hr = pFileSource->Load(filename, NULL);
        pFileSource->Release();
    }
    // Continue building graph...
    // (Add to graph, render streams, etc.)
    pSettings->Release();
    pSourceFilter->Release();
    return hr;
}
```

### C# with Hardware Acceleration

## ``` public void PlayFileWithHardwareAcceleration(string filename, IntPtr videoWindowHandle) { filterGraph = (IFilterGraph2)new FilterGraph(); // Create source filter sourceFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFFFMPEGSource, "FFMPEG Source"); // Configure hardware acceleration var settings = sourceFilter as IFFMPEGSourceSettings; if (settings != null) { // Enable GPU decoding int hr = settings.SetHWAccelerationEnabled(true); DsError.ThrowExceptionForHR(hr); } // Load file var fileSource = sourceFilter as IFileSourceFilter; fileSource.Load(filename, null); // Build and run graph... ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); captureGraph.SetFiltergraph(filterGraph); captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null); captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null); mediaControl = (IMediaControl)filterGraph; mediaControl.Run(); Marshal.ReleaseComObject(captureGraph); } ```

## Example 3: Network Streaming (RTSP/HLS)

Stream video from network sources.

### C# RTSP Streaming

```
public void PlayRTSPStream(string rtspUrl, IntPtr videoWindowHandle)
{
    filterGraph = (IFilterGraph2)new FilterGraph();

    sourceFilter = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFFFMPEGSource,
        "FFMPEG Source");

    // Configure for network streaming
    var settings = sourceFilter as IFFMPEGSourceSettings;
    if (settings != null)
    {
        // Set buffering mode for network streams
        settings.SetBufferingMode(FFMPEG_SOURCE_BUFFERING_MODE.FFMPEG_SOURCE_BUFFERING_MODE_ON);

        // Set connection timeout (in seconds)
        settings.SetLoadTimeOut(30);

        // Enable hardware decoding for performance
        settings.SetHWAccelerationEnabled(true);
    }

    // Load RTSP stream
    // Example: "rtsp://camera.example.com:554/stream"
    var fileSource = sourceFilter as IFileSourceFilter;
    int hr = fileSource.Load(rtspUrl, null);
    DsError.ThrowExceptionForHR(hr);

    // Build graph
    ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
    captureGraph.SetFiltergraph(filterGraph);

    captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
    captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);

    // Setup video window
    videoWindow = (IVideoWindow)filterGraph;
    videoWindow.put_Owner(videoWindowHandle);
    videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);
    videoWindow.put_Visible(OABool.True);

    // Run
    mediaControl = (IMediaControl)filterGraph;
    mediaControl.Run();

    Marshal.ReleaseComObject(captureGraph);
}
```

### C# HLS Streaming

```
public void PlayHLSStream(string hlsUrl, IntPtr videoWindowHandle)
{
    filterGraph = (IFilterGraph2)new FilterGraph();

    sourceFilter = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFFFMPEGSource,
        "FFMPEG Source");

    var settings = sourceFilter as IFFMPEGSourceSettings;
    if (settings != null)
    {
        // HLS streams benefit from buffering
        settings.SetBufferingMode(FFMPEG_SOURCE_BUFFERING_MODE.FFMPEG_SOURCE_BUFFERING_MODE_ON);

        // Longer timeout for HLS playlist loading
        settings.SetLoadTimeOut(60);

        // Hardware acceleration
        settings.SetHWAccelerationEnabled(true);
    }

    // Load HLS stream
    // Example: "https://example.com/stream/playlist.m3u8"
    var fileSource = sourceFilter as IFileSourceFilter;
    fileSource.Load(hlsUrl, null);

    // Build and run graph (same as RTSP example)
    ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
    captureGraph.SetFiltergraph(filterGraph);

    captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
    captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);

    videoWindow = (IVideoWindow)filterGraph;
    videoWindow.put_Owner(videoWindowHandle);
    videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);

    mediaControl = (IMediaControl)filterGraph;
    mediaControl.Run();

    Marshal.ReleaseComObject(captureGraph);
}
```

---

## Example 4: Custom FFmpeg Options

Pass custom FFmpeg demuxer/decoder options.

### C# with Custom Options

```
public void PlayWithCustomOptions(string filename, IntPtr videoWindowHandle)
{
    filterGraph = (IFilterGraph2)new FilterGraph();
    sourceFilter = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFFFMPEGSource,
        "FFMPEG Source");
    var settings = sourceFilter as IFFMPEGSourceSettings;
    if (settings != null)
    {
        // Set custom FFmpeg options
        // Format: "key=value" for each option
        // Example 1: Set buffer size for network streams
        settings.SetCustomOption("buffer_size", "1024000");
        // Example 2: Enable low latency mode
        settings.SetCustomOption("fflags", "nobuffer");
        // Example 3: Set analyzer duration (microseconds)
        settings.SetCustomOption("analyzeduration", "1000000");
        // Example 4: Set probe size
        settings.SetCustomOption("probesize", "5000000");
        // Example 5: RTSP transport protocol
        settings.SetCustomOption("rtsp_transport", "tcp");
        // Example 6: Set timeout (microseconds)
        settings.SetCustomOption("timeout", "5000000");
    }
    // Load file
    var fileSource = sourceFilter as IFileSourceFilter;
    fileSource.Load(filename, null);
    // Build graph...
    ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
    captureGraph.SetFiltergraph(filterGraph);
    captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
    captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);
    mediaControl = (IMediaControl)filterGraph;
    mediaControl.Run();
    Marshal.ReleaseComObject(captureGraph);
}
```

### Common FFmpeg Options

## ``` // Network streaming options settings.SetCustomOption("rtsp_transport", "tcp"); // Use TCP for RTSP settings.SetCustomOption("rtsp_flags", "prefer_tcp"); // Prefer TCP over UDP settings.SetCustomOption("timeout", "10000000"); // 10 second timeout settings.SetCustomOption("stimeout", "5000000"); // 5 second socket timeout // Buffer and probing options settings.SetCustomOption("buffer_size", "2097152"); // 2MB buffer settings.SetCustomOption("analyzeduration", "2000000"); // 2 seconds analysis settings.SetCustomOption("probesize", "10000000"); // 10MB probe size // Low latency options settings.SetCustomOption("fflags", "nobuffer"); // Disable buffering settings.SetCustomOption("flags", "low_delay"); // Low delay flag settings.SetCustomOption("framedrop", "1"); // Allow frame dropping // HTTP options settings.SetCustomOption("user_agent", "MyApp/1.0"); // Custom user agent settings.SetCustomOption("headers", "Authorization: Bearer token"); // Clear all custom options settings.ClearCustomOptions(); ```

## Example 5: Buffering Mode Configuration

Control buffering behavior for different scenarios.

### C# Buffering Examples

```
public enum BufferingScenario
{
    LocalFile,
    NetworkStream,
    LowLatency
}

public void PlayWithBuffering(string source, BufferingScenario scenario, IntPtr videoWindowHandle)
{
    filterGraph = (IFilterGraph2)new FilterGraph();

    sourceFilter = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFFFMPEGSource,
        "FFMPEG Source");

    var settings = sourceFilter as IFFMPEGSourceSettings;
    if (settings != null)
    {
        switch (scenario)
        {
            case BufferingScenario.LocalFile:
                // Auto mode - let filter decide
                settings.SetBufferingMode(
                    FFMPEG_SOURCE_BUFFERING_MODE.FFMPEG_SOURCE_BUFFERING_MODE_AUTO);
                break;

            case BufferingScenario.NetworkStream:
                // Enable buffering for smooth playback
                settings.SetBufferingMode(
                    FFMPEG_SOURCE_BUFFERING_MODE.FFMPEG_SOURCE_BUFFERING_MODE_ON);
                settings.SetLoadTimeOut(30);  // 30 second timeout
                break;

            case BufferingScenario.LowLatency:
                // Disable buffering for minimal latency
                settings.SetBufferingMode(
                    FFMPEG_SOURCE_BUFFERING_MODE.FFMPEG_SOURCE_BUFFERING_MODE_OFF);
                settings.SetCustomOption("fflags", "nobuffer");
                settings.SetCustomOption("flags", "low_delay");
                break;
        }
    }

    // Load source
    var fileSource = sourceFilter as IFileSourceFilter;
    fileSource.Load(source, null);

    // Build and run graph...
    ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
    captureGraph.SetFiltergraph(filterGraph);

    captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
    captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);

    mediaControl = (IMediaControl)filterGraph;
    mediaControl.Run();

    Marshal.ReleaseComObject(captureGraph);
}
```

---

## Example 6: Multi-Stream Selection

Select specific video and audio tracks.

### C# Stream Selection

## ``` public void PlayWithStreamSelection(string filename, int videoStreamIndex, int audioStreamIndex, IntPtr videoWindowHandle) { filterGraph = (IFilterGraph2)new FilterGraph(); sourceFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFFFMPEGSource, "FFMPEG Source"); // Load file first var fileSource = sourceFilter as IFileSourceFilter; fileSource.Load(filename, null); // Get available streams var streamSelect = sourceFilter as IAMStreamSelect; if (streamSelect != null) { streamSelect.Count(out int streamCount); List<int> videoStreams = new List<int>(); List<int> audioStreams = new List<int>(); // Enumerate streams for (int i = 0; i < streamCount; i++) { streamSelect.Info(i, out AMMediaType mt, out _, out _, out _, out string name, out _, out _); if (mt.majorType == MediaType.Video) { videoStreams.Add(i); Console.WriteLine($"Video Stream {videoStreams.Count - 1}: {name}"); } else if (mt.majorType == MediaType.Audio) { audioStreams.Add(i); Console.WriteLine($"Audio Stream {audioStreams.Count - 1}: {name}"); } DsUtils.FreeAMMediaType(mt); } // Enable selected streams if (videoStreamIndex >= 0 && videoStreamIndex < videoStreams.Count) { streamSelect.Enable(videoStreams[videoStreamIndex], AMStreamSelectEnableFlags.Enable); } if (audioStreamIndex >= 0 && audioStreamIndex < audioStreams.Count) { streamSelect.Enable(audioStreams[audioStreamIndex], AMStreamSelectEnableFlags.Enable); } } // Build graph ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); captureGraph.SetFiltergraph(filterGraph); captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null); captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null); videoWindow = (IVideoWindow)filterGraph; videoWindow.put_Owner(videoWindowHandle); videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings); mediaControl = (IMediaControl)filterGraph; mediaControl.Run(); Marshal.ReleaseComObject(captureGraph); } ```

## Example 7: Container Data Callback (e.g., SMPTE KLV metadata)

Receive raw out-of-band data buffers carried in the container (such as SMPTE KLV metadata packets in MPEG-TS streams). The callback fires once per data packet and surfaces the packet bytes plus its presentation/end timestamps.

### C# Data Callback Implementation

```
// Real signature (per IFFmpegSourceSettings.h):
//   HRESULT (BYTE* buffer, int bufferLen, int dataType, LONGLONG startTime, LONGLONG stopTime)
// dataType is a VF_DATA_TYPE enum:
//   0 = unknown, 1 = SMPTE_KLV
public delegate int FFMPEGDataCallbackDelegate(
    IntPtr buffer,
    int bufferLen,
    int dataType,
    long startTime,
    long stopTime);

public class FFMPEGDataCallbackExample
{
    private IFilterGraph2 filterGraph;
    private IBaseFilter sourceFilter;
    private FFMPEGDataCallbackDelegate dataCallback;

    public void PlayWithCallback(string filename, Action<byte[], int, long, long> onPacket)
    {
        // Keep a managed reference to the delegate so the GC doesn't collect it
        // while native code holds a function pointer to it.
        this.dataCallback = (buffer, bufferLen, dataType, startTime, stopTime) =>
        {
            byte[] managed = new byte[bufferLen];
            Marshal.Copy(buffer, managed, 0, bufferLen);
            onPacket(managed, dataType, startTime, stopTime);
            return 0; // S_OK
        };

        filterGraph = (IFilterGraph2)new FilterGraph();

        sourceFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFFFMPEGSource,
            "FFMPEG Source");

        var settings = sourceFilter as IFFMPEGSourceSettings;
        if (settings != null)
        {
            // Wire up the data callback
            settings.SetDataCallback(this.dataCallback);
        }

        // Load file
        var fileSource = sourceFilter as IFileSourceFilter;
        fileSource.Load(filename, null);

        // Build graph (without renderers if you only want callbacks)
        ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
        captureGraph.SetFiltergraph(filterGraph);

        // Render normally; the data callback fires alongside playback.
        captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
        captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);

        var mediaControl = (IMediaControl)filterGraph;
        mediaControl.Run();

        Marshal.ReleaseComObject(captureGraph);
    }
}

// Usage:
//   example.PlayWithCallback("input.ts", (bytes, dataType, startTime, stopTime) =>
//   {
//       const int VF_DATA_TYPE_SMPTE_KLV = 1;
//       if (dataType == VF_DATA_TYPE_SMPTE_KLV)
//       {
//           // Decode KLV metadata packet
//           Console.WriteLine($"KLV packet: {bytes.Length} bytes, {startTime}–{stopTime}");
//       }
//   });
```

---

## Example 8: Timestamp Callback

Monitor demuxer/stream timing per media type.

### C# Timestamp Callback

## ``` // Real signature (per IFFmpegSourceSettings.h): // HRESULT (int mediaType, __int64 demuxerStartTime, // __int64 streamStartTime, __int64 timestamp) // mediaType selects between audio and video streams. public delegate int FFMPEGTimestampCallbackDelegate( int mediaType, long demuxerStartTime, long streamStartTime, long timestamp); private FFMPEGTimestampCallbackDelegate timestampCallback; public void PlayWithTimestampCallback(string filename) { // Hold the delegate so it isn't GC'd while native code calls back. this.timestampCallback = (mediaType, demuxerStart, streamStart, timestamp) => { Console.WriteLine( $"mediaType={mediaType} demuxerStart={demuxerStart} " + $"streamStart={streamStart} timestamp={timestamp}"); return 0; // S_OK }; filterGraph = (IFilterGraph2)new FilterGraph(); sourceFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFFFMPEGSource, "FFMPEG Source"); var settings = sourceFilter as IFFMPEGSourceSettings; if (settings != null) { settings.SetTimestampCallback(this.timestampCallback); } // Load and play file... var fileSource = sourceFilter as IFileSourceFilter; fileSource.Load(filename, null); ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); captureGraph.SetFiltergraph(filterGraph); captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null); captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null); var mediaControl = (IMediaControl)filterGraph; mediaControl.Run(); Marshal.ReleaseComObject(captureGraph); } ```

## Example 9: License Activation

Activate purchased license.

### C# License Activation

```
public void PlayWithLicense(string filename, string licenseKey, IntPtr videoWindowHandle)
{
    filterGraph = (IFilterGraph2)new FilterGraph();

    sourceFilter = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFFFMPEGSource,
        "FFMPEG Source");

    // Activate license
    var registration = sourceFilter as IVFRegister;
    if (registration != null)
    {
        int hr = registration.SetLicenseKey(licenseKey);
        if (hr != 0)
        {
            throw new Exception("License activation failed");
        }
    }

    // Configure and play...
    var settings = sourceFilter as IFFMPEGSourceSettings;
    if (settings != null)
    {
        settings.SetHWAccelerationEnabled(true);
    }

    var fileSource = sourceFilter as IFileSourceFilter;
    fileSource.Load(filename, null);

    ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
    captureGraph.SetFiltergraph(filterGraph);

    captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
    captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);

    videoWindow = (IVideoWindow)filterGraph;
    videoWindow.put_Owner(videoWindowHandle);
    videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);

    mediaControl = (IMediaControl)filterGraph;
    mediaControl.Run();

    Marshal.ReleaseComObject(captureGraph);
}
```

---

## Example 10: Complete Media Player

Full-featured media player with all features.

### C# Complete Example

```
using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;
public class FFMPEGMediaPlayer : IDisposable
{
    private IFilterGraph2 filterGraph;
    private ICaptureGraphBuilder2 captureGraph;
    private IMediaControl mediaControl;
    private IMediaSeeking mediaSeeking;
    private IVideoWindow videoWindow;
    private IMediaEventEx mediaEventEx;
    private IBaseFilter sourceFilter;
    private const int WM_GRAPHNOTIFY = 0x8000 + 1;
    public event EventHandler PlaybackComplete;
    public void Initialize(IntPtr windowHandle, IntPtr notifyHandle)
    {
        // Create filter graph
        filterGraph = (IFilterGraph2)new FilterGraph();
        captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
        mediaControl = (IMediaControl)filterGraph;
        mediaSeeking = (IMediaSeeking)filterGraph;
        videoWindow = (IVideoWindow)filterGraph;
        mediaEventEx = (IMediaEventEx)filterGraph;
        // Setup event notifications
        int hr = mediaEventEx.SetNotifyWindow(notifyHandle, WM_GRAPHNOTIFY, IntPtr.Zero);
        DsError.ThrowExceptionForHR(hr);
        // Attach capture graph
        hr = captureGraph.SetFiltergraph(filterGraph);
        DsError.ThrowExceptionForHR(hr);
    }
    public void LoadFile(string filename, bool enableGPU, bool enableBuffering, string licenseKey = null)
    {
        // Create source filter
        sourceFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFFFMPEGSource,
            "FFMPEG Source");
        // Register license if provided
        if (!string.IsNullOrEmpty(licenseKey))
        {
            var registration = sourceFilter as IVFRegister;
            registration?.SetLicenseKey(licenseKey);
        }
        // Configure filter
        var settings = sourceFilter as IFFMPEGSourceSettings;
        if (settings != null)
        {
            settings.SetHWAccelerationEnabled(enableGPU);
            if (enableBuffering)
            {
                settings.SetBufferingMode(
                    FFMPEG_SOURCE_BUFFERING_MODE.FFMPEG_SOURCE_BUFFERING_MODE_ON);
            }
            else
            {
                settings.SetBufferingMode(
                    FFMPEG_SOURCE_BUFFERING_MODE.FFMPEG_SOURCE_BUFFERING_MODE_AUTO);
            }
            settings.SetLoadTimeOut(30);
        }
        // Load file
        var fileSource = sourceFilter as IFileSourceFilter;
        int hr = fileSource.Load(filename, null);
        DsError.ThrowExceptionForHR(hr);
        // Render streams
        hr = captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
        hr = captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);
    }
    public void SetVideoWindow(IntPtr handle, int width, int height)
    {
        if (videoWindow != null)
        {
            videoWindow.put_Owner(handle);
            videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);
            videoWindow.SetWindowPosition(0, 0, width, height);
            videoWindow.put_Visible(OABool.True);
        }
    }
    public void Play()
    {
        mediaControl?.Run();
    }
    public void Pause()
    {
        mediaControl?.Pause();
    }
    public void Stop()
    {
        mediaControl?.Stop();
    }
    public void Seek(long timeInSeconds)
    {
        if (mediaSeeking != null)
        {
            long duration;
            mediaSeeking.GetDuration(out duration);
            long seekPos = timeInSeconds * 10000000; // Convert to 100-nanosecond units
            if (seekPos <= duration)
            {
                mediaSeeking.SetPositions(ref seekPos, AMSeekingSeekingFlags.AbsolutePositioning,
                                         IntPtr.Zero, AMSeekingSeekingFlags.NoPositioning);
            }
        }
    }
    public long GetPosition()
    {
        if (mediaSeeking != null)
        {
            mediaSeeking.GetCurrentPosition(out long position);
            return position / 10000000; // Convert to seconds
        }
        return 0;
    }
    public long GetDuration()
    {
        if (mediaSeeking != null)
        {
            mediaSeeking.GetDuration(out long duration);
            return duration / 10000000; // Convert to seconds
        }
        return 0;
    }
    public void HandleGraphEvent()
    {
        if (mediaEventEx != null)
        {
            while (mediaEventEx.GetEvent(out EventCode eventCode, out IntPtr param1,
                                          out IntPtr param2, 0) == 0)
            {
                mediaEventEx.FreeEventParams(eventCode, param1, param2);
                if (eventCode == EventCode.Complete)
                {
                    PlaybackComplete?.Invoke(this, EventArgs.Empty);
                }
            }
        }
    }
    public void Dispose()
    {
        if (mediaControl != null)
        {
            mediaControl.Stop();
        }
        if (mediaEventEx != null)
        {
            mediaEventEx.SetNotifyWindow(IntPtr.Zero, 0, IntPtr.Zero);
        }
        if (videoWindow != null)
        {
            videoWindow.put_Visible(OABool.False);
            videoWindow.put_Owner(IntPtr.Zero);
        }
        FilterGraphTools.RemoveAllFilters(filterGraph);
        if (sourceFilter != null) Marshal.ReleaseComObject(sourceFilter);
        if (videoWindow != null) Marshal.ReleaseComObject(videoWindow);
        if (mediaSeeking != null) Marshal.ReleaseComObject(mediaSeeking);
        if (mediaEventEx != null) Marshal.ReleaseComObject(mediaEventEx);
        if (captureGraph != null) Marshal.ReleaseComObject(captureGraph);
        if (mediaControl != null) Marshal.ReleaseComObject(mediaControl);
        if (filterGraph != null) Marshal.ReleaseComObject(filterGraph);
    }
}
```

### Usage Example

## ``` public partial class MainForm : Form { private FFMPEGMediaPlayer player; public MainForm() { InitializeComponent(); player = new FFMPEGMediaPlayer(); } private void btnLoad_Click(object sender, EventArgs e) { OpenFileDialog dlg = new OpenFileDialog(); dlg.Filter = "Video Files|*.mp4;*.mkv;*.avi;*.mov|All Files|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { player.Initialize(panelVideo.Handle, this.Handle); player.LoadFile(dlg.FileName, enableGPU: true, enableBuffering: true); player.SetVideoWindow(panelVideo.Handle, panelVideo.Width, panelVideo.Height); player.PlaybackComplete += Player_PlaybackComplete; player.Play(); } } private void Player_PlaybackComplete(object sender, EventArgs e) { MessageBox.Show("Playback complete"); } protected override void WndProc(ref Message m) { if (m.Msg == 0x8000 + 1) // WM_GRAPHNOTIFY { player?.HandleGraphEvent(); } base.WndProc(ref m); } private void MainForm_FormClosing(object sender, FormClosingEventArgs e) { player?.Dispose(); } } ```

## Troubleshooting

### Issue: "Class not registered" Error

**Solution**: Ensure filter is registered:

```
regsvr32 VisioForge_FFMPEG_Source_x64.ax
```

### Issue: Hardware Acceleration Not Working

**Solution**: Check GPU support and drivers:

```
var settings = sourceFilter as IFFMPEGSourceSettings;
bool isEnabled;
settings.GetHWAccelerationEnabled(out isEnabled);
Console.WriteLine($"HW Acceleration: {isEnabled}");
```

### Issue: Network Stream Connection Fails

**Solution**: Increase timeout and use custom options:

```
settings.SetLoadTimeOut(60);
settings.SetCustomOption("timeout", "30000000");  // 30 seconds
settings.SetCustomOption("rtsp_transport", "tcp");
```

---

## See Also

### Documentation

- [Interface Reference](../interface-reference/) - Complete API reference
- [Deployment Guide](../../deployment/) - Filter deployment

### Code Samples

- **[GitHub Samples Repository](https://github.com/visioforge/directshow-samples)** - Complete working examples
- **[C# Sample Project](https://github.com/visioforge/directshow-samples/tree/master/FFMPEG%20Source%20Filter/dotnet/cs)** - Full-featured C# implementation
- **[VB.NET Sample Project](https://github.com/visioforge/directshow-samples/tree/master/FFMPEG%20Source%20Filter/dotnet/vbnet)** - VB.NET implementation
- **[C++ Sample Project](https://github.com/visioforge/directshow-samples/tree/master/FFMPEG%20Source%20Filter/cpp_builder)** - C++Builder implementation

### External Resources

- [FFmpeg Documentation](https://ffmpeg.org/documentation.html)
- [DirectShow Programming Guide](https://learn.microsoft.com/en-us/windows/win32/DirectShow/directshow)

### Support

- [Technical Support](https://support.visioforge.com) - Get help from VisioForge team
- [Discord Community](https://discord.com/invite/yvXUG56WCH) - Join our community

---END OF PAGE---


## FFmpeg Source DirectShow Filter - 100+ Media Formats
**URL:** https://www.visioforge.com/help/docs/directshow/ffmpeg-source-filters/
**Description:** DirectShow source filter powered by FFmpeg for decoding MP4, MKV, H.265, and 100+ formats with hardware acceleration. COM interface for C++, C#, and Delphi.
**Tags:** DirectShow, C++, Windows, Streaming
**API:** IBaseFilter, IFileSourceFilter, FFMPEGFilter, FileSource, IFFMPEGSourceSettings

# FFMPEG Source DirectShow Filter

## Introduction

The FFMPEG Source DirectShow filter enables developers to seamlessly integrate advanced media decoding and playback capabilities into any DirectShow-compatible application. This powerful component bridges the gap between complex multimedia formats and your software development needs, providing a robust foundation for building media-rich applications.

---

## Installation

Before using the code samples and integrating the filter into your application, you must first install the FFMPEG Source DirectShow Filter from the [product page](https://www.visioforge.com/ffmpeg-source-directshow-filter).

**Installation Steps**:

1. Download the SDK installer from the product page
2. Run the installer with administrative privileges
3. The installer will register the FFMPEG Source filter and deploy all necessary FFMPEG DLLs
4. Sample applications and source code will be available in the installation directory

**Note**: The filter must be properly registered on the system before it can be used in your applications. The installer handles this automatically.

---

## Key Features and Capabilities

Our filter comes bundled with all necessary FFMPEG DLLs and provides a feature-rich DirectShow filter interface that supports:

- **Extensive Format Compatibility**: Handle a wide range of video and audio formats including MP4, MKV, AVI, MOV, WMV, FLV, and many others without additional codec installations
- **Network Stream Support**: Connect to RTSP, RTMP, HTTP, UDP, and TCP streams for live media integration
- **Multiple Stream Management**: Select between video and audio streams in multi-stream media files
- **Advanced Seeking Capabilities**: Implement precise seeking functionality in your applications
- **GPU Acceleration**: Utilize hardware acceleration for optimal performance

## Implementation Examples

The SDK includes comprehensive sample applications for multiple development environments:

### Delphi Integration (Primary)

```
// Initialize the FFMPEG Source filter in Delphi using DSPack
procedure TMainForm.InitializeFFMPEGSource;
var
  FFMPEGFilter: IBaseFilter;
  FileSource: IFileSourceFilter;
begin
  // Create FFMPEG Source filter instance
  // IMPORTANT: Ensure proper COM initialization before this call
  CoCreateInstance(CLSID_FFMPEGSource, nil, CLSCTX_INPROC_SERVER,
                  IID_IBaseFilter, FFMPEGFilter);

  // Query for file source interface
  FFMPEGFilter.QueryInterface(IID_IFileSourceFilter, FileSource);

  // Load media file - can be local or network URL
  FileSource.Load('C:\media\sample.mp4', nil);

  // Add to filter graph for rendering
  FilterGraph.AddFilter(FFMPEGFilter, 'FFMPEG Source');

  // Connect to appropriate renderers or processing filters
  // FilterGraph.RenderStream(...);
end;
```

### C# Integration (.NET)

```
using System;
using System.Runtime.InteropServices;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;

// Initialize the FFMPEG Source filter in C# using DirectShowLib
public class FFMPEGSourcePlayer
{
    private IFilterGraph2 filterGraph;
    private ICaptureGraphBuilder2 captureGraph;
    private IMediaControl mediaControl;
    private IMediaSeeking mediaSeeking;
    private IMediaEventEx mediaEventEx;
    private IBaseFilter sourceFilter;
    private IBaseFilter videoRenderer;

    public void Initialize(string filename, IntPtr videoWindowHandle)
    {
        try
        {
            // Create the filter graph manager
            filterGraph = (IFilterGraph2)new FilterGraph();
            captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
            mediaControl = (IMediaControl)filterGraph;
            mediaSeeking = (IMediaSeeking)filterGraph;
            mediaEventEx = (IMediaEventEx)filterGraph;

            // Attach the filter graph to the capture graph
            int hr = captureGraph.SetFiltergraph(filterGraph);
            DsError.ThrowExceptionForHR(hr);

            // Create the FFMPEG Source filter using the correct CLSID
            sourceFilter = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFFFMPEGSource,
                "FFMPEG Source");

            // Optional: Register purchased version
            // var reg = sourceFilter as IVFRegister;
            // reg?.SetLicenseKey("your-license-key-here");

            // Configure filter settings
            var filterConfig = sourceFilter as IFFMPEGSourceSettings;
            if (filterConfig != null)
            {
                // Set buffering mode (AUTO, ON, or OFF)
                filterConfig.SetBufferingMode(FFMPEG_SOURCE_BUFFERING_MODE.FFMPEG_SOURCE_BUFFERING_MODE_AUTO);

                // Enable hardware acceleration (GPU decoding)
                filterConfig.SetHWAccelerationEnabled(true);

                // Set connection timeout (milliseconds)
                filterConfig.SetLoadTimeOut(30000);
            }

            // Load the media file or network stream
            var sourceFilterIntf = sourceFilter as IFileSourceFilter;
            hr = sourceFilterIntf.Load(filename, null);
            DsError.ThrowExceptionForHR(hr);

            // Create video renderer (EVR - Enhanced Video Renderer)
            Guid CLSID_EVR = new Guid("FA10746C-9B63-4B6C-BC49-FC300EA5F256");
            videoRenderer = FilterGraphTools.AddFilterFromClsid(filterGraph, CLSID_EVR, "EVR");

            // Configure EVR
            var evrConfig = videoRenderer as MediaFoundation.EVR.IEVRFilterConfig;
            evrConfig?.SetNumberOfStreams(1);

            // Set video window for rendering
            var getService = videoRenderer as MediaFoundation.IMFGetService;
            if (getService != null)
            {
                getService.GetService(
                    MediaFoundation.MFServices.MR_VIDEO_RENDER_SERVICE,
                    typeof(MediaFoundation.IMFVideoDisplayControl).GUID,
                    out var videoDisplayControlObj);

                var videoDisplayControl = videoDisplayControlObj as MediaFoundation.IMFVideoDisplayControl;
                videoDisplayControl?.SetVideoWindow(videoWindowHandle);
            }

            // Render the streams
            hr = captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, videoRenderer);
            DsError.ThrowExceptionForHR(hr);

            hr = captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);
            // Note: Audio rendering errors are not critical for video-only playback

            // Start playback
            hr = mediaControl.Run();
            DsError.ThrowExceptionForHR(hr);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error initializing FFMPEG Source: {ex.Message}");
            Cleanup();
            throw;
        }
    }

    public void Cleanup()
    {
        // Stop playback
        if (mediaControl != null)
        {
            mediaControl.StopWhenReady();
            mediaControl.Stop();
        }

        // Stop receiving events
        mediaEventEx?.SetNotifyWindow(IntPtr.Zero, 0, IntPtr.Zero);

        // Remove all filters
        FilterGraphTools.RemoveAllFilters(filterGraph);

        // Release DirectShow interfaces
        if (mediaControl != null)
        {
            Marshal.ReleaseComObject(mediaControl);
            mediaControl = null;
        }

        if (mediaSeeking != null)
        {
            Marshal.ReleaseComObject(mediaSeeking);
            mediaSeeking = null;
        }

        if (mediaEventEx != null)
        {
            Marshal.ReleaseComObject(mediaEventEx);
            mediaEventEx = null;
        }

        if (sourceFilter != null)
        {
            Marshal.ReleaseComObject(sourceFilter);
            sourceFilter = null;
        }

        if (videoRenderer != null)
        {
            Marshal.ReleaseComObject(videoRenderer);
            videoRenderer = null;
        }

        if (filterGraph != null)
        {
            Marshal.ReleaseComObject(filterGraph);
            filterGraph = null;
        }

        if (captureGraph != null)
        {
            Marshal.ReleaseComObject(captureGraph);
            captureGraph = null;
        }
    }
}
```

**Key CLSIDs and GUIDs:**

```
// FFMPEG Source Filter CLSID — same value used across the C# / C++ samples and
// the registry registration in ../deployment/filter-registration.md.
public static readonly Guid CLSID_VFFFMPEGSource = new Guid("1974D893-83E4-4F89-9908-795C524CC17E");

// IFFMPEGSourceSettings interface — for the canonical IID see the interface header
// (`IFFmpegSourceSettings.h` / `IFFmpegSourceSettings.cs`) linked from
// [interface-reference.md](./interface-reference.md). The interface IID is distinct
// from the filter CLSID above (a single GUID cannot serve as both).
public interface IFFMPEGSourceSettings { /* ... */ }

// IVFRegister Interface IID (for licensing)
[Guid("59E82754-B531-4A8E-A94D-57C75F01DA30")]
public interface IVFRegister { /* ... */ }
```

**Required NuGet Packages:**

- `VisioForge.DirectShowAPI` - DirectShow wrapper library
- `MediaFoundation.Net` - Media Foundation wrapper for EVR renderer

**Stream Selection Example:**

```
// Select specific video or audio streams in multi-stream files
var streamSelect = sourceFilter as IAMStreamSelect;
if (streamSelect != null)
{
    streamSelect.Count(out int streamCount);

    for (int i = 0; i < streamCount; i++)
    {
        streamSelect.Info(i, out var mediaType, out _, out _, out _, out var name, out _, out _);

        if (mediaType.majorType == MediaType.Video)
        {
            // Enable the first video stream
            streamSelect.Enable(i, AMStreamSelectEnableFlags.Enable);
            break;
        }
    }
}
```

### C++ Integration Example

```
// Initialize the FFMPEG Source filter in C++ using DirectShow
HRESULT InitializeFFMPEGSource()
{
    HRESULT hr = S_OK;
    IGraphBuilder* pGraph = NULL;
    IMediaControl* pControl = NULL;
    IBaseFilter* pFFMPEGSource = NULL;
    IFileSourceFilter* pFileSource = NULL;

    // Initialize COM
    CoInitialize(NULL);

    // Create the filter graph manager
    hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
                         IID_IGraphBuilder, (void**)&pGraph);
    if (FAILED(hr))
        return hr;

    // Create the FFMPEG Source filter
    hr = CoCreateInstance(CLSID_FFMPEGSource, NULL, CLSCTX_INPROC_SERVER,
                         IID_IBaseFilter, (void**)&pFFMPEGSource);
    if (FAILED(hr))
        goto cleanup;

    // Add the filter to the graph
    hr = pGraph->AddFilter(pFFMPEGSource, L"FFMPEG Source");
    if (FAILED(hr))
        goto cleanup;

    // Get the IFileSourceFilter interface
    hr = pFFMPEGSource->QueryInterface(IID_IFileSourceFilter, (void**)&pFileSource);
    if (FAILED(hr))
        goto cleanup;

    // Load the media file
    hr = pFileSource->Load(L"C:\\media\\sample.mp4", NULL);
    if (FAILED(hr))
        goto cleanup;

    // Render the output pins of the FFMPEG Source filter
    hr = pGraph->Render(GetPin(pFFMPEGSource, PINDIR_OUTPUT, 0));

    // Get the media control interface for playback control
    hr = pGraph->QueryInterface(IID_IMediaControl, (void**)&pControl);
    if (SUCCEEDED(hr))
    {
        // Start playback
        hr = pControl->Run();
        // ... handle playback as needed
    }

cleanup:
    // Release interfaces
    if (pControl) pControl->Release();
    if (pFileSource) pFileSource->Release();
    if (pFFMPEGSource) pFFMPEGSource->Release();
    if (pGraph) pGraph->Release();

    return hr;
}

// Helper function to get pins from a filter
IPin* GetPin(IBaseFilter* pFilter, PIN_DIRECTION PinDir, int nPin)
{
    IEnumPins* pEnum = NULL;
    IPin* pPin = NULL;

    if (pFilter)
    {
        pFilter->EnumPins(&pEnum);
        if (pEnum)
        {
            while (pEnum->Next(1, &pPin, NULL) == S_OK)
            {
                PIN_DIRECTION PinDirThis;
                pPin->QueryDirection(&PinDirThis);
                if (PinDir == PinDirThis)
                {
                    if (nPin == 0)
                        break;
                    nPin--;
                }
                pPin->Release();
                pPin = NULL;
            }
            pEnum->Release();
        }
    }

    return pPin;
}
```

## Integration with Processing Filters

Enhance your media pipeline by connecting the FFMPEG Source filter with additional processing components:

- Apply real-time video effects and transformations
- Process audio streams for custom sound manipulation
- Implement specialized media analysis features

Our [Processing Filters pack](https://www.visioforge.com/processing-filters-pack) offers additional capabilities, or you can integrate with any standard DirectShow-compatible filters.

## Technical Specifications

### Supported DirectShow Interfaces

The filter implements these standard DirectShow interfaces for maximum compatibility:

- **IAMStreamSelect**: Select between multiple video and audio streams
- **IAMStreamConfig**: Configure video and audio settings
- **IFileSourceFilter**: Set filename or streaming URL
- **IMediaSeeking**: Implement precise seeking functionality
- **ISpecifyPropertyPages**: Access configuration through property pages

## Version History and Updates

### Version 15.0

- Enhanced FFMPEG libraries with latest codecs
- Added GPU decoding support for improved performance
- Optimized memory management for large files

### Version 12.0

- Updated FFMPEG libraries
- Improved compatibility with Windows 10/11

### Version 11.0

- Updated FFMPEG libraries
- Fixed seeking issues with certain file formats

### Version 10.0

- Updated FFMPEG libraries
- Added support for additional container formats

### Version 9.0

- Updated FFMPEG libraries
- Performance optimizations

### Version 8.0

- Updated FFMPEG libraries
- Improved error handling

### Version 7.0

- Initial release as an independent product
- Core functionality established

## Additional Resources

- Explore our [product page](https://www.visioforge.com/ffmpeg-source-directshow-filter) for detailed specifications
- View our [End User License Agreement](../../eula/) for licensing details
- Check our developer documentation for advanced implementation scenarios

---END OF PAGE---


## FFmpeg Source DirectShow Filter Interface API Reference
**URL:** https://www.visioforge.com/help/docs/directshow/ffmpeg-source-filters/interface-reference/
**Description:** IFFmpegSourceSettings interface with hardware acceleration, buffering modes, custom FFmpeg options, and callbacks for DirectShow.
**Tags:** DirectShow, C++, Windows, Streaming, Decoding, RTSP, C#
**API:** IFFmpegSourceSettings, IFileSourceFilter, IFFMPEGSourceSettings

# IFFMPEGSourceSettings Interface Reference

## Overview

The `IFFMPEGSourceSettings` interface provides advanced configuration options for the FFMPEG Source DirectShow filter. This interface enables developers to control hardware acceleration, buffering behavior, custom FFmpeg options, and various callbacks for media playback.

> The .NET / C++ / Delphi headers spell this interface `IFFMPEGSourceSettings` (all uppercase `FFMPEG`). The legacy header file paths `IFFmpegSourceSettings.h` / `.cs` keep the historical mixed-case filename — but the symbol exposed by all three languages is the all-caps form. The two are equivalent identifiers in C#; this page uses the all-caps form consistently with examples.md / index.md.

## Interface Definition

- **Interface Name**: `IFFMPEGSourceSettings`
- **Filter CLSID it queries through**: `{1974D893-83E4-4F89-9908-795C524CC17E}` (the FFMPEG Source filter — the interface IID itself is distinct; consult the header).
- **Inherits From**: `IUnknown`

### Interface Definition Files

Complete interface definitions are available on GitHub:

- **C# (.NET)**: [IFFmpegSourceSettings.cs](https://github.com/visioforge/directshow-samples/blob/main/Interfaces/dotnet/IFFmpegSourceSettings.cs)
- **C++ Header**: [IFFmpegSourceSettings.h](https://github.com/visioforge/directshow-samples/blob/main/Interfaces/cpp/FFMPEG%20Source/IFFmpegSourceSettings.h)
- **Delphi**: [VCFiltersAPI.pas](https://github.com/visioforge/directshow-samples/blob/main/Interfaces/delphi/VCFiltersAPI.pas) (search for `IFFMPEGSourceSettings`)

All interface definitions include:

- Complete method signatures with proper marshalling attributes
- Callback delegate definitions
- Enumeration types (buffering modes, media types)
- Usage documentation and examples

## Methods Reference

### Hardware Acceleration

#### GetHWAccelerationEnabled

Retrieves the current hardware acceleration state.

**Syntax (C++)**:

```
BOOL GetHWAccelerationEnabled();
```

**Syntax (C#)**:

```
[PreserveSig]
bool GetHWAccelerationEnabled();
```

**Returns**: `TRUE` if hardware acceleration is enabled, `FALSE` otherwise.

**Default**: `TRUE`

---

#### SetHWAccelerationEnabled

Enables or disables hardware video decoding acceleration. **Syntax (C++)**:

```
HRESULT SetHWAccelerationEnabled(BOOL enabled);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetHWAccelerationEnabled([MarshalAs(UnmanagedType.Bool)] bool enabled);
```

**Parameters**: - `enabled`: Set to `TRUE` to enable hardware acceleration, `FALSE` to disable. **Returns**: `S_OK` (0) on success, error code otherwise. **Usage Notes**: - Must be called **before** connecting downstream video filters - When enabled, the filter attempts to use hardware decoding (DXVA, NVDEC, QuickSync, etc.) - Falls back to software decoding if hardware acceleration is unavailable - Hardware acceleration significantly improves performance for H.264, H.265, VP9, and AV1 codecs **Example (C++)**:

```
IFFmpegSourceSettings* pSettings = nullptr;
pFilter->QueryInterface(IID_IFFmpegSourceSettings, (void**)&pSettings);
// Enable hardware acceleration
pSettings->SetHWAccelerationEnabled(TRUE);
pSettings->Release();
```

**Example (C#)**:

```
var settings = filter as IFFmpegSourceSettings;
if (settings != null)
{
    // Enable hardware acceleration
    settings.SetHWAccelerationEnabled(true);
}
```

---

### Load Timeout Configuration

#### GetLoadTimeOut

Retrieves the current source loading timeout value.

**Syntax (C++)**:

```
DWORD GetLoadTimeOut();
```

**Syntax (C#)**:

```
[PreserveSig]
uint GetLoadTimeOut();
```

**Returns**: Timeout value in milliseconds.

**Default**: `15000` (15 seconds)

---

#### SetLoadTimeOut

Sets the timeout duration for source loading operations. **Syntax (C++)**:

```
HRESULT SetLoadTimeOut(DWORD milliseconds);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetLoadTimeOut(uint milliseconds);
```

**Parameters**: - `milliseconds`: Timeout duration in milliseconds. **Returns**: `S_OK` (0) on success. **Usage Notes**: - Must be called **before** loading the source file/URL - Particularly important for network streams that may have slow connection times - Set higher values for slow network connections or large files - Set lower values to fail fast on unreachable sources **Example (C++)**:

```
// Set 30-second timeout for network streams
pSettings->SetLoadTimeOut(30000);
// Load RTSP stream
IFileSourceFilter* pFileSource = nullptr;
pFilter->QueryInterface(IID_IFileSourceFilter, (void**)&pFileSource);
pFileSource->Load(L"rtsp://example.com/stream", nullptr);
```

---

### Buffering Configuration

#### GetBufferingMode

Retrieves the current buffering mode.

**Syntax (C++)**:

```
FFMPEG_SOURCE_BUFFERING_MODE GetBufferingMode();
```

**Syntax (C#)**:

```
[PreserveSig]
FFMPEG_SOURCE_BUFFERING_MODE GetBufferingMode();
```

**Returns**: Current buffering mode (see enumeration below).

**Default**: `FFMPEG_SOURCE_BUFFERING_MODE_AUTO`

---

#### SetBufferingMode

Sets the buffering mode for live sources. **Syntax (C++)**:

```
HRESULT SetBufferingMode(FFMPEG_SOURCE_BUFFERING_MODE mode);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetBufferingMode(FFMPEG_SOURCE_BUFFERING_MODE mode);
```

**Parameters**: - `mode`: Buffering mode to use. **Returns**: `S_OK` (0) on success. **Usage Notes**: - Must be called **before** loading the source - Affects latency and stability for live streams **Buffering Modes**: | Mode | Value | Description | Use Case | |------|-------|-------------|----------| | `FFMPEG_SOURCE_BUFFERING_MODE_AUTO` | 0 | Automatically detect if buffering is needed | Default - recommended for most scenarios | | `FFMPEG_SOURCE_BUFFERING_MODE_ON` | 1 | Force buffering enabled | Use for unstable network streams | | `FFMPEG_SOURCE_BUFFERING_MODE_OFF` | 2 | Force buffering disabled | Use for low-latency live streams | **Example (C++)**:

```
// Disable buffering for low-latency RTSP stream
pSettings->SetBufferingMode(FFMPEG_SOURCE_BUFFERING_MODE_OFF);
pSettings->SetLoadTimeOut(5000); // 5-second timeout
```

**Example (C#)**:

```
// Enable buffering for unstable network
settings.SetBufferingMode(FFMPEG_SOURCE_BUFFERING_MODE.ON);
```

---

### Custom FFmpeg Options

#### SetCustomOption

Sets a custom FFmpeg option for the demuxer or decoder.

**Syntax (C++)**:

```
HRESULT SetCustomOption(LPSTR name, LPSTR value);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetCustomOption([MarshalAs(UnmanagedType.LPStr)] string name,
                     [MarshalAs(UnmanagedType.LPStr)] string value);
```

**Parameters**:

- `name`: Option name (ASCII string).
- `value`: Option value (ASCII string).

**Returns**: `S_OK` (0) on success.

**Usage Notes**:

- Must be called **before** loading the source
- Allows passing any FFmpeg AVFormatContext or AVCodecContext option
- Options are passed directly to FFmpeg libraries
- Invalid options are ignored with a warning

**Common Options**:

| Option | Value | Description |
| --- | --- | --- |
| `rtsp_transport` | `tcp` or `udp` | Force RTSP transport protocol |
| `timeout` | Microseconds | Network timeout for protocols |
| `buffer_size` | Bytes | Input buffer size |
| `analyzeduration` | Microseconds | Duration to analyze stream |
| `probesize` | Bytes | Size of data to probe |
| `fflags` | `nobuffer` | Disable buffering |
| `threads` | Number | Decoder thread count |

**Example (C++)**:

```
// Configure RTSP to use TCP transport
pSettings->SetCustomOption("rtsp_transport", "tcp");

// Set network timeout to 5 seconds
pSettings->SetCustomOption("timeout", "5000000"); // 5 seconds in microseconds

// Increase probe size for better format detection
pSettings->SetCustomOption("probesize", "10000000"); // 10MB
```

**Example (C#)**:

```
// Low-latency configuration
settings.SetCustomOption("fflags", "nobuffer");
settings.SetCustomOption("flags", "low_delay");
settings.SetCustomOption("probesize", "32");
```

---

#### ClearCustomOptions

Clears all previously set custom options. **Syntax (C++)**:

```
HRESULT ClearCustomOptions();
```

**Syntax (C#)**:

```
[PreserveSig]
int ClearCustomOptions();
```

**Returns**: `S_OK` (0) on success. **Usage Notes**: - Must be called **before** loading the source - Resets all custom options to FFmpeg defaults **Example (C++)**:

```
pSettings->ClearCustomOptions();
```

---

### Callback Configuration

#### SetDataCallback

Sets a callback function to receive decoded video/audio data.

**Syntax (C++)**:

```
HRESULT SetDataCallback(FFMPEGDataCallbackDelegate callback);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetDataCallback([MarshalAs(UnmanagedType.FunctionPtr)] FFMPEGDataCallbackDelegate callback);
```

**Parameters**:

- `callback`: Pointer to callback function.

**Returns**: `S_OK` (0) on success.

**Callback Signature (C++)**:

```
typedef HRESULT(_stdcall* FFMPEGDataCallbackDelegate) (
    BYTE* buffer,        // Pointer to data buffer
    int bufferLen,       // Buffer length in bytes
    int dataType,        // 0 = video, 1 = audio
    LONGLONG startTime,  // Start timestamp (100-nanosecond units)
    LONGLONG stopTime    // Stop timestamp (100-nanosecond units)
);
```

**Usage Notes**:

- Callback is invoked for each decoded frame/audio sample
- Called from filter's streaming thread - keep processing minimal
- Buffer data is valid only during callback execution
- Return `S_OK` from callback to continue processing

**Example (C++)**:

```
HRESULT __stdcall DataCallback(BYTE* buffer, int bufferLen, int dataType,
                                LONGLONG startTime, LONGLONG stopTime)
{
    if (dataType == 0) // Video
    {
        // Process video frame
        ProcessVideoFrame(buffer, bufferLen, startTime);
    }
    else // Audio
    {
        // Process audio data
        ProcessAudioData(buffer, bufferLen);
    }
    return S_OK;
}

// Set callback
pSettings->SetDataCallback(&DataCallback);
```

---

#### SetTimestampCallback

Sets a callback function to receive timestamp information. **Syntax (C++)**:

```
HRESULT SetTimestampCallback(FFMPEGTimestampCallbackDelegate callback);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetTimestampCallback([MarshalAs(UnmanagedType.FunctionPtr)] FFMPEGTimestampCallbackDelegate callback);
```

**Parameters**: - `callback`: Pointer to callback function. **Returns**: `S_OK` (0) on success. **Callback Signature (C++)**:

```
typedef HRESULT(_stdcall* FFMPEGTimestampCallbackDelegate) (
    int mediaType,              // 0 = video, 1 = audio
    __int64 demuxerStartTime,   // Demuxer start time
    __int64 streamStartTime,    // Stream start time
    __int64 timestamp           // Current timestamp
);
```

**Usage Notes**: - Useful for timestamp analysis and synchronization debugging - Called for each decoded frame/sample

---

### Audio Control

#### SetAudioEnabled

Enables or disables audio stream processing.

**Syntax (C++)**:

```
HRESULT SetAudioEnabled(BOOL enabled);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetAudioEnabled([MarshalAs(UnmanagedType.Bool)] bool enabled);
```

**Parameters**:

- `enabled`: Set to `TRUE` to enable audio, `FALSE` to disable.

**Returns**: `S_OK` (0) on success.

**Usage Notes**:

- Must be called **before** loading the source
- When disabled, audio streams are not decoded (saves CPU/memory)
- Useful for video-only applications

**Example (C++)**:

```
// Disable audio for video-only processing
pSettings->SetAudioEnabled(FALSE);
```

## Related Interfaces

- **IFileSourceFilter** - Standard DirectShow interface for loading files/URLs
- **IAMStreamSelect** - Select between multiple audio/video streams
- **IMediaSeeking** - Seek to specific positions in the media
- **IAMStreamConfig** - Configure video/audio format

## See Also

### Documentation

- [FFMPEG Source Filter Overview](../) - Product overview and features
- [Code Examples](../examples/) - Complete working code samples

### Interface Definitions

- [C# Interface (.NET)](https://github.com/visioforge/directshow-samples/blob/main/Interfaces/dotnet/IFFmpegSourceSettings.cs) - Complete .NET interface definition
- [C++ Interface Header](https://github.com/visioforge/directshow-samples/blob/main/Interfaces/cpp/FFMPEG%20Source/IFFmpegSourceSettings.h) - C++ header file
- [Delphi Interface](https://github.com/visioforge/directshow-samples/blob/main/Interfaces/delphi/VCFiltersAPI.pas) - Delphi interface definition

### Working Samples

- [GitHub Samples Repository](https://github.com/visioforge/directshow-samples) - Complete working examples for all platforms

### External Resources

- [FFmpeg Documentation](https://ffmpeg.org/documentation.html) - FFmpeg library documentation
- [DirectShow SDK](https://learn.microsoft.com/en-us/windows/win32/DirectShow/directshow) - Microsoft DirectShow documentation

---END OF PAGE---


## DirectShow Encoding Codecs - H.264, H.265, AAC, and More
**URL:** https://www.visioforge.com/help/docs/directshow/filters-enc/codecs-reference/
**Description:** DirectShow codec reference with H.264/H.265/VP8/VP9 video, AAC/MP3/Opus audio, and hardware acceleration (NVENC, QuickSync, AMF).
**Tags:** DirectShow, C++, Windows, Streaming, Encoding, MKV, WebM, TS, H.264, H.265, VP8, VP9, MPEG-2, AAC, MP3, Opus, FLAC, Vorbis, Speex

# Encoding Filters Pack - Codecs Reference

## Overview

This document provides a comprehensive reference for all video and audio codecs supported by the DirectShow Encoding Filters Pack. The pack includes both software and hardware-accelerated encoders for professional media encoding.

---

## Video Codecs

### H.264/AVC (MPEG-4 Part 10)

The most widely used video codec for streaming, broadcasting, and file storage.

#### Encoder Options

| Encoder Type | Description | Hardware Support | Performance | Quality |
| --- | --- | --- | --- | --- |
| **Software (x264)** | CPU-based H.264 encoder | None | Moderate | Excellent |
| **NVENC** | NVIDIA GPU encoder | NVIDIA GPUs (Kepler+) | Very Fast | Good-Excellent |
| **QuickSync** | Intel integrated graphics | Intel CPUs (2nd gen+) | Fast | Good |
| **AMD AMF** | AMD GPU encoder | AMD GPUs (GCN+) | Fast | Good |
| **Media Foundation** | Windows MF encoder | Various (OS-dependent) | Moderate | Good |
| #### Profiles and Levels |  |  |  |  |
| **Profiles**: |  |  |  |  |
| - **Baseline** - Basic features, mobile devices |  |  |  |  |
| - **Main** - Standard features, most applications |  |  |  |  |
| - **High** - Advanced features, HD content, Blu-ray |  |  |  |  |
| **Common Levels**: |  |  |  |  |
| - **Level 3.0** - SD (720x480 @ 30 fps) |  |  |  |  |
| - **Level 3.1** - 720p (1280x720 @ 30 fps) |  |  |  |  |
| - **Level 4.0** - 1080p (1920x1080 @ 30 fps) |  |  |  |  |
| - **Level 4.1** - 1080p @ 60 fps |  |  |  |  |
| - **Level 5.0** - 4K (3840x2160 @ 30 fps) |  |  |  |  |
| - **Level 5.1** - 4K @ 60 fps |  |  |  |  |
| #### Rate Control Modes |  |  |  |  |
| Mode | Description | Use Case | Bitrate Behavior |  |
| ------ | ------------- | ---------- | ------------------ |  |
| **CBR** | Constant Bitrate | Streaming, broadcasting | Fixed bitrate |  |
| **VBR** | Variable Bitrate | File storage | Varies based on complexity |  |
| **CQP** | Constant Quantization | High quality archival | Varies significantly |  |
| #### Recommended Settings |  |  |  |  |
| **Streaming (1080p @ 30fps)**: |  |  |  |  |
| - Bitrate: 4-6 Mbps |  |  |  |  |
| - Profile: High |  |  |  |  |
| - Level: 4.0 |  |  |  |  |
| - GOP Size: 60 (2 seconds) |  |  |  |  |
| - B-frames: 2 |  |  |  |  |
| **Recording (1080p @ 60fps)**: |  |  |  |  |
| - Bitrate: 8-12 Mbps |  |  |  |  |
| - Profile: High |  |  |  |  |
| - Level: 4.1 |  |  |  |  |
| - GOP Size: 120 (2 seconds) |  |  |  |  |
| - B-frames: 3 |  |  |  |  |
| **Low Latency Streaming**: |  |  |  |  |
| - Bitrate: 2-4 Mbps |  |  |  |  |
| - Profile: Main |  |  |  |  |
| - Level: 3.1 |  |  |  |  |
| - GOP Size: 30 (1 second) |  |  |  |  |
| - B-frames: 0 |  |  |  |  |
| --- |  |  |  |  |

### H.265/HEVC (High Efficiency Video Coding)

Next-generation codec offering 40-50% better compression than H.264.

#### Encoder Options

| Encoder Type | Description | Hardware Support | Performance | Quality |
| --- | --- | --- | --- | --- |
| **Software (x265)** | CPU-based HEVC encoder | None | Slow | Excellent |
| **NVENC** | NVIDIA GPU encoder | NVIDIA GPUs (Maxwell+) | Fast | Good-Excellent |
| **QuickSync** | Intel integrated graphics | Intel CPUs (6th gen+) | Fast | Good |
| **AMD AMF** | AMD GPU encoder | AMD GPUs (Fiji+) | Fast | Good |

#### Profiles and Tiers

**Profiles**: - **Main** - 8-bit, 4:2:0, standard use - **Main 10** - 10-bit, HDR support - **Main Still Picture** - Single images

**Tiers**: - **Main Tier** - Standard applications - **High Tier** - Professional/broadcast

**Common Levels**: - **Level 3.1** - 720p @ 30 fps - **Level 4.0** - 1080p @ 30 fps - **Level 4.1** - 1080p @ 60 fps - **Level 5.0** - 4K @ 30 fps - **Level 5.1** - 4K @ 60 fps

#### Recommended Settings

**4K Streaming (2160p @ 30fps)**: - Bitrate: 15-20 Mbps - Profile: Main - Level: 5.0 - GOP Size: 60 - Tile Encoding: Enabled

**1080p High Quality**: - Bitrate: 3-5 Mbps - Profile: Main or Main 10 - Level: 4.0 - GOP Size: 90

---

### VP8

Google's open-source video codec, primarily for WebM containers.

#### Features

- **License**: Royalty-free, open source
- **Container**: WebM (preferred), MKV
- **Hardware Support**: Limited
- **Quality**: Good at medium-high bitrates
- **Complexity**: Moderate encoding time

#### Recommended Settings

**WebM Streaming (720p)**: - Bitrate: 1-2 Mbps - GOP Size: 120 - Quality: Good (0-63 scale, lower is better) - Threads: Auto

---

### VP9

Successor to VP8 with significantly improved compression efficiency.

#### Features

- **License**: Royalty-free, open source
- **Container**: WebM (primary), MKV
- **Hardware Support**: Recent GPUs (Intel, NVIDIA, AMD)
- **Quality**: Comparable to H.265
- **Complexity**: Very high (software), moderate (hardware)

#### 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

#### Recommended Settings

**YouTube/WebM (1080p @ 30fps)**: - Bitrate: 2-4 Mbps - Quality/Speed: 1 (fastest), 0 (slowest/best) - GOP Size: 60 - Tile Columns: 2

---

### MPEG-2

Legacy codec still used for DVDs and broadcasting.

#### Features

- **License**: Requires license
- **Container**: MPEG-PS, MPEG-TS, VOB
- **Hardware Support**: Universal
- **Quality**: Good but requires higher bitrates
- **Use Cases**: DVD authoring, broadcasting

#### Common Variants

- **MPEG-2 DVD** - 4-8 Mbps, 720x480/720x576
- **MPEG-2 SVCD** - 2.5 Mbps, 480x480/480x576
- **MPEG-2 HD** - 15-25 Mbps, 1920x1080

#### Recommended Settings

**DVD Video (NTSC)**: - Resolution: 720x480 - Bitrate: 6 Mbps - GOP Size: 15 (NTSC) or 12 (PAL) - Aspect Ratio: 16:9 or 4:3

---

### MPEG-4 Part 2

Older MPEG-4 Visual codec (DivX/Xvid era).

#### Features

- **License**: Requires license
- **Container**: AVI, MP4, MKV
- **Quality**: Moderate
- **Use Cases**: Legacy content, low-power devices

#### Recommended Settings

**Standard Definition**: - Resolution: 640x480 - Bitrate: 1-2 Mbps - GOP Size: 250

---

## Audio Codecs

### AAC (Advanced Audio Coding)

Industry-standard audio codec for most applications.

#### Encoder Options

| Encoder Type | Description | Quality | Performance |
| --- | --- | --- | --- |
| **FFmpeg AAC** | Software encoder | Good | Fast |
| **Media Foundation AAC** | Windows built-in | Good | Fast |
| **FAAC** | Open-source encoder | Moderate | Fast |
| #### Profiles |  |  |  |
| - **AAC-LC (Low Complexity)** - Standard, most compatible |  |  |  |
| - **HE-AAC (High Efficiency)** - Better at low bitrates |  |  |  |
| - **HE-AAC v2** - Even better for very low bitrates |  |  |  |
| #### Recommended Bitrates |  |  |  |
| Quality | Stereo | 5.1 Surround |  |
| --------- | -------- | -------------- |  |
| **Low** | 64-96 kbps | 192 kbps |  |
| **Medium** | 128 kbps | 256 kbps |  |
| **High** | 192 kbps | 384 kbps |  |
| **Very High** | 256-320 kbps | 448-640 kbps |  |
| #### Sample Rates |  |  |  |
| - **44.1 kHz** - CD quality, music |  |  |  |
| - **48 kHz** - Professional audio, video |  |  |  |
| - **32 kHz** - Lower quality (voice) |  |  |  |
| --- |  |  |  |

### MP3 (MPEG-1/2 Audio Layer III)

Legacy but still widely used audio codec.

#### Encoder Options

- **LAME** - Excellent quality open-source encoder
- **FFmpeg MP3** - Built-in encoder

#### Bitrate Modes

| Mode | Description | File Size | Quality |
| --- | --- | --- | --- |
| **CBR** | Constant Bitrate | Predictable | Consistent |
| **VBR** | Variable Bitrate | Smaller | Better |
| **ABR** | Average Bitrate | Balanced | Good |

#### Recommended Settings

**Music (High Quality)**: - Mode: VBR - Quality: V0-V2 (LAME scale) - Approximate Bitrate: 190-245 kbps - Sample Rate: 44.1 kHz

**Podcast/Speech**: - Mode: CBR - Bitrate: 96-128 kbps - Sample Rate: 44.1 kHz

**Low Bandwidth**: - Mode: VBR - Quality: V5-V6 - Approximate Bitrate: 120-150 kbps

---

### Vorbis

Open-source alternative to MP3 and AAC.

#### Features

- **License**: Completely free, no patents
- **Container**: OGG (primary), WebM, MKV
- **Quality**: Excellent, especially at low-mid bitrates
- **Compatibility**: Good but not universal

#### Recommended Settings

**Music (High Quality)**: - Quality: 6-8 (0-10 scale) - Approximate Bitrate: 192-256 kbps - Sample Rate: 44.1 kHz or 48 kHz **Streaming**: - Quality: 4-5 - Approximate Bitrate: 128-160 kbps

---

### Opus

Modern, highly efficient codec for both speech and music.

#### Features

- **License**: Royalty-free, standardized (RFC 6716)
- **Container**: WebM, MKV, OGG
- **Latency**: Extremely low (5-66.5 ms)
- **Bitrate Range**: 6-510 kbps
- **Quality**: Superior to MP3, AAC, Vorbis

#### Applications

- **VoIP/Voice Chat**: 8-24 kbps
- **Music Streaming**: 64-128 kbps
- **High Fidelity**: 128-256 kbps

#### Recommended Settings

**Voice Chat**: - Bitrate: 16-24 kbps - Sample Rate: 16 kHz or 48 kHz - Application: VoIP

**Music**: - Bitrate: 96-160 kbps - Sample Rate: 48 kHz - Application: Audio

---

### FLAC (Free Lossless Audio Codec)

Lossless audio compression.

#### Features

- **License**: Open source, royalty-free
- **Compression**: Typically 40-60% of original
- **Quality**: Bit-perfect lossless
- **Compatibility**: Good and improving

#### Compression Levels

- **Level 0** - Fastest, ~50% compression
- **Level 5** - Default, ~55% compression
- **Level 8** - Slowest, ~60% compression

#### Recommended Settings

**Archival**: - Compression Level: 5-8 - Sample Rate: Original (typically 44.1 or 48 kHz) - Bit Depth: Original (16 or 24-bit) **Streaming**: - Compression Level: 0-3 - Sample Rate: 44.1 or 48 kHz

---

### Speex

Specialized codec for voice compression.

#### Features

- **License**: Open source (BSD)
- **Purpose**: Speech compression (not music)
- **Bitrate**: 2-44 kbps
- **Quality**: Optimized for voice

#### Modes

- **Narrowband** (8 kHz) - Phone quality, 2.15-24.6 kbps
- **Wideband** (16 kHz) - Better clarity, 4-44 kbps
- **Ultra-wideband** (32 kHz) - Full speech spectrum

#### Recommended Settings

**VoIP**: - Mode: Wideband - Quality: 6-8 (0-10 scale) - Bitrate: ~15-20 kbps

---

## Hardware Acceleration Overview

### NVIDIA NVENC

**Supported Codecs**: - H.264/AVC (all NVIDIA GPUs from Kepler generation) - H.265/HEVC (Maxwell generation and newer) **Generations**: - **Kepler** (GTX 600/700) - 1st gen, basic H.264 - **Maxwell** (GTX 900) - 2nd gen, HEVC support - **Pascal** (GTX 10XX) - 3rd gen, improved quality - **Turing/Ampere** (RTX 20XX/30XX) - 7th/8th gen, excellent quality **Performance**: Up to 8K @ 30 fps (GPU dependent) **Quality Settings**: - Preset: P1 (fastest) to P7 (slowest, best quality) - Recommended: P4-P6 for balanced quality/speed

---

### Intel QuickSync

**Supported Codecs**: - H.264/AVC (2nd gen Core and newer) - H.265/HEVC (6th gen Core and newer) - VP9 (9th gen Core and newer)

**Generations**: - **Sandy Bridge** (2nd gen) - H.264 support - **Skylake** (6th gen) - HEVC support - **Ice Lake** (10th gen mobile) - Improved quality - **Rocket Lake** (11th gen) - Enhanced features

**Performance**: Up to 4K @ 60 fps

**Quality**: Good, improving with each generation

---

### AMD AMF (Advanced Media Framework)

**Supported Codecs**: - H.264/AVC (GCN 1.0 and newer) - H.265/HEVC (Fiji/Polaris and newer) **Generations**: - **GCN 1-4** (R7/R9, RX 400/500) - H.264 only - **Vega** (RX Vega) - HEVC support - **RDNA** (RX 5000/6000) - Improved quality **Performance**: Up to 4K @ 60 fps **Quality**: Good, competitive with QuickSync

---

## Codec Selection Guide

### For Streaming (Live)

**Recommended**: H.264 (NVENC/QuickSync) - **Reason**: Universal compatibility, low latency, hardware acceleration - **Fallback**: H.264 (software)

**Settings**: - 1080p @ 30fps: 4-6 Mbps - 720p @ 30fps: 2.5-4 Mbps - Low latency: Disable B-frames

---

### For Recording (High Quality)

**Recommended**: H.265 (NVENC/QuickSync) or H.264 (software) - **Reason**: Best quality-to-size ratio - **Alternative**: HEVC software for maximum quality **Settings**: - 4K @ 30fps: 15-25 Mbps (HEVC) or 35-50 Mbps (H.264) - 1080p @ 60fps: 8-15 Mbps (HEVC) or 15-25 Mbps (H.264)

---

### For Web Delivery

**Recommended**: VP9 or H.264 - **Reason**: Browser compatibility, royalty-free (VP9)

**Settings**: - VP9: 1080p @ 2-4 Mbps - H.264: 1080p @ 4-6 Mbps

---

### For Audio

**Music**: AAC (128-192 kbps) or Opus (96-160 kbps) **Voice**: Opus (16-32 kbps) or Speex (15-20 kbps) **Archival**: FLAC (lossless) **Podcast**: MP3 VBR (V4-V2, ~130-190 kbps) or AAC (128 kbps)

---

## Compatibility Matrix

| Codec | MP4 | MKV | AVI | WebM | OGG | MPEG-TS |
| --- | --- | --- | --- | --- | --- | --- |
| **H.264** | ✓ | ✓ | ✓ | ✗ | ✗ | ✓ |
| **H.265** | ✓ | ✓ | ✗ | ✗ | ✗ | ✓ |
| **VP8** | ✗ | ✓ | ✗ | ✓ | ✗ | ✗ |
| **VP9** | ✗ | ✓ | ✗ | ✓ | ✗ | ✗ |
| **MPEG-2** | ✓ | ✓ | ✓ | ✗ | ✗ | ✓ |
| **AAC** | ✓ | ✓ | ✗ | ✗ | ✗ | ✓ |
| **MP3** | ✓ | ✓ | ✓ | ✗ | ✗ | ✓ |
| **Vorbis** | ✗ | ✓ | ✗ | ✓ | ✓ | ✗ |
| **Opus** | ✗ | ✓ | ✗ | ✓ | ✓ | ✗ |
| **FLAC** | ✓ | ✓ | ✗ | ✓ | ✓ | ✗ |

---

## See Also

- [Encoding Filters Pack Overview](../)
- [Muxers Reference](../muxers-reference/)
- [NVENC Interface Reference](../interfaces/nvenc/)
- [Code Examples](../examples/)

---END OF PAGE---


## DirectShow Encoding Filter Examples - C++, C#, VB.NET
**URL:** https://www.visioforge.com/help/docs/directshow/filters-enc/examples/
**Description:** Code examples for DirectShow encoding — NVENC GPU, H.264/H.265 software, AAC/MP3/Opus audio, and MP4/MKV/WebM muxer configuration.
**Tags:** DirectShow, C++, Windows, Streaming, Encoding, MP4, MKV, WebM, TS, H.264, H.265, VP9, AAC, MP3, Opus, FLAC, Vorbis, C#
**API:** IBaseFilter, IFileSinkFilter, ProgressEventArgs

# Encoding Filters Pack - Code Examples

## Overview

This page provides practical code examples for encoding video and audio using the Encoding Filters Pack. Covers:

- **NVENC Encoder** - NVIDIA hardware encoding (H.264/H.265)
- **Software Encoders** - H.264, H.265, VP8, VP9, MPEG-2
- **Audio Encoders** - AAC, MP3, Opus, Vorbis, FLAC
- **Muxers** - MP4, MKV, WebM, MPEG-TS, AVI

---

## Prerequisites

### C++ Projects

```
#include <dshow.h>
#include <streams.h>
#include "INVEncConfig.h"  // NVENC interface
#pragma comment(lib, "strmiids.lib")
```

### C# Projects

```
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;
using System.Runtime.InteropServices;
```

**NuGet Packages**: - VisioForge.DirectShowAPI - MediaFoundationCore

---

## NVENC Hardware Encoding Examples

> **NVENC Preset and Profile GUIDs** — The `SetPreset(Guid)` and `SetProfile(Guid)` methods accept NVIDIA NVENC SDK GUID constants. Real presets: `NV_ENC_PRESET_DEFAULT_GUID`, `NV_ENC_PRESET_HP_GUID` (high performance), `NV_ENC_PRESET_HQ_GUID` (high quality), `NV_ENC_PRESET_LOW_LATENCY_DEFAULT_GUID`, `NV_ENC_PRESET_LOW_LATENCY_HQ_GUID`, `NV_ENC_PRESET_LOW_LATENCY_HP_GUID`, `NV_ENC_PRESET_LOSSLESS_DEFAULT_GUID`, `NV_ENC_PRESET_BD_GUID`. H.264 profiles: `NV_ENC_H264_PROFILE_BASELINE_GUID`, `NV_ENC_H264_PROFILE_MAIN_GUID`, `NV_ENC_H264_PROFILE_HIGH_GUID`. HEVC: `NV_ENC_HEVC_PROFILE_MAIN_GUID`. These GUIDs are defined in the NVIDIA NVENC SDK (`nvEncodeAPI.h`).

### Example 1: Basic NVENC H.264 Encoding

Encode video with NVIDIA hardware acceleration.

#### C# NVENC H.264 Encoding

```
using VisioForge.Core.Types.Output;

// ...

var nvenc = encoderFilter as INVEncConfig;
if (nvenc != null)
{
    nvenc.SetCodec(NVENCEncoder.H264);
    nvenc.SetRateControl(NVENCRateControlMode.CBR);
    nvenc.SetBitrate(5000000);                    // 5 Mbps
    nvenc.SetPreset(NV_ENC_PRESET_DEFAULT_GUID);   // Balanced quality/speed
    nvenc.SetGOP(60);                              // Keyframe every 60 frames
    nvenc.SetBFrames(2);                           // B-frames
    nvenc.SetProfile(NV_ENC_H264_PROFILE_HIGH_GUID);
    nvenc.SetLevel(NVENCEncoderLevel.H264_41);     // Level 4.1
}
```

#### C++ NVENC H.264 Encoding

```
hr = pEncoder->QueryInterface(IID_INVEncConfig, (void**)&pNVEnc);
if (SUCCEEDED(hr))
{
    pNVEnc->SetCodec(0);                              // H264
    pNVEnc->SetRateControl(2);                        // CBR
    pNVEnc->SetBitrate(5000000);                      // 5 Mbps
    pNVEnc->SetPreset(NV_ENC_PRESET_DEFAULT_GUID);    // Balanced
    pNVEnc->SetGOP(60);                               // Keyframe interval
    pNVEnc->SetBFrames(2);                            // B-frames
    pNVEnc->SetProfile(NV_ENC_H264_PROFILE_HIGH_GUID);
    pNVEnc->SetLevel(41);                             // Level 4.1

    pNVEnc->Release();
}
```

---

### Example 2: NVENC H.265 (HEVC) Encoding

Encode with H.265 for better compression.

#### C# NVENC H.265

## ``` public void EncodeH265(string inputFile, string outputFile) { var filterGraph = (IFilterGraph2)new FilterGraph(); // Add source filterGraph.AddSourceFilter(inputFile, "Source", out IBaseFilter sourceFilter); // Add NVENC encoder var encoderFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFNVENCEncoder, "NVENC Encoder"); var nvenc = encoderFilter as INVEncConfig; if (nvenc != null) { nvenc.SetCodec(NVENCEncoder.HEVC); nvenc.SetRateControl(NVENCRateControlMode.CONST_QP); nvenc.SetQp(23); // QP 23: good balance nvenc.SetPreset(NV_ENC_PRESET_HQ_GUID); // High quality nvenc.SetProfile(NV_ENC_HEVC_PROFILE_MAIN_GUID); nvenc.SetLevel(NVENCEncoderLevel.H264_41); // Level 4.1 nvenc.SetGOP(120); // 4 seconds at 30fps nvenc.SetBFrames(3); } // Add muxer var muxerFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFMP4Muxer, "MP4 Muxer"); var fileSink = muxerFilter as IFileSinkFilter; fileSink?.SetFileName(outputFile, null); // Connect and encode... ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); captureGraph.SetFiltergraph(filterGraph); captureGraph.RenderStream(null, MediaType.Video, sourceFilter, encoderFilter, muxerFilter); var mediaControl = (IMediaControl)filterGraph; mediaControl.Run(); Marshal.ReleaseComObject(captureGraph); } ```

### Example 3: NVENC Rate Control Modes

Different rate control strategies for various use cases.

#### C# Rate Control Examples

```
using VisioForge.Core.Types.Output;

public void ConfigureRateControl(INVEncConfig nvenc, NVENCRateControlMode mode)
{
    switch (mode)
    {
        case NVENCRateControlMode.CBR:
            nvenc.SetRateControl(NVENCRateControlMode.CBR);
            nvenc.SetBitrate(5000000);       // 5 Mbps target
            nvenc.SetVbvBitrate(5000000);    // Same as target for CBR
            nvenc.SetVbvSize(10000000);      // 10 Mb buffer
            break;

        case NVENCRateControlMode.VBR:
            nvenc.SetRateControl(NVENCRateControlMode.VBR);
            nvenc.SetBitrate(5000000);       // Average 5 Mbps
            nvenc.SetVbvBitrate(8000000);    // Peak 8 Mbps
            nvenc.SetVbvSize(10000000);
            break;

        case NVENCRateControlMode.CONST_QP:
            nvenc.SetRateControl(NVENCRateControlMode.CONST_QP);
            nvenc.SetQp(23);                 // QP: lower = better quality
            break;
    }
}
```

---

### Example 4: NVENC Quality Presets

Balance between speed and quality.

#### C# Quality Presets

## ``` public void SetQualityPreset(INVEncConfig nvenc, string useCase) { switch (useCase.ToLower()) { case "realtime": nvenc.SetPreset(NV_ENC_PRESET_LOW_LATENCY_HP_GUID); nvenc.SetBFrames(0); break; case "fast": nvenc.SetPreset(NV_ENC_PRESET_LOW_LATENCY_DEFAULT_GUID); nvenc.SetBFrames(1); break; case "balanced": nvenc.SetPreset(NV_ENC_PRESET_DEFAULT_GUID); nvenc.SetBFrames(2); break; case "quality": nvenc.SetPreset(NV_ENC_PRESET_HQ_GUID); nvenc.SetBFrames(3); break; default: nvenc.SetPreset(NV_ENC_PRESET_DEFAULT_GUID); nvenc.SetBFrames(2); break; } } ```

## Software Encoding Examples

### Example 5: Software H.264 Encoder

Use CPU-based H.264 encoding.

#### C# Software H.264

```
public void EncodeSoftwareH264(string inputFile, string outputFile)
{
    var filterGraph = (IFilterGraph2)new FilterGraph();

    // Add source
    filterGraph.AddSourceFilter(inputFile, "Source", out IBaseFilter sourceFilter);

    // Add software H.264 encoder
    var encoderFilter = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFH264Encoder,  // Software encoder
        "H.264 Encoder");

    // Configure encoder (if interface available)
    // var h264Config = encoderFilter as IH264EncoderConfig;
    // Configure bitrate, quality, etc.

    // Add muxer
    var muxerFilter = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFMP4Muxer,
        "MP4 Muxer");

    var fileSink = muxerFilter as IFileSinkFilter;
    fileSink?.SetFileName(outputFile, null);

    // Connect and encode
    ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
    captureGraph.SetFiltergraph(filterGraph);

    captureGraph.RenderStream(null, MediaType.Video, sourceFilter, encoderFilter, muxerFilter);

    var mediaControl = (IMediaControl)filterGraph;
    mediaControl.Run();

    Marshal.ReleaseComObject(captureGraph);
}
```

---

## Audio Encoding Examples

### Example 6: AAC Audio Encoding

Encode audio to AAC format.

#### C# AAC Encoding

## ``` public void EncodeAACAudio(string inputFile, string outputFile) { var filterGraph = (IFilterGraph2)new FilterGraph(); // Add source filterGraph.AddSourceFilter(inputFile, "Source", out IBaseFilter sourceFilter); // Add video encoder (e.g., NVENC) var videoEncoderFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFNVENCEncoder, "NVENC Encoder"); var nvenc = videoEncoderFilter as INVEncConfig; if (nvenc != null) { nvenc.SetCodec(NVENCEncoder.H264); nvenc.SetRateControl(NVENCRateControlMode.CBR); nvenc.SetBitrate(5000000); nvenc.SetPreset(NV_ENC_PRESET_DEFAULT_GUID); } // Add AAC audio encoder var audioEncoderFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFAACEncoder, "AAC Encoder"); // Configure AAC (if interface available) // var aacConfig = audioEncoderFilter as IAACEncoderConfig; // aacConfig?.SetBitrate(192000); // 192 kbps // aacConfig?.SetProfile(AAC_PROFILE_LC); // Add muxer var muxerFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFMP4Muxer, "MP4 Muxer"); var fileSink = muxerFilter as IFileSinkFilter; fileSink?.SetFileName(outputFile, null); // Connect filters ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); captureGraph.SetFiltergraph(filterGraph); // Video path captureGraph.RenderStream(null, MediaType.Video, sourceFilter, videoEncoderFilter, muxerFilter); // Audio path captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, audioEncoderFilter, muxerFilter); // Run encoding var mediaControl = (IMediaControl)filterGraph; mediaControl.Run(); Marshal.ReleaseComObject(captureGraph); } ```

### Example 7: Multiple Audio Codec Support

Support for different audio codecs.

#### C# Audio Codec Selection

```
public enum AudioCodec
{
    AAC,
    MP3,
    Opus,
    Vorbis,
    FLAC
}

public IBaseFilter CreateAudioEncoder(IFilterGraph2 filterGraph, AudioCodec codec)
{
    Guid encoderCLSID;
    string encoderName;

    switch (codec)
    {
        case AudioCodec.AAC:
            encoderCLSID = Consts.CLSID_VFAACEncoder;
            encoderName = "AAC Encoder";
            break;

        case AudioCodec.MP3:
            encoderCLSID = Consts.CLSID_VFMP3Encoder;
            encoderName = "MP3 Encoder";
            break;

        case AudioCodec.Opus:
            encoderCLSID = Consts.CLSID_VFOpusEncoder;
            encoderName = "Opus Encoder";
            break;

        case AudioCodec.Vorbis:
            encoderCLSID = Consts.CLSID_VFVorbisEncoder;
            encoderName = "Vorbis Encoder";
            break;

        case AudioCodec.FLAC:
            encoderCLSID = Consts.CLSID_VFFLACEncoder;
            encoderName = "FLAC Encoder";
            break;

        default:
            throw new ArgumentException("Unsupported audio codec");
    }

    return FilterGraphTools.AddFilterFromClsid(filterGraph, encoderCLSID, encoderName);
}
```

---

## Container Muxing Examples

### Example 8: MP4 Container

Mux video and audio to MP4 format.

#### C# MP4 Muxing

## ``` public void CreateMP4(string inputFile, string outputFile) { var filterGraph = (IFilterGraph2)new FilterGraph(); // Add source filterGraph.AddSourceFilter(inputFile, "Source", out IBaseFilter sourceFilter); // Add video encoder var videoEncoder = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFNVENCEncoder, "NVENC Encoder"); // Add audio encoder var audioEncoder = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFAACEncoder, "AAC Encoder"); // Add MP4 muxer var muxerFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFMP4Muxer, "MP4 Muxer"); // Set output file var fileSink = muxerFilter as IFileSinkFilter; fileSink?.SetFileName(outputFile, null); // Configure muxer (if needed) // var mp4Config = muxerFilter as IMP4MuxerConfig; // mp4Config?.SetFastStart(true); // Enable fast start for web // Connect filters ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); captureGraph.SetFiltergraph(filterGraph); captureGraph.RenderStream(null, MediaType.Video, sourceFilter, videoEncoder, muxerFilter); captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, audioEncoder, muxerFilter); var mediaControl = (IMediaControl)filterGraph; mediaControl.Run(); Marshal.ReleaseComObject(captureGraph); } ```

### Example 9: MKV Container

Create Matroska (MKV) files.

#### C# MKV Muxing

```
public void CreateMKV(string inputFile, string outputFile)
{
    var filterGraph = (IFilterGraph2)new FilterGraph();

    // Add source
    filterGraph.AddSourceFilter(inputFile, "Source", out IBaseFilter sourceFilter);

    // Add encoders
    var videoEncoder = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFNVENCEncoder,
        "NVENC Encoder");

    var audioEncoder = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFAACEncoder,
        "AAC Encoder");

    // Add MKV muxer
    var muxerFilter = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFMKVMuxer,
        "MKV Muxer");

    var fileSink = muxerFilter as IFileSinkFilter;
    fileSink?.SetFileName(outputFile, null);

    // Connect and encode
    ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
    captureGraph.SetFiltergraph(filterGraph);

    captureGraph.RenderStream(null, MediaType.Video, sourceFilter, videoEncoder, muxerFilter);
    captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, audioEncoder, muxerFilter);

    var mediaControl = (IMediaControl)filterGraph;
    mediaControl.Run();

    Marshal.ReleaseComObject(captureGraph);
}
```

---

### Example 10: WebM Container

Create WebM files for web delivery.

#### C# WebM Muxing

## ``` public void CreateWebM(string inputFile, string outputFile) { var filterGraph = (IFilterGraph2)new FilterGraph(); // Add source filterGraph.AddSourceFilter(inputFile, "Source", out IBaseFilter sourceFilter); // Add VP9 video encoder (WebM standard) var videoEncoder = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFVP9Encoder, "VP9 Encoder"); // Add Opus audio encoder (WebM standard) var audioEncoder = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFOpusEncoder, "Opus Encoder"); // Add WebM muxer var muxerFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFWebMMuxer, "WebM Muxer"); var fileSink = muxerFilter as IFileSinkFilter; fileSink?.SetFileName(outputFile, null); // Connect and encode ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); captureGraph.SetFiltergraph(filterGraph); captureGraph.RenderStream(null, MediaType.Video, sourceFilter, videoEncoder, muxerFilter); captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, audioEncoder, muxerFilter); var mediaControl = (IMediaControl)filterGraph; mediaControl.Run(); Marshal.ReleaseComObject(captureGraph); } ```

## Complete Encoding Pipeline

### Example 11: Full-Featured Encoder

Complete encoding application with all features.

#### C# Complete Encoder

```
using System;
using System.Runtime.InteropServices;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;

public class CompleteEncoder : IDisposable
{
    private IFilterGraph2 filterGraph;
    private ICaptureGraphBuilder2 captureGraph;
    private IMediaControl mediaControl;
    private IMediaEventEx mediaEventEx;
    private IMediaSeeking mediaSeeking;

    private const int WM_GRAPHNOTIFY = 0x8000 + 1;

    public event EventHandler EncodingComplete;
    public event EventHandler<ProgressEventArgs> ProgressChanged;

    public class ProgressEventArgs : EventArgs
    {
        public long CurrentPosition { get; set; }
        public long Duration { get; set; }
        public double PercentComplete { get; set; }
    }

    public void Initialize(IntPtr notifyHandle)
    {
        filterGraph = (IFilterGraph2)new FilterGraph();
        captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
        mediaControl = (IMediaControl)filterGraph;
        mediaEventEx = (IMediaEventEx)filterGraph;
        mediaSeeking = (IMediaSeeking)filterGraph;

        int hr = mediaEventEx.SetNotifyWindow(notifyHandle, WM_GRAPHNOTIFY, IntPtr.Zero);
        DsError.ThrowExceptionForHR(hr);

        hr = captureGraph.SetFiltergraph(filterGraph);
        DsError.ThrowExceptionForHR(hr);
    }

    public void ConfigureEncoding(
        string inputFile,
        string outputFile,
        VideoCodec videoCodec,
        AudioCodec audioCodec,
        ContainerFormat container,
        int videoBitrate = 5000000,
        int audioBitrate = 192000)
    {
        // Add source
        filterGraph.AddSourceFilter(inputFile, "Source", out IBaseFilter sourceFilter);

        // Create video encoder
        IBaseFilter videoEncoder = CreateVideoEncoder(videoCodec);
        ConfigureVideoEncoder(videoEncoder, videoCodec, videoBitrate);

        // Create audio encoder
        IBaseFilter audioEncoder = CreateAudioEncoder(audioCodec);
        ConfigureAudioEncoder(audioEncoder, audioCodec, audioBitrate);

        // Create muxer
        IBaseFilter muxer = CreateMuxer(container);

        // Set output file
        var fileSink = muxer as IFileSinkFilter;
        fileSink?.SetFileName(outputFile, null);

        // Connect pipeline
        int hr = captureGraph.RenderStream(null, MediaType.Video, sourceFilter, videoEncoder, muxer);
        hr = captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, audioEncoder, muxer);
    }

    private IBaseFilter CreateVideoEncoder(VideoCodec codec)
    {
        Guid clsid;
        string name;

        switch (codec)
        {
            case VideoCodec.H264_NVENC:
                clsid = Consts.CLSID_VFNVENCEncoder;
                name = "NVENC H.264";
                break;

            case VideoCodec.H265_NVENC:
                clsid = Consts.CLSID_VFNVENCEncoder;
                name = "NVENC H.265";
                break;

            case VideoCodec.H264_Software:
                clsid = Consts.CLSID_VFH264Encoder;
                name = "Software H.264";
                break;

            default:
                throw new ArgumentException("Unsupported video codec");
        }

        return FilterGraphTools.AddFilterFromClsid(filterGraph, clsid, name);
    }

    private void ConfigureVideoEncoder(IBaseFilter encoder, VideoCodec codec, int bitrate)
    {
        if (codec == VideoCodec.H264_NVENC || codec == VideoCodec.H265_NVENC)
        {
            var nvenc = encoder as INVEncConfig;
            if (nvenc != null)
            {
                nvenc.SetCodec(codec == VideoCodec.H264_NVENC ? NVENCEncoder.H264 : NVENCEncoder.HEVC);
                nvenc.SetRateControl(NVENCRateControlMode.CBR);
                nvenc.SetBitrate(bitrate);
                nvenc.SetPreset(NV_ENC_PRESET_DEFAULT_GUID);
                nvenc.SetGOP(60);
                nvenc.SetBFrames(2);
            }
        }
        // Configure other encoders...
    }

    private IBaseFilter CreateAudioEncoder(AudioCodec codec)
    {
        Guid clsid;
        string name;

        switch (codec)
        {
            case AudioCodec.AAC:
                clsid = Consts.CLSID_VFAACEncoder;
                name = "AAC Encoder";
                break;

            case AudioCodec.MP3:
                clsid = Consts.CLSID_VFMP3Encoder;
                name = "MP3 Encoder";
                break;

            default:
                throw new ArgumentException("Unsupported audio codec");
        }

        return FilterGraphTools.AddFilterFromClsid(filterGraph, clsid, name);
    }

    private void ConfigureAudioEncoder(IBaseFilter encoder, AudioCodec codec, int bitrate)
    {
        // Configure audio encoder based on codec type
        // (Interface-specific configuration)
    }

    private IBaseFilter CreateMuxer(ContainerFormat format)
    {
        Guid clsid;
        string name;

        switch (format)
        {
            case ContainerFormat.MP4:
                clsid = Consts.CLSID_VFMP4Muxer;
                name = "MP4 Muxer";
                break;

            case ContainerFormat.MKV:
                clsid = Consts.CLSID_VFMKVMuxer;
                name = "MKV Muxer";
                break;

            case ContainerFormat.WebM:
                clsid = Consts.CLSID_VFWebMMuxer;
                name = "WebM Muxer";
                break;

            default:
                throw new ArgumentException("Unsupported container format");
        }

        return FilterGraphTools.AddFilterFromClsid(filterGraph, clsid, name);
    }

    public void StartEncoding()
    {
        mediaControl?.Run();
    }

    public void Stop()
    {
        mediaControl?.Stop();
    }

    public double GetProgress()
    {
        if (mediaSeeking != null)
        {
            mediaSeeking.GetCurrentPosition(out long position);
            mediaSeeking.GetDuration(out long duration);

            if (duration > 0)
            {
                return (double)position / duration * 100.0;
            }
        }

        return 0.0;
    }

    public void HandleGraphEvent()
    {
        if (mediaEventEx != null)
        {
            while (mediaEventEx.GetEvent(out EventCode eventCode, out IntPtr param1,
                                          out IntPtr param2, 0) == 0)
            {
                mediaEventEx.FreeEventParams(eventCode, param1, param2);

                if (eventCode == EventCode.Complete)
                {
                    EncodingComplete?.Invoke(this, EventArgs.Empty);
                }
            }
        }
    }

    public void Dispose()
    {
        if (mediaControl != null)
        {
            mediaControl.Stop();
        }

        if (mediaEventEx != null)
        {
            mediaEventEx.SetNotifyWindow(IntPtr.Zero, 0, IntPtr.Zero);
        }

        FilterGraphTools.RemoveAllFilters(filterGraph);

        if (mediaEventEx != null) Marshal.ReleaseComObject(mediaEventEx);
        if (mediaSeeking != null) Marshal.ReleaseComObject(mediaSeeking);
        if (captureGraph != null) Marshal.ReleaseComObject(captureGraph);
        if (mediaControl != null) Marshal.ReleaseComObject(mediaControl);
        if (filterGraph != null) Marshal.ReleaseComObject(filterGraph);
    }
}

public enum VideoCodec
{
    H264_NVENC,
    H265_NVENC,
    H264_Software,
    VP8,
    VP9
}

public enum ContainerFormat
{
    MP4,
    MKV,
    WebM,
    MPEG_TS,
    AVI
}
```

---

## Troubleshooting

### Issue: NVENC Not Available

**Solution**: Check GPU compatibility:

```
var nvenc2 = encoder as INVEncConfig2;
if (nvenc2 != null)
{
    int hr = nvenc2.CheckNVENCAvailable(out bool available, out int status);
    if (hr != 0 || !available)
    {
        Console.WriteLine("NVENC not available - GPU may not support it");
        // Fall back to software encoder
    }
}
```

### Issue: Encoding Too Slow

**Solution**: Adjust quality preset:

```
// Use faster preset
nvenc.SetPreset(NV_ENC_PRESET_LOW_LATENCY_HP_GUID);
nvenc.SetBFrames(0);  // Disable B-frames
```

### Issue: Output File Size Too Large

**Solution**: Adjust bitrate or use better codec:

```
// Lower bitrate
nvenc.SetBitrate(2000000);  // 2 Mbps instead of 5
// Or use H.265 for better compression
nvenc.SetCodec(NVENCEncoder.HEVC);
```

---

## See Also

### Documentation

- [NVENC Interface](../interfaces/nvenc/) - Complete NVENC API
- [Codecs Reference](../codecs-reference/) - All video/audio codecs
- [Muxers Reference](../muxers-reference/) - Container formats

### External Resources

- [NVIDIA NVENC Documentation](https://developer.nvidia.com/video-codec-sdk)
- [H.264 Specification](https://www.itu.int/rec/T-REC-H.264)

---END OF PAGE---


## DirectShow Encoding Filters — H.264, H.265, NVENC & More
**URL:** https://www.visioforge.com/help/docs/directshow/filters-enc/
**Description:** DirectShow video/audio encoders with H.264, H.265, VP8, VP9, AAC, MP3, and GPU acceleration (NVENC, QuickSync, AMF) for Windows apps.
**Tags:** DirectShow, C++, Windows, Streaming

# DirectShow Encoding Filters Pack

## Introduction

The DirectShow Encoding Filters Pack provides a powerful set of media encoding components designed specifically for software developers building professional multimedia applications. This toolkit enables seamless integration of high-performance encoding capabilities for both audio and video streams across a wide variety of popular formats.

---

## Installation

Before using the code samples and integrating the filters into your application, you must first install the DirectShow Encoding Filters Pack from the [product page](https://www.visioforge.com/encoding-filters-pack).

**Installation Steps**:

1. Download the Encoding Filters Pack installer from the product page
2. Run the installer with administrative privileges
3. The installer will register all encoding and muxing filters
4. Sample applications and source code will be available in the installation directory

**Note**: All filters must be properly registered on the system before they can be used in your applications. The installer handles this automatically.

---

## Key Features

### Multi-Format Encoding Support

The filters pack supports numerous industry-standard formats, including:

- **MP4 container** with H264, HEVC, and AAC codecs
- **MPEG-TS** streams
- **MKV** (Matroska) containers
- **WebM** format with VP8/VP9 video codecs
- Multiple audio formats including **Vorbis**, **MP3**, **FLAC**, and **Opus**

### Hardware Acceleration

Developers can leverage GPU acceleration for improved encoding performance:

- **Intel** QuickSync technology
- **AMD/ATI** hardware acceleration
- **Nvidia** NVENC encoding support

This hardware optimization dramatically improves encoding speeds while reducing CPU load in your applications.

### Flexible Implementation Options

The pack includes:

- Standalone H264/AAC encoders utilizing CPU resources
- Specialized muxer components with integrated video and audio encoders
- Options for both CPU and GPU-based encoding paths

## Technical Capabilities

The filter components integrate seamlessly into DirectShow application pipelines, providing developers with:

- High-quality video encoding at various bitrates and resolutions
- Efficient audio compression with configurable quality settings
- Advanced container format support with customizable parameters
- DirectShow filter graph compatibility for straightforward implementation

For detailed specifications and a comprehensive list of all supported video/audio encoders and output formats, please visit the [product page](https://www.visioforge.com/encoding-filters-pack).

## Version History

### 11.4 Release

- Updated filter components to match current .Net SDK implementations
- Enhanced AMD AMF H264/H265 encoders with latest optimizations
- Improved Intel QuickSync H265 encoders for better performance
- Refreshed sample applications with new coding examples

### 11.0 Release

- Synchronized filters with current .Net SDK versions
- Upgraded Nvidia NVENC H264/H265 encoders for better quality
- Introduced new SSF muxer filter component

### 10.0 Release

- Updated all filters to align with .Net SDK implementations
- Enhanced Media Foundation encoders (H264, H265, AAC)
- Added dedicated NVENC video encoder filter as CUDA encoder replacement

### 9.0 Release

- Optimized MP4 container with H264/AAC output
- Expanded WebM format support with VP9 encoding capabilities
- Improved H265 encoder filter performance
- Enhanced Intel QuickSync H264 encoders

### 8.6 Release

- Implemented RTSP sink filter for streaming applications
- Added RTMP sink filter in BETA status
- Upgraded AAC encoder filter with quality improvements

### 8.5 Initial Release

- First public release including filters from .Net SDKs
- Core components: AAC encoder, H264 encoders (CPU/GPU)
- Additional encoders: H265 (CPU/GPU), VP8, Vorbis
- Container support: MP4 muxer, WebM muxer
- Streaming capabilities: RTSP source, RTMP source

---

## Resources

- [Product Page](https://www.visioforge.com/encoding-filters-pack) - Purchase, licensing, and product information
- [Code Examples](https://github.com/visioforge/directshow-samples/tree/main/Encoding%20Filters%20Pack) - Sample applications and implementation examples

---

## See Also

- [Codecs Reference](codecs-reference/) - Complete video and audio codec documentation
- [Muxers Reference](muxers-reference/) - Container format specifications
- [NVENC Interface](interfaces/nvenc/) - NVIDIA hardware encoder API
- [Code Examples](examples/) - Practical encoding examples

---END OF PAGE---


## AAC Encoder DirectShow Filter - COM Interface Reference
**URL:** https://www.visioforge.com/help/docs/directshow/filters-enc/interfaces/aac/
**Description:** Configure AAC encoding in DirectShow with IMonogramAACEncoder and IVFAACEncoder interfaces. Bitrate, profile, sample rate, and channel settings for C++/C#.
**Tags:** DirectShow, C++, Windows, Streaming, Encoding, Decoding, MP4, TS, AAC, MP3, C#
**API:** IMonogramAACEncoder, IVFAACEncoder, AACConfig, VFAACEncoder, IBaseFilter

# AAC Encoder Interface Reference

## Overview

The AAC (Advanced Audio Coding) encoder DirectShow filters provide interfaces for high-quality audio encoding to the AAC format. AAC is the successor to MP3, offering better sound quality at the same bitrate and is the standard audio codec for MP4, M4A, and streaming applications.

Two AAC encoder interfaces are available: - **IMonogramAACEncoder**: Simple configuration interface using a single configuration structure - **IVFAACEncoder**: Comprehensive interface with individual property methods for fine-grained control

## IMonogramAACEncoder Interface

### Overview

The **IMonogramAACEncoder** interface provides a simple, structure-based configuration approach for AAC encoding. Configuration is performed using the `AACConfig` structure that contains all essential encoding parameters.

**Interface GUID**: `{B2DE30C0-1441-4451-A0CE-A914FD561D7F}`

**Inherits From**: `IUnknown`

### AACConfig Structure

```
/// <summary>
/// AAC encoder configuration structure.
/// </summary>
public struct AACConfig
{
    /// <summary>
    /// AAC version/profile (typically 2 for AAC-LC, 4 for AAC-HE)
    /// </summary>
    public int version;

    /// <summary>
    /// Object type / profile:
    /// 2 = AAC-LC (Low Complexity) - recommended for most uses
    /// 5 = AAC-HE (High Efficiency)
    /// 29 = AAC-HEv2 (High Efficiency version 2)
    /// </summary>
    public int object_type;

    /// <summary>
    /// Output format type (0 = Raw AAC, 1 = ADTS)
    /// </summary>
    public int output_type;

    /// <summary>
    /// Target bitrate in bits per second (e.g., 128000 for 128 kbps)
    /// </summary>
    public int bitrate;
}
```

### AACInfo Structure

```
/// <summary>
/// AAC encoder runtime information.
/// </summary>
public struct AACInfo
{
    /// <summary>
    /// Input sample rate in Hz (e.g., 44100, 48000)
    /// </summary>
    public int samplerate;

    /// <summary>
    /// Number of audio channels (1 = mono, 2 = stereo, 6 = 5.1, etc.)
    /// </summary>
    public int channels;

    /// <summary>
    /// AAC frame size in samples (typically 1024 for AAC-LC)
    /// </summary>
    public int frame_size;

    /// <summary>
    /// Total number of frames encoded
    /// </summary>
    public long frames_done;
}
```

### Interface Definitions

#### C# Definition

```
using System;
using System.Runtime.InteropServices;

namespace VisioForge.DirectShowAPI
{
    /// <summary>
    /// AAC encoder configuration structure.
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct AACConfig
    {
        public int version;
        public int object_type;
        public int output_type;
        public int bitrate;
    }

    /// <summary>
    /// AAC encoder runtime information.
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct AACInfo
    {
        public int samplerate;
        public int channels;
        public int frame_size;
        public long frames_done;
    }

    /// <summary>
    /// Monogram AAC encoder configuration interface.
    /// Provides structure-based configuration for AAC encoding.
    /// </summary>
    [ComImport]
    [Guid("B2DE30C0-1441-4451-A0CE-A914FD561D7F")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IMonogramAACEncoder
    {
        /// <summary>
        /// Gets the current AAC encoder configuration.
        /// </summary>
        /// <param name="config">Reference to AACConfig structure to receive current settings</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int GetConfig(ref AACConfig config);

        /// <summary>
        /// Sets the AAC encoder configuration.
        /// </summary>
        /// <param name="config">Reference to AACConfig structure containing desired settings</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetConfig(ref AACConfig config);
    }
}
```

#### C++ Definition

```
#include <unknwn.h>

// {B2DE30C0-1441-4451-A0CE-A914FD561D7F}
DEFINE_GUID(IID_IMonogramAACEncoder,
    0xb2de30c0, 0x1441, 0x4451, 0xa0, 0xce, 0xa9, 0x14, 0xfd, 0x56, 0x1d, 0x7f);

/// <summary>
/// AAC encoder configuration structure.
/// </summary>
struct AACConfig
{
    int version;
    int object_type;
    int output_type;
    int bitrate;
};

/// <summary>
/// AAC encoder runtime information.
/// </summary>
struct AACInfo
{
    int samplerate;
    int channels;
    int frame_size;
    __int64 frames_done;
};

/// <summary>
/// Monogram AAC encoder configuration interface.
/// </summary>
DECLARE_INTERFACE_(IMonogramAACEncoder, IUnknown)
{
    /// <summary>
    /// Gets the current AAC encoder configuration.
    /// </summary>
    /// <param name="config">Pointer to AACConfig structure to receive settings</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(GetConfig)(THIS_
        AACConfig* config
        ) PURE;

    /// <summary>
    /// Sets the AAC encoder configuration.
    /// </summary>
    /// <param name="config">Pointer to AACConfig structure with desired settings</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(SetConfig)(THIS_
        const AACConfig* config
        ) PURE;
};
```

#### Delphi Definition

```
uses
  ActiveX, ComObj;

const
  IID_IMonogramAACEncoder: TGUID = '{B2DE30C0-1441-4451-A0CE-A914FD561D7F}';

type
  /// <summary>
  /// AAC encoder configuration structure.
  /// </summary>
  TAACConfig = record
    version: Integer;
    object_type: Integer;
    output_type: Integer;
    bitrate: Integer;
  end;

  /// <summary>
  /// AAC encoder runtime information.
  /// </summary>
  TAACInfo = record
    samplerate: Integer;
    channels: Integer;
    frame_size: Integer;
    frames_done: Int64;
  end;

  /// <summary>
  /// Monogram AAC encoder configuration interface.
  /// </summary>
  IMonogramAACEncoder = interface(IUnknown)
    ['{B2DE30C0-1441-4451-A0CE-A914FD561D7F}']

    /// <summary>
    /// Gets the current AAC encoder configuration.
    /// </summary>
    function GetConfig(var config: TAACConfig): HRESULT; stdcall;

    /// <summary>
    /// Sets the AAC encoder configuration.
    /// </summary>
    function SetConfig(const config: TAACConfig): HRESULT; stdcall;
  end;
```

---

## IVFAACEncoder Interface

### Overview

The **IVFAACEncoder** interface provides comprehensive, property-based configuration for AAC encoding with individual getter/setter methods for each parameter. This interface offers finer control and is easier to use for incremental configuration changes. **Interface GUID**: `{0BEF7533-39E6-42a5-863F-E087FAB5D84F}` **Inherits From**: `IUnknown`

### Interface Definitions

#### C# Definition

```
using System;
using System.Runtime.InteropServices;
namespace VisioForge.DirectShowAPI
{
    /// <summary>
    /// VisioForge AAC encoder configuration interface.
    /// Provides comprehensive property-based control over AAC encoding parameters.
    /// </summary>
    [ComImport]
    [Guid("0BEF7533-39E6-42a5-863F-E087FAB5D84F")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IVFAACEncoder
    {
        /// <summary>
        /// Forces a specific input sample rate. Set to 0 to accept any rate.
        /// </summary>
        /// <param name="ulSampleRate">Sample rate in Hz (e.g., 44100, 48000). 0 = any rate</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetInputSampleRate(uint ulSampleRate);
        /// <summary>
        /// Gets the configured input sample rate.
        /// </summary>
        /// <param name="pulSampleRate">Receives sample rate in Hz. 0 if not fixed</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int GetInputSampleRate(out uint pulSampleRate);
        /// <summary>
        /// Sets the number of input channels.
        /// </summary>
        /// <param name="nChannels">Number of channels (1=mono, 2=stereo, 6=5.1, etc.)</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetInputChannels(short nChannels);
        /// <summary>
        /// Gets the number of input channels.
        /// </summary>
        /// <param name="pnChannels">Receives the number of channels</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int GetInputChannels(out short pnChannels);
        /// <summary>
        /// Sets the target bitrate. Set to -1 to use maximum bitrate.
        /// </summary>
        /// <param name="ulBitRate">Bitrate in bits per second (e.g., 128000). -1 = maximum</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetBitRate(uint ulBitRate);
        /// <summary>
        /// Gets the configured bitrate.
        /// </summary>
        /// <param name="pulBitRate">Receives bitrate in bps. -1 if set to maximum</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int GetBitRate(out uint pulBitRate);
        /// <summary>
        /// Sets the AAC profile type.
        /// </summary>
        /// <param name="uProfile">Profile: 2=AAC-LC, 5=AAC-HE, 29=AAC-HEv2</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetProfile(uint uProfile);
        /// <summary>
        /// Gets the current AAC profile.
        /// </summary>
        /// <param name="puProfile">Receives the profile type</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int GetProfile(out uint puProfile);
        /// <summary>
        /// Sets the output format.
        /// </summary>
        /// <param name="uFormat">Format: 0=Raw AAC, 1=ADTS</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetOutputFormat(uint uFormat);
        /// <summary>
        /// Gets the output format.
        /// </summary>
        /// <param name="puFormat">Receives the output format</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int GetOutputFormat(out uint puFormat);
        /// <summary>
        /// Sets the time shift value for timestamp adjustment.
        /// </summary>
        /// <param name="timeShift">Time shift in milliseconds</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetTimeShift(int timeShift);
        /// <summary>
        /// Gets the time shift value.
        /// </summary>
        /// <param name="ptimeShift">Receives the time shift in milliseconds</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int GetTimeShift(out int ptimeShift);
        /// <summary>
        /// Enables or disables Low Frequency Effects (LFE) channel.
        /// </summary>
        /// <param name="lfe">1 to enable LFE, 0 to disable</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetLFE(uint lfe);
        /// <summary>
        /// Gets the LFE channel state.
        /// </summary>
        /// <param name="p">Receives LFE state (1=enabled, 0=disabled)</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int GetLFE(out uint p);
        /// <summary>
        /// Enables or disables Temporal Noise Shaping (TNS).
        /// TNS improves encoding of transient sounds.
        /// </summary>
        /// <param name="tns">1 to enable TNS, 0 to disable</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetTNS(uint tns);
        /// <summary>
        /// Gets the TNS state.
        /// </summary>
        /// <param name="p">Receives TNS state (1=enabled, 0=disabled)</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int GetTNS(out uint p);
        /// <summary>
        /// Enables or disables Mid-Side stereo coding.
        /// Can improve compression for stereo audio.
        /// </summary>
        /// <param name="v">1 to enable mid-side coding, 0 to disable</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetMidSide(uint v);
        /// <summary>
        /// Gets the mid-side coding state.
        /// </summary>
        /// <param name="p">Receives mid-side state (1=enabled, 0=disabled)</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int GetMidSide(out uint p);
    }
}
```

#### C++ Definition

```
#include <unknwn.h>
// {0BEF7533-39E6-42a5-863F-E087FAB5D84F}
DEFINE_GUID(IID_IVFAACEncoder,
    0x0bef7533, 0x39e6, 0x42a5, 0x86, 0x3f, 0xe0, 0x87, 0xfa, 0xb5, 0xd8, 0x4f);
/// <summary>
/// VisioForge AAC encoder configuration interface.
/// </summary>
DECLARE_INTERFACE_(IVFAACEncoder, IUnknown)
{
    STDMETHOD(SetInputSampleRate)(THIS_
        unsigned long ulSampleRate
        ) PURE;
    STDMETHOD(GetInputSampleRate)(THIS_
        unsigned long* pulSampleRate
        ) PURE;
    STDMETHOD(SetInputChannels)(THIS_
        short nChannels
        ) PURE;
    STDMETHOD(GetInputChannels)(THIS_
        short* pnChannels
        ) PURE;
    STDMETHOD(SetBitRate)(THIS_
        unsigned long ulBitRate
        ) PURE;
    STDMETHOD(GetBitRate)(THIS_
        unsigned long* pulBitRate
        ) PURE;
    STDMETHOD(SetProfile)(THIS_
        unsigned long uProfile
        ) PURE;
    STDMETHOD(GetProfile)(THIS_
        unsigned long* puProfile
        ) PURE;
    STDMETHOD(SetOutputFormat)(THIS_
        unsigned long uFormat
        ) PURE;
    STDMETHOD(GetOutputFormat)(THIS_
        unsigned long* puFormat
        ) PURE;
    STDMETHOD(SetTimeShift)(THIS_
        int timeShift
        ) PURE;
    STDMETHOD(GetTimeShift)(THIS_
        int* ptimeShift
        ) PURE;
    STDMETHOD(SetLFE)(THIS_
        unsigned long lfe
        ) PURE;
    STDMETHOD(GetLFE)(THIS_
        unsigned long* p
        ) PURE;
    STDMETHOD(SetTNS)(THIS_
        unsigned long tns
        ) PURE;
    STDMETHOD(GetTNS)(THIS_
        unsigned long* p
        ) PURE;
    STDMETHOD(SetMidSide)(THIS_
        unsigned long v
        ) PURE;
    STDMETHOD(GetMidSide)(THIS_
        unsigned long* p
        ) PURE;
};
```

#### Delphi Definition

```
uses
  ActiveX, ComObj;
const
  IID_IVFAACEncoder: TGUID = '{0BEF7533-39E6-42a5-863F-E087FAB5D84F}';
type
  /// <summary>
  /// VisioForge AAC encoder configuration interface.
  /// </summary>
  IVFAACEncoder = interface(IUnknown)
    ['{0BEF7533-39E6-42a5-863F-E087FAB5D84F}']
    function SetInputSampleRate(ulSampleRate: Cardinal): HRESULT; stdcall;
    function GetInputSampleRate(out pulSampleRate: Cardinal): HRESULT; stdcall;
    function SetInputChannels(nChannels: SmallInt): HRESULT; stdcall;
    function GetInputChannels(out pnChannels: SmallInt): HRESULT; stdcall;
    function SetBitRate(ulBitRate: Cardinal): HRESULT; stdcall;
    function GetBitRate(out pulBitRate: Cardinal): HRESULT; stdcall;
    function SetProfile(uProfile: Cardinal): HRESULT; stdcall;
    function GetProfile(out puProfile: Cardinal): HRESULT; stdcall;
    function SetOutputFormat(uFormat: Cardinal): HRESULT; stdcall;
    function GetOutputFormat(out puFormat: Cardinal): HRESULT; stdcall;
    function SetTimeShift(timeShift: Integer): HRESULT; stdcall;
    function GetTimeShift(out ptimeShift: Integer): HRESULT; stdcall;
    function SetLFE(lfe: Cardinal): HRESULT; stdcall;
    function GetLFE(out p: Cardinal): HRESULT; stdcall;
    function SetTNS(tns: Cardinal): HRESULT; stdcall;
    function GetTNS(out p: Cardinal): HRESULT; stdcall;
    function SetMidSide(v: Cardinal): HRESULT; stdcall;
    function GetMidSide(out p: Cardinal): HRESULT; stdcall;
  end;
```

## AAC Profiles and Configuration

### AAC Profiles

**AAC-LC (Low Complexity) - Profile 2** (Recommended): - Best quality-to-bitrate ratio - Lowest computational complexity - Universal decoder support - Use for: Music, podcasts, video soundtracks - Bitrate range: 64-320 kbps **AAC-HE (High Efficiency) - Profile 5**: - Optimized for low bitrates - Uses Spectral Band Replication (SBR) - Better quality than AAC-LC at low bitrates (<= 64 kbps) - Use for: Streaming, voice, low-bitrate applications - Bitrate range: 32-80 kbps **AAC-HEv2 (High Efficiency version 2) - Profile 29**: - Further optimized for very low bitrates - Uses Parametric Stereo (PS) in addition to SBR - Best for mono/stereo at extremely low bitrates - Use for: Voice streaming, very low bandwidth - Bitrate range: 16-40 kbps

### Output Formats

**Raw AAC (Format 0)**: - Pure AAC bitstream without container - Requires external container (MP4, M4A, MKV) - Use for: Muxing into MP4/M4A files - Smallest output size **ADTS (Audio Data Transport Stream) - Format 1**: - AAC with frame headers - Self-contained, can be played directly - Slightly larger than raw AAC - Use for: Standalone AAC files, streaming - Better error resilience

### Recommended Bitrates

| Use Case | Channels | Profile | Bitrate | Notes |
| --- | --- | --- | --- | --- |
| Voice/Podcast (mono) | 1 | AAC-LC | 64-96 kbps | Clear speech |
| Voice/Podcast (stereo) | 2 | AAC-LC | 96-128 kbps | High quality speech |
| Music (stereo) standard | 2 | AAC-LC | 128-192 kbps | Good quality |
| Music (stereo) high quality | 2 | AAC-LC | 256-320 kbps | Excellent quality |
| Low-bandwidth streaming | 2 | AAC-HE | 48-64 kbps | Acceptable quality |
| Very low bandwidth | 1-2 | AAC-HEv2 | 24-40 kbps | Basic quality |
| 5.1 surround | 6 | AAC-LC | 384-512 kbps | Cinema quality |
| ## Usage Examples |  |  |  |  |
| ### C# Example - IMonogramAACEncoder (High Quality Music) |  |  |  |  |
| ``` using System; using DirectShowLib; using VisioForge.DirectShowAPI; public class MonogramAACHighQuality {     public void ConfigureHighQualityMusic(IBaseFilter audioEncoder)     {         // Query the Monogram AAC encoder interface         var aacEncoder = audioEncoder as IMonogramAACEncoder;         if (aacEncoder == null)         {             Console.WriteLine("Error: Filter does not support IMonogramAACEncoder");             return;         }         // Configure high quality stereo music encoding         var config = new AACConfig         {             version = 2,            // AAC version 2             object_type = 2,        // AAC-LC profile             output_type = 0,        // Raw AAC (for MP4 muxing)             bitrate = 192000        // 192 kbps         };         int hr = aacEncoder.SetConfig(ref config);         if (hr == 0)         {             Console.WriteLine("AAC encoder configured for high quality music:");             Console.WriteLine("  Profile: AAC-LC");             Console.WriteLine("  Bitrate: 192 kbps");             Console.WriteLine("  Output: Raw AAC for MP4 container");         }         else         {             Console.WriteLine($"Error configuring AAC encoder: 0x{hr:X8}");         }     } } ``` |  |  |  |  |
| ### C# Example - IVFAACEncoder (Comprehensive Configuration) |  |  |  |  |
| ``` public class VFAACHighQualityMusic {     public void ConfigureComprehensive(IBaseFilter audioEncoder)     {         // Query the VisioForge AAC encoder interface         var vfAacEncoder = audioEncoder as IVFAACEncoder;         if (vfAacEncoder == null)         {             Console.WriteLine("Error: Filter does not support IVFAACEncoder");             return;         }         // Configure comprehensive stereo music encoding         vfAacEncoder.SetInputSampleRate(48000);     // 48 kHz         vfAacEncoder.SetInputChannels(2);            // Stereo         vfAacEncoder.SetBitRate(256000);            // 256 kbps         vfAacEncoder.SetProfile(2);                 // AAC-LC         vfAacEncoder.SetOutputFormat(0);            // Raw AAC         vfAacEncoder.SetTNS(1);                     // Enable TNS         vfAacEncoder.SetMidSide(1);                 // Enable mid-side coding         vfAacEncoder.SetLFE(0);                     // No LFE (stereo only)         vfAacEncoder.SetTimeShift(0);               // No time shift         Console.WriteLine("VisioForge AAC encoder configured:");         // Verify configuration         vfAacEncoder.GetBitRate(out uint bitrate);         vfAacEncoder.GetProfile(out uint profile);         vfAacEncoder.GetInputChannels(out short channels);         Console.WriteLine($"  Bitrate: {bitrate / 1000} kbps");         Console.WriteLine($"  Profile: {(profile == 2 ? "AAC-LC" : profile.ToString())}");         Console.WriteLine($"  Channels: {channels}");     } } ``` |  |  |  |  |
| ### C# Example - Low Bitrate Streaming (AAC-HE) |  |  |  |  |
| ``` public class VFAACLowBitrateStreaming {     public void ConfigureLowBitrate(IBaseFilter audioEncoder)     {         var vfAacEncoder = audioEncoder as IVFAACEncoder;         if (vfAacEncoder == null)             return;         // Configure for low-bitrate streaming         vfAacEncoder.SetInputSampleRate(44100);     // 44.1 kHz         vfAacEncoder.SetInputChannels(2);            // Stereo         vfAacEncoder.SetBitRate(64000);             // 64 kbps         vfAacEncoder.SetProfile(5);                 // AAC-HE (High Efficiency)         vfAacEncoder.SetOutputFormat(1);            // ADTS for streaming         vfAacEncoder.SetTNS(1);                     // Enable TNS         vfAacEncoder.SetMidSide(1);                 // Enable mid-side         vfAacEncoder.SetLFE(0);                     // No LFE         Console.WriteLine("AAC-HE configured for low-bitrate streaming");         Console.WriteLine("  64 kbps stereo with ADTS output");     } } ``` |  |  |  |  |
| ### C# Example - Voice/Podcast Encoding |  |  |  |  |
| ``` public class VFAACVoicePodcast {     public void ConfigureVoicePodcast(IBaseFilter audioEncoder)     {         var vfAacEncoder = audioEncoder as IVFAACEncoder;         if (vfAacEncoder == null)             return;         // Configure for voice/podcast (mono)         vfAacEncoder.SetInputSampleRate(44100);     // 44.1 kHz         vfAacEncoder.SetInputChannels(1);            // Mono         vfAacEncoder.SetBitRate(80000);             // 80 kbps         vfAacEncoder.SetProfile(2);                 // AAC-LC         vfAacEncoder.SetOutputFormat(0);            // Raw AAC         vfAacEncoder.SetTNS(1);                     // Enable TNS for speech         vfAacEncoder.SetMidSide(0);                 // N/A for mono         vfAacEncoder.SetLFE(0);                     // No LFE         Console.WriteLine("AAC configured for voice/podcast");         Console.WriteLine("  80 kbps mono AAC-LC");     } } ``` |  |  |  |  |
| ### C++ Example - IMonogramAACEncoder |  |  |  |  |
| ``` #include <dshow.h> #include <iostream> #include "IMonogramAACEncoder.h" void ConfigureMonogramAAC(IBaseFilter* pAudioEncoder) {     IMonogramAACEncoder* pAACEncoder = NULL;     HRESULT hr = S_OK;     // Query the Monogram AAC encoder interface     hr = pAudioEncoder->QueryInterface(IID_IMonogramAACEncoder,                                        (void**)&pAACEncoder);     if (FAILED(hr) || !pAACEncoder)     {         std::cout << "Error: Filter does not support IMonogramAACEncoder" << std::endl;         return;     }     // Configure high quality music encoding     AACConfig config;     config.version = 2;         // AAC version 2     config.object_type = 2;     // AAC-LC     config.output_type = 0;     // Raw AAC     config.bitrate = 192000;    // 192 kbps     hr = pAACEncoder->SetConfig(&config);     if (SUCCEEDED(hr))     {         std::cout << "AAC encoder configured for high quality music" << std::endl;         std::cout << "  Profile: AAC-LC" << std::endl;         std::cout << "  Bitrate: 192 kbps" << std::endl;     }     pAACEncoder->Release(); } ``` |  |  |  |  |
| ### C++ Example - IVFAACEncoder |  |  |  |  |
| ``` #include "IVFAACEncoder.h" void ConfigureVFAAC(IBaseFilter* pAudioEncoder) {     IVFAACEncoder* pVFAACEncoder = NULL;     HRESULT hr = pAudioEncoder->QueryInterface(IID_IVFAACEncoder,                                                (void**)&pVFAACEncoder);     if (SUCCEEDED(hr) && pVFAACEncoder)     {         // Configure comprehensive stereo encoding         pVFAACEncoder->SetInputSampleRate(48000);   // 48 kHz         pVFAACEncoder->SetInputChannels(2);          // Stereo         pVFAACEncoder->SetBitRate(256000);          // 256 kbps         pVFAACEncoder->SetProfile(2);               // AAC-LC         pVFAACEncoder->SetOutputFormat(0);          // Raw AAC         pVFAACEncoder->SetTNS(1);                   // Enable TNS         pVFAACEncoder->SetMidSide(1);               // Enable mid-side         pVFAACEncoder->SetLFE(0);                   // No LFE         std::cout << "VisioForge AAC encoder configured" << std::endl;         pVFAACEncoder->Release();     } } ``` |  |  |  |  |
| ### Delphi Example - IMonogramAACEncoder |  |  |  |  |
| ``` uses   DirectShow9, ActiveX; procedure ConfigureMonogramAAC(AudioEncoder: IBaseFilter); var   AACEncoder: IMonogramAACEncoder;   Config: TAACConfig;   hr: HRESULT; begin   // Query the Monogram AAC encoder interface   hr := AudioEncoder.QueryInterface(IID_IMonogramAACEncoder, AACEncoder);   if Failed(hr) or (AACEncoder = nil) then   begin     WriteLn('Error: Filter does not support IMonogramAACEncoder');     Exit;   end;   try     // Configure high quality music encoding     Config.version := 2;         // AAC version 2     Config.object_type := 2;     // AAC-LC     Config.output_type := 0;     // Raw AAC     Config.bitrate := 192000;    // 192 kbps     hr := AACEncoder.SetConfig(Config);     if Succeeded(hr) then     begin       WriteLn('AAC encoder configured for high quality music');       WriteLn('  Profile: AAC-LC');       WriteLn('  Bitrate: 192 kbps');     end;   finally     AACEncoder := nil;   end; end; ``` |  |  |  |  |
| ### Delphi Example - IVFAACEncoder |  |  |  |  |
| ``` procedure ConfigureVFAAC(AudioEncoder: IBaseFilter); var   VFAACEncoder: IVFAACEncoder; begin   if Succeeded(AudioEncoder.QueryInterface(IID_IVFAACEncoder, VFAACEncoder)) then   begin     try       // Configure comprehensive stereo encoding       VFAACEncoder.SetInputSampleRate(48000);   // 48 kHz       VFAACEncoder.SetInputChannels(2);          // Stereo       VFAACEncoder.SetBitRate(256000);          // 256 kbps       VFAACEncoder.SetProfile(2);               // AAC-LC       VFAACEncoder.SetOutputFormat(0);          // Raw AAC       VFAACEncoder.SetTNS(1);                   // Enable TNS       VFAACEncoder.SetMidSide(1);               // Enable mid-side       VFAACEncoder.SetLFE(0);                   // No LFE       WriteLn('VisioForge AAC encoder configured');     finally       VFAACEncoder := nil;     end;   end; end; ``` |  |  |  |  |
| ## Best Practices |  |  |  |  |
| ### Profile Selection |  |  |  |  |
| **Use AAC-LC (Profile 2) when**: |  |  |  |  |
| - Encoding music or high-quality audio |  |  |  |  |
| - Bitrate >= 96 kbps |  |  |  |  |
| - Maximum decoder compatibility required |  |  |  |  |
| - **Recommended for most scenarios** |  |  |  |  |
| **Use AAC-HE (Profile 5) when**: |  |  |  |  |
| - Bitrate constraints (32-80 kbps) |  |  |  |  |
| - Streaming over limited bandwidth |  |  |  |  |
| - Voice/speech content acceptable at lower quality |  |  |  |  |
| - Mobile/web streaming applications |  |  |  |  |
| **Use AAC-HEv2 (Profile 29) when**: |  |  |  |  |
| - Extremely limited bandwidth (< 40 kbps) |  |  |  |  |
| - Voice-only content |  |  |  |  |
| - Mono or stereo only (not multichannel) |  |  |  |  |
| ### Bitrate Guidelines |  |  |  |  |
| **Mono Speech/Podcast**: |  |  |  |  |
| - Minimum: 48-64 kbps (AAC-LC) |  |  |  |  |
| - Recommended: 80-96 kbps (AAC-LC) |  |  |  |  |
| - High quality: 128 kbps (AAC-LC) |  |  |  |  |
| **Stereo Music**: |  |  |  |  |
| - Minimum: 96-128 kbps (AAC-LC) |  |  |  |  |
| - Recommended: 192-256 kbps (AAC-LC) |  |  |  |  |
| - High quality: 256-320 kbps (AAC-LC) |  |  |  |  |
| **Streaming Applications**: |  |  |  |  |
| - Low bandwidth: 48-64 kbps (AAC-HE, stereo) |  |  |  |  |
| - Standard bandwidth: 96-128 kbps (AAC-LC, stereo) |  |  |  |  |
| - High bandwidth: 192-256 kbps (AAC-LC, stereo) |  |  |  |  |
| ### Output Format Selection |  |  |  |  |
| **Use Raw AAC (Format 0) when**: |  |  |  |  |
| - Muxing into MP4, M4A, or MKV containers |  |  |  |  |
| - Container provides framing and synchronization |  |  |  |  |
| - **Recommended for most video/multimedia applications** |  |  |  |  |
| **Use ADTS (Format 1) when**: |  |  |  |  |
| - Creating standalone .aac files |  |  |  |  |
| - Streaming without container |  |  |  |  |
| - Better error recovery needed |  |  |  |  |
| - Testing/debugging audio independently |  |  |  |  |
| ### Feature Flags |  |  |  |  |
| **Temporal Noise Shaping (TNS)**: |  |  |  |  |
| - **Enable** for all encoding scenarios |  |  |  |  |
| - Improves transient response |  |  |  |  |
| - Better quality for percussive sounds |  |  |  |  |
| - Minimal computational overhead |  |  |  |  |
| **Mid-Side Stereo Coding**: |  |  |  |  |
| - **Enable** for stereo music encoding |  |  |  |  |
| - Improves compression efficiency |  |  |  |  |
| - Better stereo imaging |  |  |  |  |
| - No benefit for mono or uncorrelated stereo |  |  |  |  |
| **Low Frequency Effects (LFE)**: |  |  |  |  |
| - **Enable** only for 5.1/7.1 surround sound |  |  |  |  |
| - Dedicated subwoofer channel (.1) |  |  |  |  |
| - Disable for stereo/mono |  |  |  |  |
| ## Troubleshooting |  |  |  |  |
| ### Low Audio Quality |  |  |  |  |
| **Symptoms**: Muffled sound, artifacts, poor clarity |  |  |  |  |
| **Possible Causes**: |  |  |  |  |
| 1. Bitrate too low for content |  |  |  |  |
| 2. Wrong profile for bitrate |  |  |  |  |
| 3. TNS disabled |  |  |  |  |
| **Solutions**: |  |  |  |  |
| - Increase bitrate to recommended levels (see tables above) |  |  |  |  |
| - For low bitrates (<= 80 kbps), use AAC-HE instead of AAC-LC |  |  |  |  |
| - Enable TNS: `SetTNS(1)` |  |  |  |  |
| - For music, ensure bitrate >= 128 kbps with AAC-LC |  |  |  |  |
| ### Encoder Initialization Failures |  |  |  |  |
| **Symptoms**: SetConfig or Set methods return error codes |  |  |  |  |
| **Possible Causes**: |  |  |  |  |
| 1. Unsupported sample rate |  |  |  |  |
| 2. Invalid bitrate for profile |  |  |  |  |
| 3. Incompatible channel configuration |  |  |  |  |
| **Solutions**: |  |  |  |  |
| - Use standard sample rates: 44100, 48000 Hz |  |  |  |  |
| - Verify bitrate is appropriate for profile |  |  |  |  |
| - Check channel count matches source audio |  |  |  |  |
| - For AAC-HE, keep bitrate <= 128 kbps |  |  |  |  |
| ### File Won't Play |  |  |  |  |
| **Symptoms**: AAC file doesn't play in media players |  |  |  |  |
| **Possible Causes**: |  |  |  |  |
| 1. Raw AAC without container |  |  |  |  |
| 2. Unsupported profile |  |  |  |  |
| 3. Corrupted stream |  |  |  |  |
| **Solutions**: |  |  |  |  |
| - Use ADTS output format (`SetOutputFormat(1)`) for standalone files |  |  |  |  |
| - Use Raw AAC (`SetOutputFormat(0)`) only with MP4/M4A container |  |  |  |  |
| - Verify player supports AAC profile (HE/HEv2 may not be supported on old players) |  |  |  |  |
| - Ensure proper stream finalization in filter graph |  |  |  |  |
| ### Compatibility Issues |  |  |  |  |
| **Symptoms**: AAC plays on some devices but not others |  |  |  |  |
| **Possible Causes**: |  |  |  |  |
| 1. Advanced profile not supported (AAC-HE/HEv2) |  |  |  |  |
| 2. Non-standard configuration |  |  |  |  |
| **Solutions**: |  |  |  |  |
| - Use AAC-LC (Profile 2) for maximum compatibility |  |  |  |  |
| - Use standard sample rates (44100 or 48000 Hz) |  |  |  |  |
| - Keep bitrates within recommended ranges |  |  |  |  |
| - Avoid very low bitrates (< 64 kbps) for AAC-LC |  |  |  |  |
| --- |  |  |  |  |

## See Also

- [LAME MP3 Encoder Interface](../lame/)
- [FLAC Encoder Interface](../flac/)
- [Audio Codecs Reference](../../codecs-reference/)
- [MP4 Muxer Interface](../mp4-muxer/)
- [Encoding Filters Pack Overview](../../)

---END OF PAGE---


## FFmpeg Encoder DirectShow Filter - MPEG, FLV, DVD Output
**URL:** https://www.visioforge.com/help/docs/directshow/filters-enc/interfaces/ffmpeg/
**Description:** IVFFFMPEGEncoder COM interface for encoding to MPEG-1, MPEG-2, FLV, VCD, SVCD, DVD, and Transport Stream in DirectShow. Audio/video codec parameters for C++/C#.
**Tags:** DirectShow, C++, Windows, Streaming, Encoding, MP4, FLV, TS, H.264, MPEG-2, AC-3, C#
**API:** IVFFFMPEGEncoder, FFMPEGOutputSettings, IBaseFilter, CVFOutputSettings, TFFMPEGOutputSettings

# FFMPEG Encoder Interface Reference

## Overview

The **IVFFFMPEGEncoder** interface provides comprehensive configuration for encoding video and audio to various formats using the FFMPEG library. This powerful encoder supports multiple output formats including Flash Video (FLV), MPEG-1, MPEG-2, VCD, SVCD, DVD, and MPEG-2 Transport Stream.

The encoder uses a structure-based configuration approach where all encoding parameters are set at once, providing a simple yet complete interface for professional video encoding to legacy and streaming formats.

**Interface GUID**: `{17B8FF7D-A67F-45CE-B425-0E4F607D8C60}`

**Filter CLSID**: `{554AB365-B293-4C1D-9245-E8DB01F027F7}`

**Inherits From**: `IUnknown`

## Filter and Interface GUIDs

```
// FFMPEG Encoder Filter CLSID
public static readonly Guid CLSID_FFMPEGEncoder =
    new Guid("554AB365-B293-4C1D-9245-E8DB01F027F7");

// IVFFFMPEGEncoder Interface IID
public static readonly Guid IID_IVFFFMPEGEncoder =
    new Guid("17B8FF7D-A67F-45CE-B425-0E4F607D8C60");
```

## Output Formats

### VFFFMPEGDLLOutputFormat Enumeration

```
/// <summary>
/// FFMPEG encoder output format options.
/// </summary>
public enum VFFFMPEGDLLOutputFormat
{
    /// <summary>
    /// Flash Video (.flv) - Web streaming format
    /// </summary>
    FLV = 0,

    /// <summary>
    /// MPEG-1 (.mpg) - Standard MPEG-1 video
    /// </summary>
    MPEG1 = 1,

    /// <summary>
    /// MPEG-1 VCD - Video CD compliant format
    /// Resolution: 352x240 (NTSC) or 352x288 (PAL)
    /// Bitrate: 1150 kbps
    /// </summary>
    MPEG1VCD = 2,

    /// <summary>
    /// MPEG-2 (.mpg) - Standard MPEG-2 video
    /// </summary>
    MPEG2 = 3,

    /// <summary>
    /// MPEG-2 Transport Stream (.ts) - Broadcasting and streaming
    /// </summary>
    MPEG2TS = 4,

    /// <summary>
    /// MPEG-2 SVCD - Super Video CD compliant format
    /// Resolution: 480x480 (NTSC) or 480x576 (PAL)
    /// Bitrate: 2500 kbps
    /// </summary>
    MPEG2SVCD = 5,

    /// <summary>
    /// MPEG-2 DVD - DVD-Video compliant format
    /// Resolution: 720x480 (NTSC) or 720x576 (PAL)
    /// Bitrate: Up to 9800 kbps
    /// </summary>
    MPEG2DVD = 6
}
```

### TV System Standards

```
/// <summary>
/// Television system standards for video encoding.
/// </summary>
public enum VFFFMPEGDLLTVSystem
{
    /// <summary>
    /// No specific TV system / Auto-detect
    /// </summary>
    None = 0,

    /// <summary>
    /// PAL (Phase Alternating Line)
    /// 25 fps, 576 lines
    /// Used in: Europe, Asia, Australia, Africa
    /// </summary>
    PAL = 1,

    /// <summary>
    /// NTSC (National Television System Committee)
    /// 29.97 fps, 480 lines
    /// Used in: North America, Japan, South Korea
    /// </summary>
    NTSC = 2,

    /// <summary>
    /// Film standard
    /// 24 fps
    /// Used for: Cinema, film transfers
    /// </summary>
    Film = 3
}
```

## FFMPEGOutputSettings Structure

```
/// <summary>
/// Complete configuration structure for FFMPEG encoder.
/// Contains all audio, video, and output format settings.
/// </summary>
[StructLayout(LayoutKind.Sequential)]
public struct FFMPEGOutputSettings
{
    /// <summary>
    /// Output filename with path.
    /// </summary>
    [MarshalAs(UnmanagedType.LPWStr)]
    public string Filename;

    /// <summary>
    /// True if audio stream is included in output.
    /// </summary>
    [MarshalAs(UnmanagedType.Bool)]
    public bool AudioAvailable;

    /// <summary>
    /// Audio bitrate in bits per second (e.g., 128000 for 128 kbps).
    /// </summary>
    public int AudioBitrate;

    /// <summary>
    /// Audio sample rate in Hz (e.g., 44100, 48000).
    /// </summary>
    public int AudioSamplerate;

    /// <summary>
    /// Number of audio channels (1 = mono, 2 = stereo).
    /// </summary>
    public int AudioChannels;

    /// <summary>
    /// Video frame width in pixels.
    /// </summary>
    public int VideoWidth;

    /// <summary>
    /// Video frame height in pixels.
    /// </summary>
    public int VideoHeight;

    /// <summary>
    /// Display aspect ratio width (e.g., 16 for 16:9).
    /// </summary>
    public int AspectRatioW;

    /// <summary>
    /// Display aspect ratio height (e.g., 9 for 16:9).
    /// </summary>
    public int AspectRatioH;

    /// <summary>
    /// Video bitrate in bits per second (e.g., 5000000 for 5 Mbps).
    /// </summary>
    public int VideoBitrate;

    /// <summary>
    /// Maximum video bitrate for VBR encoding (bits per second).
    /// </summary>
    public int VideoMaxRate;

    /// <summary>
    /// Minimum video bitrate for VBR encoding (bits per second).
    /// </summary>
    public int VideoMinRate;

    /// <summary>
    /// Video buffer size in bits (affects latency and smoothness).
    /// </summary>
    public int VideoBufferSize;

    /// <summary>
    /// True to enable interlaced encoding (for broadcast TV).
    /// </summary>
    [MarshalAs(UnmanagedType.Bool)]
    public bool Interlace;

    /// <summary>
    /// GOP (Group of Pictures) size - keyframe interval.
    /// Typical: 12-15 for MPEG-2, 30-60 for web video.
    /// </summary>
    public int VideoGopSize;

    /// <summary>
    /// TV system standard (PAL, NTSC, Film, or None).
    /// </summary>
    [MarshalAs(UnmanagedType.I4)]
    public VFFFMPEGDLLTVSystem TVSystem;

    /// <summary>
    /// Output format (FLV, MPEG-1, MPEG-2, etc.).
    /// </summary>
    [MarshalAs(UnmanagedType.I4)]
    public VFFFMPEGDLLOutputFormat OutputFormat;
}
```

## Interface Definitions

### C# Definition

```
using System;
using System.Runtime.InteropServices;

namespace VisioForge.DirectShowAPI
{
    /// <summary>
    /// FFMPEG encoder configuration interface.
    /// Provides comprehensive encoding to multiple formats using FFMPEG library.
    /// </summary>
    [ComImport]
    [Guid("17B8FF7D-A67F-45CE-B425-0E4F607D8C60")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IVFFFMPEGEncoder
    {
        /// <summary>
        /// Sets the complete FFMPEG encoder configuration.
        /// All encoding parameters must be set at once via this structure.
        /// </summary>
        /// <param name="settings">Complete encoder settings structure</param>
        [PreserveSig]
        void set_settings([In] FFMPEGOutputSettings settings);
    }
}
```

### C++ Definition

```
#include <unknwn.h>

// {17B8FF7D-A67F-45CE-B425-0E4F607D8C60}
DEFINE_GUID(IID_IVFFFMPEGEncoder,
    0x17b8ff7d, 0xa67f, 0x45ce, 0xb4, 0x25, 0xe, 0x4f, 0x60, 0x7d, 0x8c, 0x60);

// {554AB365-B293-4C1D-9245-E8DB01F027F7}
DEFINE_GUID(CLSID_FFMPEGEncoder,
    0x554ab365, 0xb293, 0x4c1d, 0x92, 0x45, 0xe8, 0xdb, 0x01, 0xf0, 0x27, 0xf7);

/// <summary>
/// Output format enumeration.
/// </summary>
enum FFOutputFormat
{
    of_FLV = 0,
    of_MPEG1 = 1,
    of_MPEG1VCD = 2,
    of_MPEG2 = 3,
    of_MPEG2TS = 4,
    of_MPEG2SVCD = 5,
    of_MPEG2DVD = 6
};

/// <summary>
/// TV system enumeration.
/// </summary>
enum video_tv_system_t
{
    video_norm_unknown = 0,
    video_norm_pal = 1,
    video_norm_ntsc = 2,
    video_norm_film = 3
};

/// <summary>
/// FFMPEG encoder output settings structure.
/// </summary>
struct CVFOutputSettings
{
    wchar_t* filename;

    BOOL audioAvailable;
    int audioBitrate;
    int audioSamplerate;
    int audioChannels;

    int videoWidth;
    int videoHeight;
    int aspectRatioW;
    int aspectRatioH;
    int videoBitrate;
    int videoMaxRate;
    int videoMinRate;
    int videoBufferSize;
    BOOL interlace;
    int videoGopSize;
    int tvSystem;

    int outputFormat;
};

/// <summary>
/// FFMPEG encoder configuration interface.
/// </summary>
DECLARE_INTERFACE_(IVFFFMPEGEncoder, IUnknown)
{
    /// <summary>
    /// Sets the complete FFMPEG encoder configuration.
    /// </summary>
    /// <param name="settings">Complete encoder settings structure</param>
    STDMETHOD(set_settings)(THIS_
        CVFOutputSettings settings
        ) PURE;
};
```

### Delphi Definition

```
uses
  ActiveX, ComObj;

const
  IID_IVFFFMPEGEncoder: TGUID = '{17B8FF7D-A67F-45CE-B425-0E4F607D8C60}';
  CLSID_FFMPEGEncoder: TGUID = '{554AB365-B293-4C1D-9245-E8DB01F027F7}';

type
  /// <summary>
  /// FFMPEG output format enumeration.
  /// </summary>
  TVFFFMPEGDLLOutputFormat = (
    FLV,
    MPEG1,
    MPEG1VCD,
    MPEG2,
    MPEG2TS,
    MPEG2SVCD,
    MPEG2DVD
  );

  /// <summary>
  /// TV system enumeration. Note: the `None` member can collide with the bare
  /// `None` identifier exposed by other Delphi units (e.g., RTL's `Variants`).
  /// Reference values via the enum's qualified name —
  /// `TVFFFMPEGDLLTVSystem.None` — to avoid ambiguity in real code.
  /// </summary>
  TVFFFMPEGDLLTVSystem = (
    None,
    PAL,
    NTSC,
    Film
  );

  /// <summary>
  /// FFMPEG encoder output settings structure.
  /// </summary>
  TFFMPEGOutputSettings = record
    Filename: PWideChar;
    AudioAvailable: BOOL;
    AudioBitrate: Integer;
    AudioSamplerate: Integer;
    AudioChannels: Integer;
    VideoWidth: Integer;
    VideoHeight: Integer;
    AspectRatioW: Integer;
    AspectRatioH: Integer;
    VideoBitrate: Integer;
    VideoMaxRate: Integer;
    VideoMinRate: Integer;
    VideoBufferSize: Integer;
    Interlace: BOOL;
    VideoGopSize: Integer;
    TVSystem: Integer;
    OutputFormat: Integer;
  end;

  /// <summary>
  /// FFMPEG encoder configuration interface.
  /// </summary>
  IVFFFMPEGEncoder = interface(IUnknown)
    ['{17B8FF7D-A67F-45CE-B425-0E4F607D8C60}']

    /// <summary>
    /// Sets the complete FFMPEG encoder configuration.
    /// </summary>
    procedure set_settings(const settings: TFFMPEGOutputSettings); stdcall;
  end;
```

## Output Format Specifications

### FLV (Flash Video)

**Format**: Adobe Flash Video (.flv) **Use Cases**: Web streaming, legacy Flash content **Typical Settings**: - Resolution: 640x480, 854x480, 1280x720 - Video Bitrate: 500-2500 kbps - Audio: MP3, 64-128 kbps, 44100 Hz - GOP: 30-60 frames

### MPEG-1

**Format**: MPEG-1 video (.mpg) **Use Cases**: Basic video, legacy systems, web **Typical Settings**: - Resolution: 352x240 (NTSC), 352x288 (PAL) - Video Bitrate: 1150 kbps - Audio: MPEG Layer 2, 224 kbps, 44100 Hz - GOP: 12-15 frames

### MPEG-1 VCD (Video CD)

**Format**: Video CD compliant MPEG-1 (.mpg) **Use Cases**: VCD authoring, disc distribution **Required Settings**: - Resolution: 352x240 (NTSC), 352x288 (PAL) - Video Bitrate: 1150 kbps (fixed) - Audio: MPEG Layer 2, 224 kbps, 44100 Hz - GOP: 12 frames (NTSC), 15 frames (PAL) - TV System: Must match (NTSC or PAL)

### MPEG-2

**Format**: MPEG-2 video (.mpg) **Use Cases**: DVD authoring, broadcast, high quality **Typical Settings**: - Resolution: 720x480 (NTSC), 720x576 (PAL) - Video Bitrate: 4000-9800 kbps - Audio: MPEG Layer 2 or AC-3, 192-448 kbps - GOP: 12-15 frames

### MPEG-2 TS (Transport Stream)

**Format**: MPEG-2 Transport Stream (.ts) **Use Cases**: Broadcasting, streaming, Blu-ray **Typical Settings**: - Resolution: 720x480, 1280x720, 1920x1080 - Video Bitrate: 3000-15000 kbps - Audio: MPEG Layer 2 or AC-3 - GOP: 12-30 frames - Better error resilience than MPEG-2 PS

### MPEG-2 SVCD (Super Video CD)

**Format**: Super Video CD compliant MPEG-2 (.mpg) **Use Cases**: SVCD authoring, disc distribution **Required Settings**: - Resolution: 480x480 (NTSC), 480x576 (PAL) - Video Bitrate: 2500 kbps (typical) - Audio: MPEG Layer 2, 224 kbps, 44100 Hz - GOP: 12-15 frames - TV System: Must match (NTSC or PAL)

### MPEG-2 DVD (DVD-Video)

**Format**: DVD-Video compliant MPEG-2 (.mpg) **Use Cases**: DVD authoring, professional distribution **Required Settings**: - Resolution: 720x480 (NTSC), 720x576 (PAL) - Video Bitrate: 4000-9800 kbps - Audio: AC-3 or PCM, up to 448 kbps - GOP: 12 frames (NTSC), 15 frames (PAL) - TV System: Must match (NTSC or PAL) - Interlaced: Typically enabled for broadcast

## Usage Examples

### C# Example - DVD-Quality MPEG-2 (NTSC)

```
using System;
using DirectShowLib;
using VisioForge.DirectShowAPI;

public class FFMPEGDVDEncoder
{
    public void ConfigureDVDNTSC(IBaseFilter ffmpegEncoder)
    {
        // Query the FFMPEG encoder interface
        var encoder = ffmpegEncoder as IVFFFMPEGEncoder;
        if (encoder == null)
        {
            Console.WriteLine("Error: Filter does not support IVFFFMPEGEncoder");
            return;
        }

        // Configure DVD-compliant MPEG-2 encoding (NTSC)
        var settings = new FFMPEGOutputSettings
        {
            // Output file
            Filename = "C:\\output\\movie.mpg",

            // Audio settings
            AudioAvailable = true,
            AudioBitrate = 224000,      // 224 kbps
            AudioSamplerate = 48000,    // 48 kHz for DVD
            AudioChannels = 2,           // Stereo

            // Video settings - DVD NTSC specs
            VideoWidth = 720,
            VideoHeight = 480,
            AspectRatioW = 16,
            AspectRatioH = 9,
            VideoBitrate = 6000000,     // 6 Mbps
            VideoMaxRate = 9800000,     // 9.8 Mbps max for DVD
            VideoMinRate = 0,
            VideoBufferSize = 1835008,  // Standard DVD buffer
            Interlace = true,           // DVD is interlaced
            VideoGopSize = 12,          // 12 frames for NTSC

            // Format settings
            TVSystem = VFFFMPEGDLLTVSystem.NTSC,
            OutputFormat = VFFFMPEGDLLOutputFormat.MPEG2DVD
        };

        encoder.set_settings(settings);

        Console.WriteLine("FFMPEG encoder configured for DVD NTSC:");
        Console.WriteLine("  Resolution: 720x480 (16:9)");
        Console.WriteLine("  Video: 6 Mbps MPEG-2, interlaced");
        Console.WriteLine("  Audio: 224 kbps, 48 kHz stereo");
        Console.WriteLine("  GOP: 12 frames");
    }
}
```

### C# Example - Web Streaming FLV

```
public class FFMPEGWebStreaming
{
    public void ConfigureFLV(IBaseFilter ffmpegEncoder)
    {
        var encoder = ffmpegEncoder as IVFFFMPEGEncoder;
        if (encoder == null)
            return;

        // Configure Flash Video for web streaming
        var settings = new FFMPEGOutputSettings
        {
            Filename = "C:\\output\\video.flv",

            // Audio settings
            AudioAvailable = true,
            AudioBitrate = 96000,       // 96 kbps
            AudioSamplerate = 44100,
            AudioChannels = 2,

            // Video settings - 720p web streaming
            VideoWidth = 1280,
            VideoHeight = 720,
            AspectRatioW = 16,
            AspectRatioH = 9,
            VideoBitrate = 2000000,     // 2 Mbps
            VideoMaxRate = 2500000,     // 2.5 Mbps max
            VideoMinRate = 1500000,     // 1.5 Mbps min
            VideoBufferSize = 2000000,
            Interlace = false,          // Progressive for web
            VideoGopSize = 60,          // 2 seconds at 30fps

            TVSystem = VFFFMPEGDLLTVSystem.None,
            OutputFormat = VFFFMPEGDLLOutputFormat.FLV
        };

        encoder.set_settings(settings);

        Console.WriteLine("FFMPEG encoder configured for FLV web streaming:");
        Console.WriteLine("  720p @ 2 Mbps, progressive");
    }
}
```

### C# Example - VCD Compliant MPEG-1 (PAL)

```
public class FFMPEGVCDEncoder
{
    public void ConfigureVCDPAL(IBaseFilter ffmpegEncoder)
    {
        var encoder = ffmpegEncoder as IVFFFMPEGEncoder;
        if (encoder == null)
            return;

        // Configure VCD-compliant MPEG-1 (PAL)
        var settings = new FFMPEGOutputSettings
        {
            Filename = "C:\\output\\vcd.mpg",

            // Audio settings - VCD spec
            AudioAvailable = true,
            AudioBitrate = 224000,      // 224 kbps required
            AudioSamplerate = 44100,    // 44.1 kHz required
            AudioChannels = 2,

            // Video settings - VCD PAL specs
            VideoWidth = 352,
            VideoHeight = 288,          // PAL resolution
            AspectRatioW = 4,
            AspectRatioH = 3,
            VideoBitrate = 1150000,     // 1150 kbps required
            VideoMaxRate = 1150000,
            VideoMinRate = 1150000,
            VideoBufferSize = 327680,   // VCD buffer size
            Interlace = false,
            VideoGopSize = 15,          // 15 frames for PAL

            TVSystem = VFFFMPEGDLLTVSystem.PAL,
            OutputFormat = VFFFMPEGDLLOutputFormat.MPEG1VCD
        };

        encoder.set_settings(settings);

        Console.WriteLine("FFMPEG encoder configured for VCD PAL:");
        Console.WriteLine("  352x288 @ 1150 kbps");
    }
}
```

### C# Example - MPEG-2 Transport Stream

```
public class FFMPEGMPEG2TS
{
    public void ConfigureMPEG2TS(IBaseFilter ffmpegEncoder)
    {
        var encoder = ffmpegEncoder as IVFFFMPEGEncoder;
        if (encoder == null)
            return;

        // Configure MPEG-2 Transport Stream for broadcasting
        var settings = new FFMPEGOutputSettings
        {
            Filename = "C:\\output\\stream.ts",

            // Audio settings
            AudioAvailable = true,
            AudioBitrate = 192000,
            AudioSamplerate = 48000,
            AudioChannels = 2,

            // Video settings - 1080i HD broadcast
            VideoWidth = 1920,
            VideoHeight = 1080,
            AspectRatioW = 16,
            AspectRatioH = 9,
            VideoBitrate = 12000000,    // 12 Mbps
            VideoMaxRate = 15000000,    // 15 Mbps max
            VideoMinRate = 8000000,     // 8 Mbps min
            VideoBufferSize = 8000000,
            Interlace = true,           // Broadcast is interlaced
            VideoGopSize = 15,

            TVSystem = VFFFMPEGDLLTVSystem.NTSC,
            OutputFormat = VFFFMPEGDLLOutputFormat.MPEG2TS
        };

        encoder.set_settings(settings);

        Console.WriteLine("FFMPEG encoder configured for MPEG-2 TS:");
        Console.WriteLine("  1080i HD broadcast stream");
    }
}
```

### C++ Example - DVD NTSC

```
#include <dshow.h>
#include <iostream>
#include "InterfaceDefine.h"

void ConfigureFFMPEGDVD(IBaseFilter* pFFMPEGEncoder)
{
    IVFFFMPEGEncoder* pEncoder = NULL;
    HRESULT hr = S_OK;

    // Query the FFMPEG encoder interface
    hr = pFFMPEGEncoder->QueryInterface(IID_IVFFFMPEGEncoder,
                                        (void**)&pEncoder);
    if (FAILED(hr) || !pEncoder)
    {
        std::cout << "Error: Filter does not support IVFFFMPEGEncoder" << std::endl;
        return;
    }

    // Configure DVD-compliant MPEG-2 encoding (NTSC)
    CVFOutputSettings settings;
    ZeroMemory(&settings, sizeof(settings));

    settings.filename = L"C:\\output\\movie.mpg";

    // Audio settings
    settings.audioAvailable = TRUE;
    settings.audioBitrate = 224000;
    settings.audioSamplerate = 48000;
    settings.audioChannels = 2;

    // Video settings - DVD NTSC specs
    settings.videoWidth = 720;
    settings.videoHeight = 480;
    settings.aspectRatioW = 16;
    settings.aspectRatioH = 9;
    settings.videoBitrate = 6000000;
    settings.videoMaxRate = 9800000;
    settings.videoMinRate = 0;
    settings.videoBufferSize = 1835008;
    settings.interlace = TRUE;
    settings.videoGopSize = 12;

    settings.tvSystem = video_norm_ntsc;
    settings.outputFormat = of_MPEG2DVD;

    pEncoder->set_settings(settings);

    std::cout << "FFMPEG encoder configured for DVD NTSC" << std::endl;

    pEncoder->Release();
}
```

### C++ Example - FLV Web Streaming

```
void ConfigureFFMPEGFLV(IBaseFilter* pFFMPEGEncoder)
{
    IVFFFMPEGEncoder* pEncoder = NULL;
    HRESULT hr = pFFMPEGEncoder->QueryInterface(IID_IVFFFMPEGEncoder,
                                                (void**)&pEncoder);
    if (SUCCEEDED(hr) && pEncoder)
    {
        CVFOutputSettings settings;
        ZeroMemory(&settings, sizeof(settings));

        settings.filename = L"C:\\output\\video.flv";

        // Audio settings
        settings.audioAvailable = TRUE;
        settings.audioBitrate = 96000;
        settings.audioSamplerate = 44100;
        settings.audioChannels = 2;

        // Video settings - 720p web
        settings.videoWidth = 1280;
        settings.videoHeight = 720;
        settings.aspectRatioW = 16;
        settings.aspectRatioH = 9;
        settings.videoBitrate = 2000000;
        settings.videoMaxRate = 2500000;
        settings.videoMinRate = 1500000;
        settings.videoBufferSize = 2000000;
        settings.interlace = FALSE;
        settings.videoGopSize = 60;

        settings.tvSystem = video_norm_unknown;
        settings.outputFormat = of_FLV;

        pEncoder->set_settings(settings);

        std::cout << "FFMPEG FLV encoder configured" << std::endl;

        pEncoder->Release();
    }
}
```

### Delphi Example - DVD PAL

```
uses
  DirectShow9, ActiveX;

procedure ConfigureFFMPEGDVDPAL(FFMPEGEncoder: IBaseFilter);
var
  Encoder: IVFFFMPEGEncoder;
  Settings: TFFMPEGOutputSettings;
  hr: HRESULT;
begin
  hr := FFMPEGEncoder.QueryInterface(IID_IVFFFMPEGEncoder, Encoder);
  if Failed(hr) or (Encoder = nil) then
  begin
    WriteLn('Error: Filter does not support IVFFFMPEGEncoder');
    Exit;
  end;

  try
    ZeroMemory(@Settings, SizeOf(Settings));

    Settings.Filename := 'C:\output\movie.mpg';

    // Audio settings
    Settings.AudioAvailable := True;
    Settings.AudioBitrate := 224000;
    Settings.AudioSamplerate := 48000;
    Settings.AudioChannels := 2;

    // Video settings - DVD PAL specs
    Settings.VideoWidth := 720;
    Settings.VideoHeight := 576;
    Settings.AspectRatioW := 16;
    Settings.AspectRatioH := 9;
    Settings.VideoBitrate := 6000000;
    Settings.VideoMaxRate := 9800000;
    Settings.VideoMinRate := 0;
    Settings.VideoBufferSize := 1835008;
    Settings.Interlace := True;
    Settings.VideoGopSize := 15;

    Settings.TVSystem := Ord(PAL);
    Settings.OutputFormat := Ord(MPEG2DVD);

    Encoder.set_settings(Settings);

    WriteLn('FFMPEG encoder configured for DVD PAL');
  finally
    Encoder := nil;
  end;
end;
```

## Best Practices

### Format-Specific Recommendations

**For DVD Authoring (MPEG2DVD)**: - Always match TV system to target region (NTSC for Americas/Japan, PAL for Europe/Asia) - Use 720x480 for NTSC, 720x576 for PAL - Enable interlacing for broadcast compatibility - GOP: 12 frames (NTSC), 15 frames (PAL) - Video bitrate: 4-9.8 Mbps - Audio: 48 kHz, 224-448 kbps

**For VCD/SVCD (MPEG1VCD, MPEG2SVCD)**: - Strictly follow format specifications (resolution, bitrate) - Match TV system to target region - Use exact specified bitrates for best compatibility - Test on target hardware (standalone VCD/SVCD players)

**For Web Streaming (FLV)**: - Use progressive (non-interlaced) encoding - Lower bitrates for broader reach (500-2500 kbps) - GOP: 30-60 frames for seek points every 1-2 seconds - Consider modern alternatives (MP4/H.264) for better quality

**For Broadcasting (MPEG2TS)**: - Transport Stream has better error resilience - Use for live streaming and broadcast applications - Higher bitrates acceptable (10-15 Mbps for HD) - Match interlacing to broadcast standard

### Resolution and Aspect Ratio

**Standard Resolutions by Format**:

| Format | NTSC Resolution | PAL Resolution | Aspect Ratio |
| --- | --- | --- | --- |
| VCD | 352x240 | 352x288 | 4:3 |
| SVCD | 480x480 | 480x576 | 4:3 or 16:9 |
| DVD | 720x480 | 720x576 | 4:3 or 16:9 |
| FLV/MPEG-2 | Any | Any | Any |

**Aspect Ratio Settings**: - 4:3 standard: `AspectRatioW = 4, AspectRatioH = 3` - 16:9 widescreen: `AspectRatioW = 16, AspectRatioH = 9` - Ensure display aspect ratio matches pixel aspect ratio

### GOP Size Guidelines

**VCD/SVCD/DVD**: - NTSC: 12 frames (0.4 seconds at 29.97 fps) - PAL: 15 frames (0.6 seconds at 25 fps) - Required for format compliance

**Web Streaming**: - 30-60 frames (1-2 seconds) - Shorter GOP: Better seeking, larger file - Longer GOP: Smaller file, slower seeking

**Broadcast**: - 12-15 frames for high quality - Match to TV system standard

### Bitrate Configuration

**VBR (Variable Bitrate)**: - Set `VideoBitrate` (average), `VideoMinRate`, `VideoMaxRate` - Better quality for same average bitrate - Use for file-based encoding

**CBR (Constant Bitrate)**: - Set all three bitrates to the same value - Predictable file size and bandwidth - Use for streaming and broadcasting

### Audio Settings

**Sample Rates**: - 44100 Hz: CD quality, VCD/SVCD - 48000 Hz: DVD, professional broadcast - Match source when possible

**Bitrates**: - Mono speech: 64-96 kbps - Stereo music: 128-224 kbps - DVD audio: 192-448 kbps

## Troubleshooting

### Encoder Initialization Fails

**Symptoms**: `set_settings` call fails or crashes

**Possible Causes**: 1. Invalid filename or path 2. Incorrect format specifications 3. Unsupported resolution/bitrate combination

**Solutions**: - Ensure output directory exists and is writable - Verify resolution matches format requirements - Check bitrate is within format limits - For VCD/SVCD/DVD, strictly follow specifications

### Output File Won't Play

**Symptoms**: Encoded file doesn't play or has errors

**Possible Causes**: 1. Format specifications not met 2. Wrong TV system for format 3. Interlacing mismatch 4. GOP size issues

**Solutions**: - For DVD/VCD/SVCD: Use exact specification parameters - Match TV system to target region - Enable interlacing for DVD/broadcast - Use standard GOP sizes (12 for NTSC, 15 for PAL)

### Poor Video Quality

**Symptoms**: Blocky, blurry, or artifact-laden video

**Possible Causes**: 1. Bitrate too low for resolution 2. Incorrect GOP size 3. Bitrate range too restrictive

**Solutions**: - Increase video bitrate (see format recommendations) - For VBR, widen min/max bitrate range - Use appropriate GOP size for format - Ensure resolution matches format specifications

### A/V Sync Issues

**Symptoms**: Audio and video drift out of sync

**Possible Causes**: 1. Incorrect sample rate 2. Wrong frame rate for TV system 3. Buffer size issues

**Solutions**: - Use 48000 Hz for DVD, 44100 Hz for VCD - Ensure TV system matches source frame rate - Increase `VideoBufferSize` for complex content - Verify source audio/video are synchronized

### DVD/VCD Won't Play on Hardware

**Symptoms**: File plays on computer but not on standalone player

**Possible Causes**: 1. Format specifications not strictly followed 2. Wrong TV system 3. Non-compliant GOP size or bitrate

**Solutions**: - **Critical**: Use exact format specifications - VCD: 352x240/288, 1150 kbps, GOP 12/15 - DVD: 720x480/576, max 9.8 Mbps, GOP 12/15 - Match TV system to player region - Enable interlacing for DVD - Test with software DVD/VCD player first

### Large File Sizes

**Symptoms**: Output files larger than expected

**Possible Causes**: 1. Bitrate too high 2. CBR instead of VBR 3. Small GOP size

**Solutions**: - Reduce video bitrate - Use VBR with appropriate min/max range - Increase GOP size (for non-DVD/VCD formats) - Consider more efficient formats (H.264/MP4 instead of MPEG-2)

---

## See Also

- [H.264 Encoder Interface](../h264/)
- [Video Codecs Reference](../../codecs-reference/)
- [MP4 Muxer Interface](../mp4-muxer/)
- [Encoding Filters Pack Overview](../../)

---END OF PAGE---


## FLAC Lossless Audio Encoder DirectShow Filter Interface
**URL:** https://www.visioforge.com/help/docs/directshow/filters-enc/interfaces/flac/
**Description:** FLAC encoder DirectShow interface with encoding levels, LPC configuration, block sizes, and compression for lossless audio encoding.
**Tags:** DirectShow, C++, Windows, Encoding, Decoding, MP3, FLAC, C#
**API:** FLACEncoder, IFLACEncodeSettings, IBaseFilter, AudioEncoder, FLACArchivalEncoder

# FLAC Encoder Interface Reference

## Overview

The **IFLACEncodeSettings** interface provides complete control over FLAC (Free Lossless Audio Codec) audio encoding parameters in DirectShow filter graphs. FLAC is a lossless audio compression format that reduces file size without any loss in audio quality, making it ideal for archival, professional audio production, and high-fidelity music distribution.

This interface allows developers to configure encoding quality levels, Linear Predictive Coding (LPC) parameters, block sizes, mid-side stereo coding, and Rice partition orders to achieve optimal compression efficiency for different types of audio content.

**Interface GUID**: `{A6096781-2A65-4540-A536-011235D0A5FE}`

**Inherits From**: `IUnknown`

## Interface Definitions

### C# Definition

```
using System;
using System.Runtime.InteropServices;

namespace VisioForge.DirectShowAPI
{
    /// <summary>
    /// FLAC (Free Lossless Audio Codec) encoder configuration interface.
    /// Provides comprehensive control over FLAC encoding parameters for lossless audio compression.
    /// </summary>
    [ComImport]
    [Guid("A6096781-2A65-4540-A536-011235D0A5FE")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IFLACEncodeSettings
    {
        /// <summary>
        /// Checks if encoding settings can be modified at the current time.
        /// </summary>
        /// <returns>True if settings can be modified, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool canModifySettings();

        /// <summary>
        /// Sets the FLAC encoding level (compression quality).
        /// </summary>
        /// <param name="inLevel">Encoding level (0-8, where 8 is highest compression, slowest)</param>
        /// <returns>True if successful, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool setEncodingLevel(uint inLevel);

        /// <summary>
        /// Sets the Linear Predictive Coding (LPC) order.
        /// Higher values provide better compression but slower encoding.
        /// </summary>
        /// <param name="inLPCOrder">LPC order (typically 0-32)</param>
        /// <returns>True if successful, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool setLPCOrder(uint inLPCOrder);

        /// <summary>
        /// Sets the audio block size for encoding.
        /// Larger blocks can provide better compression but increase latency.
        /// </summary>
        /// <param name="inBlockSize">Block size in samples (typically 192-4608)</param>
        /// <returns>True if successful, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool setBlockSize(uint inBlockSize);

        /// <summary>
        /// Enables or disables mid-side stereo coding for 2-channel audio.
        /// Can improve compression for stereo audio with correlated channels.
        /// </summary>
        /// <param name="inUseMidSideCoding">True to enable mid-side coding, false to disable</param>
        /// <returns>True if successful, false otherwise</returns>
        /// <remarks>Only applicable for 2-channel (stereo) audio</remarks>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool useMidSideCoding([In, MarshalAs(UnmanagedType.Bool)] bool inUseMidSideCoding);

        /// <summary>
        /// Enables or disables adaptive mid-side stereo coding.
        /// Automatically decides whether to use mid-side coding on a per-block basis.
        /// Overrides useMidSideCoding and is generally faster.
        /// </summary>
        /// <param name="inUseAdaptiveMidSideCoding">True to enable adaptive mid-side coding, false to disable</param>
        /// <returns>True if successful, false otherwise</returns>
        /// <remarks>Only for 2-channel audio. Overrides useMidSideCoding setting. Generally provides better performance.</remarks>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool useAdaptiveMidSideCoding([In, MarshalAs(UnmanagedType.Bool)] bool inUseAdaptiveMidSideCoding);

        /// <summary>
        /// Enables or disables exhaustive model search for best compression.
        /// Significantly slower but can provide better compression ratios.
        /// </summary>
        /// <param name="inUseExhaustiveModelSearch">True to enable exhaustive search, false to disable</param>
        /// <returns>True if successful, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool useExhaustiveModelSearch([In, MarshalAs(UnmanagedType.Bool)] bool inUseExhaustiveModelSearch);

        /// <summary>
        /// Sets the Rice partition order range for entropy coding.
        /// Controls the trade-off between compression efficiency and encoding speed.
        /// </summary>
        /// <param name="inMin">Minimum Rice partition order</param>
        /// <param name="inMax">Maximum Rice partition order</param>
        /// <returns>True if successful, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool setRicePartitionOrder(uint inMin, uint inMax);

        /// <summary>
        /// Gets the current encoding level setting.
        /// </summary>
        /// <returns>Current encoding level (0-8)</returns>
        [PreserveSig]
        int encoderLevel();

        /// <summary>
        /// Gets the current Linear Predictive Coding (LPC) order.
        /// </summary>
        /// <returns>Current LPC order</returns>
        [PreserveSig]
        uint LPCOrder();

        /// <summary>
        /// Gets the current block size setting.
        /// </summary>
        /// <returns>Current block size in samples</returns>
        [PreserveSig]
        uint blockSize();

        /// <summary>
        /// Gets the minimum Rice partition order.
        /// </summary>
        /// <returns>Minimum Rice partition order</returns>
        [PreserveSig]
        uint riceMin();

        /// <summary>
        /// Gets the maximum Rice partition order.
        /// </summary>
        /// <returns>Maximum Rice partition order</returns>
        [PreserveSig]
        uint riceMax();

        /// <summary>
        /// Checks if mid-side stereo coding is enabled.
        /// </summary>
        /// <returns>True if mid-side coding is enabled, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool isUsingMidSideCoding();

        /// <summary>
        /// Checks if adaptive mid-side stereo coding is enabled.
        /// </summary>
        /// <returns>True if adaptive mid-side coding is enabled, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool isUsingAdaptiveMidSideCoding();

        /// <summary>
        /// Checks if exhaustive model search is enabled.
        /// </summary>
        /// <returns>True if exhaustive model search is enabled, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool isUsingExhaustiveModel();
    }
}
```

### C++ Definition

```
#include <unknwn.h>

// {A6096781-2A65-4540-A536-011235D0A5FE}
DEFINE_GUID(IID_IFLACEncodeSettings,
    0xa6096781, 0x2a65, 0x4540, 0xa5, 0x36, 0x01, 0x12, 0x35, 0xd0, 0xa5, 0xfe);

/// <summary>
/// FLAC (Free Lossless Audio Codec) encoder configuration interface.
/// Provides comprehensive control over FLAC encoding parameters for lossless audio compression.
/// </summary>
DECLARE_INTERFACE_(IFLACEncodeSettings, IUnknown)
{
    /// <summary>
    /// Checks if encoding settings can be modified at the current time.
    /// </summary>
    /// <returns>TRUE if settings can be modified, FALSE otherwise</returns>
    STDMETHOD_(BOOL, canModifySettings)(THIS) PURE;

    /// <summary>
    /// Sets the FLAC encoding level (compression quality).
    /// </summary>
    /// <param name="inLevel">Encoding level (0-8, where 8 is highest compression, slowest)</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    STDMETHOD_(BOOL, setEncodingLevel)(THIS_
        unsigned long inLevel
        ) PURE;

    /// <summary>
    /// Sets the Linear Predictive Coding (LPC) order.
    /// Higher values provide better compression but slower encoding.
    /// </summary>
    /// <param name="inLPCOrder">LPC order (typically 0-32)</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    STDMETHOD_(BOOL, setLPCOrder)(THIS_
        unsigned long inLPCOrder
        ) PURE;

    /// <summary>
    /// Sets the audio block size for encoding.
    /// Larger blocks can provide better compression but increase latency.
    /// </summary>
    /// <param name="inBlockSize">Block size in samples (typically 192-4608)</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    STDMETHOD_(BOOL, setBlockSize)(THIS_
        unsigned long inBlockSize
        ) PURE;

    /// <summary>
    /// Enables or disables mid-side stereo coding for 2-channel audio.
    /// Can improve compression for stereo audio with correlated channels.
    /// </summary>
    /// <param name="inUseMidSideCoding">TRUE to enable mid-side coding, FALSE to disable</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    /// <remarks>Only applicable for 2-channel (stereo) audio</remarks>
    STDMETHOD_(BOOL, useMidSideCoding)(THIS_
        BOOL inUseMidSideCoding
        ) PURE;

    /// <summary>
    /// Enables or disables adaptive mid-side stereo coding.
    /// Automatically decides whether to use mid-side coding on a per-block basis.
    /// Overrides useMidSideCoding and is generally faster.
    /// </summary>
    /// <param name="inUseAdaptiveMidSideCoding">TRUE to enable adaptive mid-side coding, FALSE to disable</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    /// <remarks>Only for 2-channel audio. Overrides useMidSideCoding setting. Generally provides better performance.</remarks>
    STDMETHOD_(BOOL, useAdaptiveMidSideCoding)(THIS_
        BOOL inUseAdaptiveMidSideCoding
        ) PURE;

    /// <summary>
    /// Enables or disables exhaustive model search for best compression.
    /// Significantly slower but can provide better compression ratios.
    /// </summary>
    /// <param name="inUseExhaustiveModelSearch">TRUE to enable exhaustive search, FALSE to disable</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    STDMETHOD_(BOOL, useExhaustiveModelSearch)(THIS_
        BOOL inUseExhaustiveModelSearch
        ) PURE;

    /// <summary>
    /// Sets the Rice partition order range for entropy coding.
    /// Controls the trade-off between compression efficiency and encoding speed.
    /// </summary>
    /// <param name="inMin">Minimum Rice partition order</param>
    /// <param name="inMax">Maximum Rice partition order</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    STDMETHOD_(BOOL, setRicePartitionOrder)(THIS_
        unsigned long inMin,
        unsigned long inMax
        ) PURE;

    /// <summary>
    /// Gets the current encoding level setting.
    /// </summary>
    /// <returns>Current encoding level (0-8)</returns>
    STDMETHOD_(int, encoderLevel)(THIS) PURE;

    /// <summary>
    /// Gets the current Linear Predictive Coding (LPC) order.
    /// </summary>
    /// <returns>Current LPC order</returns>
    STDMETHOD_(unsigned long, LPCOrder)(THIS) PURE;

    /// <summary>
    /// Gets the current block size setting.
    /// </summary>
    /// <returns>Current block size in samples</returns>
    STDMETHOD_(unsigned long, blockSize)(THIS) PURE;

    /// <summary>
    /// Gets the minimum Rice partition order.
    /// </summary>
    /// <returns>Minimum Rice partition order</returns>
    STDMETHOD_(unsigned long, riceMin)(THIS) PURE;

    /// <summary>
    /// Gets the maximum Rice partition order.
    /// </summary>
    /// <returns>Maximum Rice partition order</returns>
    STDMETHOD_(unsigned long, riceMax)(THIS) PURE;

    /// <summary>
    /// Checks if mid-side stereo coding is enabled.
    /// </summary>
    /// <returns>TRUE if mid-side coding is enabled, FALSE otherwise</returns>
    STDMETHOD_(BOOL, isUsingMidSideCoding)(THIS) PURE;

    /// <summary>
    /// Checks if adaptive mid-side stereo coding is enabled.
    /// </summary>
    /// <returns>TRUE if adaptive mid-side coding is enabled, FALSE otherwise</returns>
    STDMETHOD_(BOOL, isUsingAdaptiveMidSideCoding)(THIS) PURE;

    /// <summary>
    /// Checks if exhaustive model search is enabled.
    /// </summary>
    /// <returns>TRUE if exhaustive model search is enabled, FALSE otherwise</returns>
    STDMETHOD_(BOOL, isUsingExhaustiveModel)(THIS) PURE;
};
```

### Delphi Definition

```
uses
  ActiveX, ComObj;

const
  IID_IFLACEncodeSettings: TGUID = '{A6096781-2A65-4540-A536-011235D0A5FE}';

type
  /// <summary>
  /// FLAC (Free Lossless Audio Codec) encoder configuration interface.
  /// Provides comprehensive control over FLAC encoding parameters for lossless audio compression.
  /// </summary>
  IFLACEncodeSettings = interface(IUnknown)
    ['{A6096781-2A65-4540-A536-011235D0A5FE}']

    /// <summary>
    /// Checks if encoding settings can be modified at the current time.
    /// </summary>
    /// <returns>True if settings can be modified, false otherwise</returns>
    function canModifySettings: BOOL; stdcall;

    /// <summary>
    /// Sets the FLAC encoding level (compression quality).
    /// </summary>
    /// <param name="inLevel">Encoding level (0-8, where 8 is highest compression, slowest)</param>
    /// <returns>True if successful, false otherwise</returns>
    function setEncodingLevel(inLevel: Cardinal): BOOL; stdcall;

    /// <summary>
    /// Sets the Linear Predictive Coding (LPC) order.
    /// Higher values provide better compression but slower encoding.
    /// </summary>
    /// <param name="inLPCOrder">LPC order (typically 0-32)</param>
    /// <returns>True if successful, false otherwise</returns>
    function setLPCOrder(inLPCOrder: Cardinal): BOOL; stdcall;

    /// <summary>
    /// Sets the audio block size for encoding.
    /// Larger blocks can provide better compression but increase latency.
    /// </summary>
    /// <param name="inBlockSize">Block size in samples (typically 192-4608)</param>
    /// <returns>True if successful, false otherwise</returns>
    function setBlockSize(inBlockSize: Cardinal): BOOL; stdcall;

    /// <summary>
    /// Enables or disables mid-side stereo coding for 2-channel audio.
    /// Can improve compression for stereo audio with correlated channels.
    /// </summary>
    /// <param name="inUseMidSideCoding">True to enable mid-side coding, false to disable</param>
    /// <returns>True if successful, false otherwise</returns>
    /// <remarks>Only applicable for 2-channel (stereo) audio</remarks>
    function useMidSideCoding(inUseMidSideCoding: BOOL): BOOL; stdcall;

    /// <summary>
    /// Enables or disables adaptive mid-side stereo coding.
    /// Automatically decides whether to use mid-side coding on a per-block basis.
    /// Overrides useMidSideCoding and is generally faster.
    /// </summary>
    /// <param name="inUseAdaptiveMidSideCoding">True to enable adaptive mid-side coding, false to disable</param>
    /// <returns>True if successful, false otherwise</returns>
    /// <remarks>Only for 2-channel audio. Overrides useMidSideCoding setting. Generally provides better performance.</remarks>
    function useAdaptiveMidSideCoding(inUseAdaptiveMidSideCoding: BOOL): BOOL; stdcall;

    /// <summary>
    /// Enables or disables exhaustive model search for best compression.
    /// Significantly slower but can provide better compression ratios.
    /// </summary>
    /// <param name="inUseExhaustiveModelSearch">True to enable exhaustive search, false to disable</param>
    /// <returns>True if successful, false otherwise</returns>
    function useExhaustiveModelSearch(inUseExhaustiveModelSearch: BOOL): BOOL; stdcall;

    /// <summary>
    /// Sets the Rice partition order range for entropy coding.
    /// Controls the trade-off between compression efficiency and encoding speed.
    /// </summary>
    /// <param name="inMin">Minimum Rice partition order</param>
    /// <param name="inMax">Maximum Rice partition order</param>
    /// <returns>True if successful, false otherwise</returns>
    function setRicePartitionOrder(inMin: Cardinal; inMax: Cardinal): BOOL; stdcall;

    /// <summary>
    /// Gets the current encoding level setting.
    /// </summary>
    /// <returns>Current encoding level (0-8)</returns>
    function encoderLevel: Integer; stdcall;

    /// <summary>
    /// Gets the current Linear Predictive Coding (LPC) order.
    /// </summary>
    /// <returns>Current LPC order</returns>
    function LPCOrder: Cardinal; stdcall;

    /// <summary>
    /// Gets the current block size setting.
    /// </summary>
    /// <returns>Current block size in samples</returns>
    function blockSize: Cardinal; stdcall;

    /// <summary>
    /// Gets the minimum Rice partition order.
    /// </summary>
    /// <returns>Minimum Rice partition order</returns>
    function riceMin: Cardinal; stdcall;

    /// <summary>
    /// Gets the maximum Rice partition order.
    /// </summary>
    /// <returns>Maximum Rice partition order</returns>
    function riceMax: Cardinal; stdcall;

    /// <summary>
    /// Checks if mid-side stereo coding is enabled.
    /// </summary>
    /// <returns>True if mid-side coding is enabled, false otherwise</returns>
    function isUsingMidSideCoding: BOOL; stdcall;

    /// <summary>
    /// Checks if adaptive mid-side stereo coding is enabled.
    /// </summary>
    /// <returns>True if adaptive mid-side coding is enabled, false otherwise</returns>
    function isUsingAdaptiveMidSideCoding: BOOL; stdcall;

    /// <summary>
    /// Checks if exhaustive model search is enabled.
    /// </summary>
    /// <returns>True if exhaustive model search is enabled, false otherwise</returns>
    function isUsingExhaustiveModel: BOOL; stdcall;
  end;
```

## Method Reference

### Configuration Check

#### canModifySettings

Checks if encoding settings can be modified at the current time. This is useful to verify the encoder is in a state where configuration changes are allowed (typically before the filter graph starts running).

**Returns**: `true` if settings can be modified, `false` otherwise

**Example Usage**:

```
if (flacEncoder.canModifySettings())
{
    // Safe to modify encoder settings
    flacEncoder.setEncodingLevel(5);
}
```

### Encoding Configuration Methods

#### setEncodingLevel

Sets the FLAC encoding level, which controls the compression quality and encoding speed trade-off.

**Parameters**: - `inLevel` - Encoding level (0-8): - 0 = Fastest encoding, lowest compression - 5 = Balanced (recommended for most uses) - 8 = Slowest encoding, highest compression

**Returns**: `true` if successful, `false` otherwise

**Recommended Values**: - **Fast archival**: Level 3-5 - **High-quality archival**: Level 6-8 - **Real-time encoding**: Level 0-2

#### setLPCOrder

Sets the Linear Predictive Coding (LPC) order, which affects compression efficiency and encoding speed.

**Parameters**: - `inLPCOrder` - LPC order value (typically 0-32) - 0 = No LPC (fastest) - 12 = Default for most audio - 32 = Maximum compression (slowest)

**Returns**: `true` if successful, `false` otherwise

**Note**: Higher LPC orders provide better compression but significantly increase encoding time.

#### setBlockSize

Sets the audio block size for encoding. The block size affects both compression efficiency and latency.

**Parameters**: - `inBlockSize` - Block size in samples - Common values: 192, 576, 1152, 2304, 4608 - Default is typically 4096 for 44.1kHz audio

**Returns**: `true` if successful, `false` otherwise

**Recommendations**: - **Low latency**: 192-1152 samples - **Standard archival**: 4096 samples - **Maximum compression**: 4608 samples

#### useMidSideCoding

Enables or disables mid-side stereo coding for 2-channel audio. Mid-side coding can improve compression for stereo audio where the left and right channels are highly correlated.

**Parameters**: - `inUseMidSideCoding` - `true` to enable, `false` to disable

**Returns**: `true` if successful, `false` otherwise

**Note**: Only applicable for 2-channel (stereo) audio. Most music benefits from mid-side coding.

#### useAdaptiveMidSideCoding

Enables or disables adaptive mid-side stereo coding. This mode automatically decides whether to use mid-side coding on a per-block basis, providing better compression than fixed mid-side coding.

**Parameters**: - `inUseAdaptiveMidSideCoding` - `true` to enable, `false` to disable

**Returns**: `true` if successful, `false` otherwise

**Note**: - Only for 2-channel audio - Overrides `useMidSideCoding` setting - Generally provides better performance than fixed mid-side coding - Recommended for most stereo encoding scenarios

#### useExhaustiveModelSearch

Enables or disables exhaustive model search for finding the best compression predictor.

**Parameters**: - `inUseExhaustiveModelSearch` - `true` to enable, `false` to disable

**Returns**: `true` if successful, `false` otherwise

**Warning**: Exhaustive search significantly slows down encoding (often 2-4x slower) but can provide marginally better compression (typically 1-3% file size reduction).

**Recommended**: Only enable for archival of critical audio where encoding time is not a concern.

#### setRicePartitionOrder

Sets the Rice partition order range for entropy coding. Rice coding is the final compression stage in FLAC.

**Parameters**: - `inMin` - Minimum Rice partition order (typically 0-2) - `inMax` - Maximum Rice partition order (typically 3-8)

**Returns**: `true` if successful, `false` otherwise

**Typical Values**: - Fast encoding: min=0, max=3 - Standard encoding: min=0, max=6 - Maximum compression: min=0, max=8

### Status Query Methods

#### encoderLevel

Gets the current encoding level setting.

**Returns**: Current encoding level (0-8)

#### LPCOrder

Gets the current Linear Predictive Coding (LPC) order.

**Returns**: Current LPC order value

#### blockSize

Gets the current block size setting.

**Returns**: Current block size in samples

#### riceMin

Gets the minimum Rice partition order.

**Returns**: Minimum Rice partition order

#### riceMax

Gets the maximum Rice partition order.

**Returns**: Maximum Rice partition order

#### isUsingMidSideCoding

Checks if fixed mid-side stereo coding is enabled.

**Returns**: `true` if mid-side coding is enabled, `false` otherwise

#### isUsingAdaptiveMidSideCoding

Checks if adaptive mid-side stereo coding is enabled.

**Returns**: `true` if adaptive mid-side coding is enabled, `false` otherwise

#### isUsingExhaustiveModel

Checks if exhaustive model search is enabled.

**Returns**: `true` if exhaustive model search is enabled, `false` otherwise

## Usage Examples

### C# Example - High Quality Archival

```
using System;
using DirectShowLib;
using VisioForge.DirectShowAPI;

public class FLACArchivalEncoder
{
    public void ConfigureHighQualityArchival(IBaseFilter audioEncoder)
    {
        // Query the FLAC encoder interface
        var flacEncoder = audioEncoder as IFLACEncodeSettings;
        if (flacEncoder == null)
        {
            Console.WriteLine("Error: Filter does not support IFLACEncodeSettings");
            return;
        }

        // Check if we can modify settings
        if (!flacEncoder.canModifySettings())
        {
            Console.WriteLine("Warning: Cannot modify encoder settings at this time");
            return;
        }

        // High quality archival settings
        flacEncoder.setEncodingLevel(8);              // Maximum compression
        flacEncoder.setLPCOrder(12);                  // Good LPC order for music
        flacEncoder.setBlockSize(4096);               // Standard block size for 44.1kHz
        flacEncoder.useAdaptiveMidSideCoding(true);   // Adaptive mid-side for stereo
        flacEncoder.useExhaustiveModelSearch(true);   // Best possible compression
        flacEncoder.setRicePartitionOrder(0, 8);      // Maximum Rice partition range

        Console.WriteLine("FLAC encoder configured for high-quality archival:");
        Console.WriteLine($"  Encoding Level: {flacEncoder.encoderLevel()}");
        Console.WriteLine($"  LPC Order: {flacEncoder.LPCOrder()}");
        Console.WriteLine($"  Block Size: {flacEncoder.blockSize()}");
        Console.WriteLine($"  Adaptive Mid-Side: {flacEncoder.isUsingAdaptiveMidSideCoding()}");
        Console.WriteLine($"  Exhaustive Search: {flacEncoder.isUsingExhaustiveModel()}");
        Console.WriteLine($"  Rice Partition: {flacEncoder.riceMin()}-{flacEncoder.riceMax()}");
    }
}
```

### C# Example - Fast Real-Time Encoding

```
public class FLACRealTimeEncoder
{
    public void ConfigureFastEncoding(IBaseFilter audioEncoder)
    {
        var flacEncoder = audioEncoder as IFLACEncodeSettings;
        if (flacEncoder == null || !flacEncoder.canModifySettings())
            return;

        // Fast encoding settings for real-time use
        flacEncoder.setEncodingLevel(2);              // Fast encoding
        flacEncoder.setLPCOrder(8);                   // Lower LPC for speed
        flacEncoder.setBlockSize(1152);               // Smaller blocks for lower latency
        flacEncoder.useAdaptiveMidSideCoding(true);   // Still good compression
        flacEncoder.useExhaustiveModelSearch(false);  // Disable for speed
        flacEncoder.setRicePartitionOrder(0, 4);      // Reduced Rice partition range

        Console.WriteLine("FLAC encoder configured for fast real-time encoding");
        Console.WriteLine($"  Encoding Level: {flacEncoder.encoderLevel()}");
        Console.WriteLine($"  LPC Order: {flacEncoder.LPCOrder()}");
        Console.WriteLine($"  Block Size: {flacEncoder.blockSize()} (lower latency)");
    }
}
```

### C# Example - Balanced Music Encoding

```
public class FLACMusicEncoder
{
    public void ConfigureBalancedMusic(IBaseFilter audioEncoder)
    {
        var flacEncoder = audioEncoder as IFLACEncodeSettings;
        if (flacEncoder == null || !flacEncoder.canModifySettings())
            return;

        // Balanced settings for music encoding (good compression, reasonable speed)
        flacEncoder.setEncodingLevel(5);              // Balanced compression
        flacEncoder.setLPCOrder(12);                  // Standard LPC for music
        flacEncoder.setBlockSize(4096);               // Optimal for 44.1kHz
        flacEncoder.useAdaptiveMidSideCoding(true);   // Adaptive mid-side
        flacEncoder.useExhaustiveModelSearch(false);  // Not needed for music
        flacEncoder.setRicePartitionOrder(0, 6);      // Good Rice partition range

        Console.WriteLine("FLAC encoder configured for balanced music encoding");
    }
}
```

### C++ Example - High Quality Archival

```
#include <dshow.h>
#include <iostream>
#include "IFLACEncodeSettings.h"

void ConfigureHighQualityFLAC(IBaseFilter* pAudioEncoder)
{
    IFLACEncodeSettings* pFLACEncoder = NULL;
    HRESULT hr = S_OK;

    // Query the FLAC encoder interface
    hr = pAudioEncoder->QueryInterface(IID_IFLACEncodeSettings,
                                       (void**)&pFLACEncoder);
    if (FAILED(hr) || !pFLACEncoder)
    {
        std::cout << "Error: Filter does not support IFLACEncodeSettings" << std::endl;
        return;
    }

    // Check if we can modify settings
    if (!pFLACEncoder->canModifySettings())
    {
        std::cout << "Warning: Cannot modify encoder settings" << std::endl;
        pFLACEncoder->Release();
        return;
    }

    // Configure high quality archival settings
    pFLACEncoder->setEncodingLevel(8);              // Maximum compression
    pFLACEncoder->setLPCOrder(12);                  // Good LPC order
    pFLACEncoder->setBlockSize(4096);               // Standard block size
    pFLACEncoder->useAdaptiveMidSideCoding(TRUE);   // Adaptive mid-side
    pFLACEncoder->useExhaustiveModelSearch(TRUE);   // Best compression
    pFLACEncoder->setRicePartitionOrder(0, 8);      // Maximum range

    // Display configuration
    std::cout << "FLAC encoder configured for high-quality archival:" << std::endl;
    std::cout << "  Encoding Level: " << pFLACEncoder->encoderLevel() << std::endl;
    std::cout << "  LPC Order: " << pFLACEncoder->LPCOrder() << std::endl;
    std::cout << "  Block Size: " << pFLACEncoder->blockSize() << std::endl;
    std::cout << "  Adaptive Mid-Side: "
              << (pFLACEncoder->isUsingAdaptiveMidSideCoding() ? "Yes" : "No") << std::endl;
    std::cout << "  Exhaustive Search: "
              << (pFLACEncoder->isUsingExhaustiveModel() ? "Yes" : "No") << std::endl;

    pFLACEncoder->Release();
}
```

### C++ Example - Fast Real-Time Encoding

```
void ConfigureFastFLAC(IBaseFilter* pAudioEncoder)
{
    IFLACEncodeSettings* pFLACEncoder = NULL;
    HRESULT hr = pAudioEncoder->QueryInterface(IID_IFLACEncodeSettings,
                                               (void**)&pFLACEncoder);
    if (SUCCEEDED(hr) && pFLACEncoder)
    {
        if (pFLACEncoder->canModifySettings())
        {
            // Fast encoding configuration
            pFLACEncoder->setEncodingLevel(2);              // Fast
            pFLACEncoder->setLPCOrder(8);                   // Lower LPC
            pFLACEncoder->setBlockSize(1152);               // Smaller blocks
            pFLACEncoder->useAdaptiveMidSideCoding(TRUE);   // Still good
            pFLACEncoder->useExhaustiveModelSearch(FALSE);  // Disabled for speed
            pFLACEncoder->setRicePartitionOrder(0, 4);      // Reduced range

            std::cout << "FLAC encoder configured for fast real-time encoding" << std::endl;
        }
        pFLACEncoder->Release();
    }
}
```

### Delphi Example - High Quality Archival

```
uses
  DirectShow9, ActiveX;

procedure ConfigureHighQualityFLAC(AudioEncoder: IBaseFilter);
var
  FLACEncoder: IFLACEncodeSettings;
  hr: HRESULT;
begin
  // Query the FLAC encoder interface
  hr := AudioEncoder.QueryInterface(IID_IFLACEncodeSettings, FLACEncoder);
  if Failed(hr) or (FLACEncoder = nil) then
  begin
    WriteLn('Error: Filter does not support IFLACEncodeSettings');
    Exit;
  end;

  try
    // Check if we can modify settings
    if not FLACEncoder.canModifySettings then
    begin
      WriteLn('Warning: Cannot modify encoder settings');
      Exit;
    end;

    // Configure high quality archival settings
    FLACEncoder.setEncodingLevel(8);              // Maximum compression
    FLACEncoder.setLPCOrder(12);                  // Good LPC order
    FLACEncoder.setBlockSize(4096);               // Standard block size
    FLACEncoder.useAdaptiveMidSideCoding(True);   // Adaptive mid-side
    FLACEncoder.useExhaustiveModelSearch(True);   // Best compression
    FLACEncoder.setRicePartitionOrder(0, 8);      // Maximum range

    // Display configuration
    WriteLn('FLAC encoder configured for high-quality archival:');
    WriteLn('  Encoding Level: ', FLACEncoder.encoderLevel);
    WriteLn('  LPC Order: ', FLACEncoder.LPCOrder);
    WriteLn('  Block Size: ', FLACEncoder.blockSize);
    WriteLn('  Adaptive Mid-Side: ', FLACEncoder.isUsingAdaptiveMidSideCoding);
    WriteLn('  Exhaustive Search: ', FLACEncoder.isUsingExhaustiveModel);

  finally
    FLACEncoder := nil;
  end;
end;
```

### Delphi Example - Balanced Music Encoding

```
procedure ConfigureBalancedMusicFLAC(AudioEncoder: IBaseFilter);
var
  FLACEncoder: IFLACEncodeSettings;
begin
  if Succeeded(AudioEncoder.QueryInterface(IID_IFLACEncodeSettings, FLACEncoder)) then
  begin
    try
      if FLACEncoder.canModifySettings then
      begin
        // Balanced settings for music
        FLACEncoder.setEncodingLevel(5);              // Balanced
        FLACEncoder.setLPCOrder(12);                  // Standard for music
        FLACEncoder.setBlockSize(4096);               // Optimal
        FLACEncoder.useAdaptiveMidSideCoding(True);   // Adaptive
        FLACEncoder.useExhaustiveModelSearch(False);  // Not needed
        FLACEncoder.setRicePartitionOrder(0, 6);      // Good range

        WriteLn('FLAC encoder configured for balanced music encoding');
      end;
    finally
      FLACEncoder := nil;
    end;
  end;
end;
```

## Best Practices

### Encoding Level Selection

**Level 0-2**: Fast encoding, suitable for real-time applications - Use when encoding speed is critical - Typical compression: 50-55% of original size

**Level 3-5**: Balanced encoding (recommended for most uses) - Good balance between speed and compression - Typical compression: 45-50% of original size - **Level 5 is recommended** for general-purpose archival

**Level 6-8**: Maximum compression, slower encoding - Use for long-term archival where storage space is critical - Typical compression: 40-45% of original size - Encoding can be 2-5x slower than level 5

### Mid-Side Stereo Coding

- **Always enable** `useAdaptiveMidSideCoding` for stereo audio
- Adaptive mode automatically determines when mid-side coding helps
- Provides better compression than fixed mid-side mode
- No significant performance penalty

### LPC Order Recommendations

**Music and General Audio**: - Use LPC order 12 for most music encoding - Higher orders (16-32) provide minimal benefit for music - Lower orders (8) are suitable for speech

**Classical and High-Dynamic Range**: - Consider LPC order 16-32 for orchestral recordings - Provides better prediction for complex harmonic content

### Block Size Selection

**Sample Rate Considerations**: - 44.1kHz: 4096 samples (default, ~93ms) - 48kHz: 4608 samples (~96ms) - 96kHz: 4608-8192 samples

**Latency Requirements**: - Real-time: 192-1152 samples - Standard archival: 4096 samples - Maximum compression: 4608 samples

### Exhaustive Model Search

**When to Enable**: - Critical archival projects where every byte counts - Unlimited encoding time available - File size reduction is paramount

**When to Disable** (recommended for most users): - Real-time or near-real-time encoding - Large batch encoding projects - Compression improvement is typically <3% - Encoding time increases 2-4x

### Rice Partition Order

**Fast Encoding**: `setRicePartitionOrder(0, 3)` **Standard Encoding**: `setRicePartitionOrder(0, 6)` (recommended) **Maximum Compression**: `setRicePartitionOrder(0, 8)`

## Troubleshooting

### Settings Cannot Be Modified

**Symptom**: `canModifySettings()` returns `false`

**Causes**: 1. Filter graph is already running 2. Encoder is actively processing audio 3. Filter is in an incorrect state

**Solutions**: - Stop the filter graph before modifying settings - Configure encoder before connecting filter pins - Query settings before starting playback/capture

### Poor Compression Ratio

**Symptom**: FLAC files are larger than expected

**Possible Causes**: 1. Low encoding level (0-2) 2. Source audio is already compressed (MP3, AAC) 3. Source audio has high noise floor 4. Inappropriate block size for sample rate

**Solutions**: - Increase encoding level to 5-8 - **Never re-encode already compressed audio** - FLAC cannot improve quality - Use noise reduction on source audio before encoding - Adjust block size to match sample rate (see recommendations above)

### Encoding Too Slow

**Symptom**: Real-time encoding cannot keep up with audio stream

**Solutions**: 1. Reduce encoding level to 0-3 2. Disable exhaustive model search 3. Reduce LPC order to 8 4. Reduce Rice partition max to 4 5. Use smaller block sizes (1152 or less)

### Audio Pops or Clicks in Encoded Output

**Symptom**: Audible artifacts in encoded FLAC files

**Possible Causes**: 1. Encoder cannot process fast enough (buffer underruns) 2. Incompatible block size with sample rate 3. Hardware performance issues

**Solutions**: - Reduce encoding complexity (lower level, disable exhaustive search) - Use standard block sizes for the sample rate - Increase DirectShow buffer sizes - Reduce system load during encoding

### Stereo Encoding Issues

**Symptom**: Stereo audio sounds incorrect or mono

**Check**: - Verify input is actually stereo (2 channels) - Mid-side coding only works with stereo input - Check if adaptive mid-side is enabled for best results - Verify filter graph audio format (use GraphEdit to inspect)

## Technical Notes

### FLAC Encoding Process

FLAC encoding involves several stages: 1. **Blocking**: Audio divided into blocks 2. **Prediction**: LPC analysis predicts sample values 3. **Mid-Side Coding**: Optional stereo decorrelation (for 2-channel audio) 4. **Residual Encoding**: Rice coding compresses prediction errors 5. **Frame Assembly**: Blocks assembled into FLAC frames

### Performance Characteristics

**CPU Usage by Setting**: - Encoding Level: ~10% increase per level - LPC Order: ~5% increase per 4 orders - Exhaustive Search: 200-400% increase - Mid-Side Coding: ~2-5% increase

**Memory Requirements**: - Minimal: ~512KB working memory - Larger blocks require more memory - No significant dependency on audio duration

### Compatibility

FLAC files encoded with any settings combination are compatible with all FLAC decoders. Higher compression settings only affect encoding time and file size, not decoder compatibility or playback quality.

---

## See Also

- [LAME MP3 Encoder Interface](../lame/)
- [Audio Codecs Reference](../../codecs-reference/)
- [Encoding Filters Pack Overview](../../)

---END OF PAGE---


## H.264 DirectShow Encoder Filter - COM Interface API
**URL:** https://www.visioforge.com/help/docs/directshow/filters-enc/interfaces/h264/
**Description:** Configure H.264/AVC encoding in DirectShow — bitrate control (CBR/VBR), profiles (Baseline/Main/High), GOP structure, and rate control. IH264Encoder reference.
**Tags:** DirectShow, C++, Windows, Streaming, Encoding, Decoding, H.264, C#
**API:** H264Encoder, IH264Encoder, IBaseFilter, VideoEncoder, H264HighQualityEncoder

# H.264 Encoder Interface Reference

## Overview

The **IH264Encoder** interface provides comprehensive control over H.264/AVC (Advanced Video Coding) video encoding in DirectShow filter graphs. H.264 is the industry-standard video compression format used for broadcast, streaming, and distribution applications.

This interface allows developers to configure encoding profiles, bitrate control, Group of Pictures (GOP) structure, macroblock encoding modes, and advanced timing parameters for optimal video quality and file size in various scenarios including streaming, broadcast, and archival.

**Interface GUID**: `{09FA2EA3-4773-41a8-90DC-9499D4061E9F}`

**Inherits From**: `IUnknown`

## Interface Definitions

### C# Definition

```
using System;
using System.Runtime.InteropServices;

namespace VisioForge.DirectShowAPI
{
    /// <summary>
    /// H.264/AVC (Advanced Video Coding) encoder configuration interface.
    /// Provides comprehensive control over H.264 encoding parameters including
    /// bitrate control, profile/level settings, GOP structure, and rate control modes.
    /// </summary>
    [ComImport]
    [Guid("09FA2EA3-4773-41a8-90DC-9499D4061E9F")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IH264Encoder
    {
        /// <summary>
        /// Gets the target bitrate for encoding.
        /// </summary>
        /// <param name="plValue">Receives the bitrate in bits per second (bps)</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_Bitrate([Out] out int plValue);

        /// <summary>
        /// Sets the target bitrate for encoding.
        /// </summary>
        /// <param name="lValue">Bitrate in bits per second (bps). Typical range: 500,000 to 50,000,000</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_Bitrate([In] int lValue);

        /// <summary>
        /// Gets the rate control mode.
        /// </summary>
        /// <param name="pValue">Receives the rate control mode (0=CBR, 1=VBR)</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_RateControl([Out] out int pValue);

        /// <summary>
        /// Sets the rate control mode.
        /// </summary>
        /// <param name="value">Rate control mode: 0 = CBR (Constant Bitrate), 1 = VBR (Variable Bitrate)</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_RateControl([In] int value);

        /// <summary>
        /// Gets the macroblock encoding mode.
        /// </summary>
        /// <param name="pValue">Receives the MB encoding mode</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_MbEncoding([Out] out int pValue);

        /// <summary>
        /// Sets the macroblock encoding mode (affects encoding complexity and quality).
        /// </summary>
        /// <param name="value">MB encoding mode value</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_MbEncoding([In] int value);

        /// <summary>
        /// Gets the GOP (Group of Pictures) enable state.
        /// </summary>
        /// <param name="pValue">Receives true if GOP is enabled, false otherwise</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_GOP([Out] [MarshalAs(UnmanagedType.Bool)] out bool pValue);

        /// <summary>
        /// Enables or disables GOP (Group of Pictures) structure.
        /// </summary>
        /// <param name="value">True to enable GOP, false to disable (all I-frames)</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_GOP([In] [MarshalAs(UnmanagedType.Bool)] bool value);

        /// <summary>
        /// Gets the auto-bitrate adjustment state.
        /// </summary>
        /// <param name="pValue">Receives true if auto-bitrate is enabled, false otherwise</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_AutoBitrate([Out] [MarshalAs(UnmanagedType.Bool)] out bool pValue);

        /// <summary>
        /// Enables or disables automatic bitrate adjustment.
        /// When enabled, the encoder automatically adjusts bitrate based on content complexity.
        /// </summary>
        /// <param name="value">True to enable auto-bitrate, false for fixed bitrate</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_AutoBitrate([In] [MarshalAs(UnmanagedType.Bool)] bool value);

        /// <summary>
        /// Gets the H.264 profile.
        /// </summary>
        /// <param name="pValue">Receives the profile value</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_Profile([Out] out int pValue);

        /// <summary>
        /// Sets the H.264 profile (Baseline, Main, High, etc.).
        /// </summary>
        /// <param name="value">Profile value: 66=Baseline, 77=Main, 100=High</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_Profile([In] int value);

        /// <summary>
        /// Gets the H.264 level.
        /// </summary>
        /// <param name="pValue">Receives the level value</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_Level([Out] out int pValue);

        /// <summary>
        /// Sets the H.264 level (constrains resolution, bitrate, and frame rate).
        /// </summary>
        /// <param name="value">Level value: 10=Level 1.0, 11=Level 1.1, ..., 51=Level 5.1</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_Level([In] int value);

        /// <summary>
        /// Gets the usage mode (quality/speed trade-off).
        /// </summary>
        /// <param name="pValue">Receives the usage mode value</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_Usage([Out] out int pValue);

        /// <summary>
        /// Sets the usage mode to optimize for quality vs. speed.
        /// </summary>
        /// <param name="value">Usage mode: 0=Quality, 1=Balanced, 2=Speed</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_Usage([In] int value);

        /// <summary>
        /// Gets the sequential timing mode.
        /// </summary>
        /// <param name="pValue">Receives the sequential timing value</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_SequentialTiming([Out] out int pValue);

        /// <summary>
        /// Sets the sequential timing mode for frame processing.
        /// </summary>
        /// <param name="value">Sequential timing mode value</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_SequentialTiming([In] int value);

        /// <summary>
        /// Gets the slice intervals for IDR and P frames.
        /// </summary>
        /// <param name="piIDR">Receives the IDR frame interval</param>
        /// <param name="piP">Receives the P frame interval</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_SliceIntervals([Out] out int piIDR, [Out] out int piP);

        /// <summary>
        /// Sets the slice intervals for IDR (Instantaneous Decoder Refresh) and P frames.
        /// IDR frames are full keyframes, P frames are predicted frames.
        /// </summary>
        /// <param name="piIDR">IDR frame interval (every N frames). Typical: 30-300</param>
        /// <param name="piP">P frame interval. Typical: 1-3</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_SliceIntervals([In] ref int piIDR, [In] ref int piP);

        /// <summary>
        /// Gets the maximum bitrate for VBR encoding.
        /// </summary>
        /// <param name="plValue">Receives the maximum bitrate in bps</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_MaxBitrate([Out] out int plValue);

        /// <summary>
        /// Sets the maximum bitrate for Variable Bitrate (VBR) encoding.
        /// Only applicable when rate control is set to VBR.
        /// </summary>
        /// <param name="lValue">Maximum bitrate in bits per second (bps)</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_MaxBitrate([In] int lValue);

        /// <summary>
        /// Gets the minimum bitrate for VBR encoding.
        /// </summary>
        /// <param name="plValue">Receives the minimum bitrate in bps</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_MinBitrate([Out] out int plValue);

        /// <summary>
        /// Sets the minimum bitrate for Variable Bitrate (VBR) encoding.
        /// Only applicable when rate control is set to VBR.
        /// </summary>
        /// <param name="lValue">Minimum bitrate in bits per second (bps)</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_MinBitrate([In] int lValue);
    }
}
```

### C++ Definition

```
#include <unknwn.h>

// {09FA2EA3-4773-41a8-90DC-9499D4061E9F}
DEFINE_GUID(IID_IH264Encoder,
    0x09fa2ea3, 0x4773, 0x41a8, 0x90, 0xdc, 0x94, 0x99, 0xd4, 0x06, 0x1e, 0x9f);

/// <summary>
/// H.264/AVC (Advanced Video Coding) encoder configuration interface.
/// Provides comprehensive control over H.264 encoding parameters.
/// </summary>
DECLARE_INTERFACE_(IH264Encoder, IUnknown)
{
    /// <summary>
    /// Gets the target bitrate for encoding.
    /// </summary>
    /// <param name="plValue">Pointer to receive bitrate in bits per second (bps)</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_Bitrate)(THIS_
        long* plValue
        ) PURE;

    /// <summary>
    /// Sets the target bitrate for encoding.
    /// </summary>
    /// <param name="lValue">Bitrate in bits per second (bps)</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_Bitrate)(THIS_
        long lValue
        ) PURE;

    /// <summary>
    /// Gets the rate control mode.
    /// </summary>
    /// <param name="pValue">Pointer to receive rate control mode</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_RateControl)(THIS_
        int* pValue
        ) PURE;

    /// <summary>
    /// Sets the rate control mode.
    /// </summary>
    /// <param name="value">Rate control mode: 0 = CBR, 1 = VBR</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_RateControl)(THIS_
        int value
        ) PURE;

    /// <summary>
    /// Gets the macroblock encoding mode.
    /// </summary>
    /// <param name="pValue">Pointer to receive MB encoding mode</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_MbEncoding)(THIS_
        int* pValue
        ) PURE;

    /// <summary>
    /// Sets the macroblock encoding mode.
    /// </summary>
    /// <param name="value">MB encoding mode value</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_MbEncoding)(THIS_
        int value
        ) PURE;

    /// <summary>
    /// Gets the GOP enable state.
    /// </summary>
    /// <param name="pValue">Pointer to receive GOP enabled state</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_GOP)(THIS_
        BOOL* pValue
        ) PURE;

    /// <summary>
    /// Enables or disables GOP structure.
    /// </summary>
    /// <param name="value">TRUE to enable GOP, FALSE to disable</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_GOP)(THIS_
        BOOL value
        ) PURE;

    /// <summary>
    /// Gets the auto-bitrate adjustment state.
    /// </summary>
    /// <param name="pValue">Pointer to receive auto-bitrate state</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_AutoBitrate)(THIS_
        BOOL* pValue
        ) PURE;

    /// <summary>
    /// Enables or disables automatic bitrate adjustment.
    /// </summary>
    /// <param name="value">TRUE to enable auto-bitrate, FALSE for fixed</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_AutoBitrate)(THIS_
        BOOL value
        ) PURE;

    /// <summary>
    /// Gets the H.264 profile.
    /// </summary>
    /// <param name="pValue">Pointer to receive profile value</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_Profile)(THIS_
        int* pValue
        ) PURE;

    /// <summary>
    /// Sets the H.264 profile.
    /// </summary>
    /// <param name="value">Profile value: 66=Baseline, 77=Main, 100=High</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_Profile)(THIS_
        int value
        ) PURE;

    /// <summary>
    /// Gets the H.264 level.
    /// </summary>
    /// <param name="pValue">Pointer to receive level value</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_Level)(THIS_
        int* pValue
        ) PURE;

    /// <summary>
    /// Sets the H.264 level.
    /// </summary>
    /// <param name="value">Level value: 10-51</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_Level)(THIS_
        int value
        ) PURE;

    /// <summary>
    /// Gets the usage mode.
    /// </summary>
    /// <param name="pValue">Pointer to receive usage mode</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_Usage)(THIS_
        int* pValue
        ) PURE;

    /// <summary>
    /// Sets the usage mode.
    /// </summary>
    /// <param name="value">Usage mode: 0=Quality, 1=Balanced, 2=Speed</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_Usage)(THIS_
        int value
        ) PURE;

    /// <summary>
    /// Gets the sequential timing mode.
    /// </summary>
    /// <param name="pValue">Pointer to receive sequential timing value</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_SequentialTiming)(THIS_
        int* pValue
        ) PURE;

    /// <summary>
    /// Sets the sequential timing mode.
    /// </summary>
    /// <param name="value">Sequential timing mode value</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_SequentialTiming)(THIS_
        int value
        ) PURE;

    /// <summary>
    /// Gets the slice intervals.
    /// </summary>
    /// <param name="piIDR">Pointer to receive IDR frame interval</param>
    /// <param name="piP">Pointer to receive P frame interval</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_SliceIntervals)(THIS_
        int* piIDR,
        int* piP
        ) PURE;

    /// <summary>
    /// Sets the slice intervals.
    /// </summary>
    /// <param name="piIDR">Pointer to IDR frame interval</param>
    /// <param name="piP">Pointer to P frame interval</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_SliceIntervals)(THIS_
        int* piIDR,
        int* piP
        ) PURE;

    /// <summary>
    /// Gets the maximum bitrate.
    /// </summary>
    /// <param name="plValue">Pointer to receive maximum bitrate in bps</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_MaxBitrate)(THIS_
        long* plValue
        ) PURE;

    /// <summary>
    /// Sets the maximum bitrate for VBR encoding.
    /// </summary>
    /// <param name="lValue">Maximum bitrate in bps</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_MaxBitrate)(THIS_
        long lValue
        ) PURE;

    /// <summary>
    /// Gets the minimum bitrate.
    /// </summary>
    /// <param name="plValue">Pointer to receive minimum bitrate in bps</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_MinBitrate)(THIS_
        long* plValue
        ) PURE;

    /// <summary>
    /// Sets the minimum bitrate for VBR encoding.
    /// </summary>
    /// <param name="lValue">Minimum bitrate in bps</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_MinBitrate)(THIS_
        long lValue
        ) PURE;
};
```

### Delphi Definition

```
uses
  ActiveX, ComObj;

const
  IID_IH264Encoder: TGUID = '{09FA2EA3-4773-41a8-90DC-9499D4061E9F}';

type
  /// <summary>
  /// H.264/AVC encoder configuration interface.
  /// </summary>
  IH264Encoder = interface(IUnknown)
    ['{09FA2EA3-4773-41a8-90DC-9499D4061E9F}']

    /// <summary>
    /// Gets the target bitrate for encoding.
    /// </summary>
    function get_Bitrate(out plValue: Integer): HRESULT; stdcall;

    /// <summary>
    /// Sets the target bitrate for encoding.
    /// </summary>
    function put_Bitrate(lValue: Integer): HRESULT; stdcall;

    /// <summary>
    /// Gets the rate control mode.
    /// </summary>
    function get_RateControl(out pValue: Integer): HRESULT; stdcall;

    /// <summary>
    /// Sets the rate control mode (0=CBR, 1=VBR).
    /// </summary>
    function put_RateControl(value: Integer): HRESULT; stdcall;

    /// <summary>
    /// Gets the macroblock encoding mode.
    /// </summary>
    function get_MbEncoding(out pValue: Integer): HRESULT; stdcall;

    /// <summary>
    /// Sets the macroblock encoding mode.
    /// </summary>
    function put_MbEncoding(value: Integer): HRESULT; stdcall;

    /// <summary>
    /// Gets the GOP enable state.
    /// </summary>
    function get_GOP(out pValue: BOOL): HRESULT; stdcall;

    /// <summary>
    /// Enables or disables GOP structure.
    /// </summary>
    function put_GOP(value: BOOL): HRESULT; stdcall;

    /// <summary>
    /// Gets the auto-bitrate adjustment state.
    /// </summary>
    function get_AutoBitrate(out pValue: BOOL): HRESULT; stdcall;

    /// <summary>
    /// Enables or disables automatic bitrate adjustment.
    /// </summary>
    function put_AutoBitrate(value: BOOL): HRESULT; stdcall;

    /// <summary>
    /// Gets the H.264 profile.
    /// </summary>
    function get_Profile(out pValue: Integer): HRESULT; stdcall;

    /// <summary>
    /// Sets the H.264 profile (66=Baseline, 77=Main, 100=High).
    /// </summary>
    function put_Profile(value: Integer): HRESULT; stdcall;

    /// <summary>
    /// Gets the H.264 level.
    /// </summary>
    function get_Level(out pValue: Integer): HRESULT; stdcall;

    /// <summary>
    /// Sets the H.264 level (10-51).
    /// </summary>
    function put_Level(value: Integer): HRESULT; stdcall;

    /// <summary>
    /// Gets the usage mode.
    /// </summary>
    function get_Usage(out pValue: Integer): HRESULT; stdcall;

    /// <summary>
    /// Sets the usage mode (0=Quality, 1=Balanced, 2=Speed).
    /// </summary>
    function put_Usage(value: Integer): HRESULT; stdcall;

    /// <summary>
    /// Gets the sequential timing mode.
    /// </summary>
    function get_SequentialTiming(out pValue: Integer): HRESULT; stdcall;

    /// <summary>
    /// Sets the sequential timing mode.
    /// </summary>
    function put_SequentialTiming(value: Integer): HRESULT; stdcall;

    /// <summary>
    /// Gets the slice intervals.
    /// </summary>
    function get_SliceIntervals(out piIDR: Integer; out piP: Integer): HRESULT; stdcall;

    /// <summary>
    /// Sets the slice intervals for IDR and P frames.
    /// </summary>
    function put_SliceIntervals(var piIDR: Integer; var piP: Integer): HRESULT; stdcall;

    /// <summary>
    /// Gets the maximum bitrate.
    /// </summary>
    function get_MaxBitrate(out plValue: Integer): HRESULT; stdcall;

    /// <summary>
    /// Sets the maximum bitrate for VBR encoding.
    /// </summary>
    function put_MaxBitrate(lValue: Integer): HRESULT; stdcall;

    /// <summary>
    /// Gets the minimum bitrate.
    /// </summary>
    function get_MinBitrate(out plValue: Integer): HRESULT; stdcall;

    /// <summary>
    /// Sets the minimum bitrate for VBR encoding.
    /// </summary>
    function put_MinBitrate(lValue: Integer): HRESULT; stdcall;
  end;
```

## H.264 Profiles and Levels

### Profiles

H.264 profiles define the features and capabilities available for encoding:

**Profile 66 - Baseline Profile**: - Lowest complexity, best decoder compatibility - No B-frames, no CABAC entropy coding - Used for: Video conferencing, mobile devices, web streaming - Compatibility: All H.264 decoders

**Profile 77 - Main Profile**: - Medium complexity, good compression - Supports B-frames, CABAC entropy coding - Used for: Standard definition broadcast, streaming services - Better compression than Baseline

**Profile 100 - High Profile**: - Highest quality, best compression - Advanced features including 8x8 transforms - Used for: Blu-ray, HDTV broadcast, high-quality streaming - Recommended for most professional applications

**Profile 110 - High 10 Profile**: - 10-bit color depth support - Used for: Professional production, HDR content

**Profile 122 - High 4:2:2 Profile**: - 4:2:2 chroma subsampling - Used for: Professional editing, broadcast production

### Levels

H.264 levels constrain maximum resolution, frame rate, and bitrate:

| Level | Max Resolution | Max Frame Rate | Max Bitrate | Typical Use Case |
| --- | --- | --- | --- | --- |
| 1.0 (10) | 176x144 | 15 fps | 64 Kbps | Mobile, low res |
| 3.0 (30) | 720x576 | 30 fps | 10 Mbps | SD broadcast |
| 3.1 (31) | 1280x720 | 30 fps | 14 Mbps | 720p HD |
| 4.0 (40) | 1920x1080 | 30 fps | 20 Mbps | 1080p HD |
| 4.1 (41) | 1920x1080 | 30 fps | 50 Mbps | 1080p HD high bitrate |
| 5.0 (50) | 2560x1920 | 30 fps | 135 Mbps | 2K, professional |
| 5.1 (51) | 4096x2304 | 30 fps | 240 Mbps | 4K UHD |
| 5.2 (52) | 4096x2304 | 60 fps | 480 Mbps | 4K UHD 60fps |

**Auto-Selection**: Set level to 0 for automatic selection based on resolution and frame rate.

## Rate Control Modes

### Constant Bitrate (CBR) - Mode 0

**Characteristics**: - Maintains consistent bitrate throughout encoding - Predictable file size and network bandwidth usage - Quality varies based on scene complexity

**Use Cases**: - Live streaming (RTMP, HLS, DASH) - Video conferencing - Broadcast transmission - Network-constrained scenarios

**Configuration**:

```
h264Encoder.put_RateControl(0);  // CBR mode
h264Encoder.put_Bitrate(5000000); // 5 Mbps fixed
```

### Variable Bitrate (VBR) - Mode 1

**Characteristics**: - Allocates more bits to complex scenes, fewer to simple scenes - Better overall quality for the same average bitrate - File size and bitrate fluctuate

**Use Cases**: - File-based encoding for storage - VOD (Video On Demand) content - Archival and distribution - When quality is more important than consistent bandwidth

**Configuration**:

```
h264Encoder.put_RateControl(1);     // VBR mode
h264Encoder.put_Bitrate(5000000);   // 5 Mbps target
h264Encoder.put_MinBitrate(3000000); // 3 Mbps minimum
h264Encoder.put_MaxBitrate(8000000); // 8 Mbps maximum
```

## Method Reference

### Bitrate Configuration

#### get\_Bitrate / put\_Bitrate

Gets or sets the target bitrate for encoding in bits per second.

**Typical Values**: - **360p (SD)**: 500,000 - 1,500,000 bps (0.5-1.5 Mbps) - **720p (HD)**: 2,500,000 - 5,000,000 bps (2.5-5 Mbps) - **1080p (Full HD)**: 5,000,000 - 15,000,000 bps (5-15 Mbps) - **4K (UHD)**: 20,000,000 - 50,000,000 bps (20-50 Mbps)

**Example**:

```
h264Encoder.put_Bitrate(5000000); // 5 Mbps for 1080p
```

#### get\_MaxBitrate / put\_MaxBitrate

Gets or sets the maximum bitrate for VBR encoding. Only applicable when rate control is set to VBR (mode 1).

**Recommendation**: Set MaxBitrate to 1.5-2x the target bitrate for VBR encoding.

#### get\_MinBitrate / put\_MinBitrate

Gets or sets the minimum bitrate for VBR encoding. Only applicable for VBR mode.

**Recommendation**: Set MinBitrate to 0.5-0.7x the target bitrate for VBR encoding.

### Rate Control Methods

#### get\_RateControl / put\_RateControl

Gets or sets the rate control mode: - **0**: Constant Bitrate (CBR) - **1**: Variable Bitrate (VBR)

#### get\_AutoBitrate / put\_AutoBitrate

Enables or disables automatic bitrate adjustment based on content complexity.

**When enabled**: Encoder automatically adjusts bitrate within configured constraints based on scene complexity, motion, and detail.

**Recommended**: Enable for VBR mode, disable for CBR mode.

### Profile and Level Configuration

#### get\_Profile / put\_Profile

Gets or sets the H.264 profile: - **66**: Baseline Profile - **77**: Main Profile - **100**: High Profile - **110**: High 10 Profile - **122**: High 4:2:2 Profile

**Recommendation**: Use High Profile (100) for most applications. Use Baseline (66) only for maximum compatibility with old devices.

#### get\_Level / put\_Level

Gets or sets the H.264 level (10 = Level 1.0, 11 = Level 1.1, ..., 51 = Level 5.1, 52 = Level 5.2).

**Auto-Selection**: Set to 0 for automatic level selection based on resolution and frame rate.

### GOP (Group of Pictures) Configuration

#### get\_GOP / put\_GOP

Enables or disables GOP structure: - **true**: Normal GOP with I/P/B frames - **false**: All I-frames (intra-only encoding)

**All I-frames mode**: - Higher bitrate required - Better editing capability (every frame is a keyframe) - No temporal compression - Use for: Production/editing workflows

**Normal GOP mode** (recommended): - Efficient compression with I/P/B frame structure - Lower bitrate for same quality - Use for: Distribution, streaming, archival

### Slice Interval Configuration

#### get\_SliceIntervals / put\_SliceIntervals

Gets or sets the slice intervals for IDR (Instantaneous Decoder Refresh) frames and P frames.

**Parameters**: - `piIDR`: IDR frame interval (keyframe every N frames) - `piP`: P frame interval

**Typical Values**: - **Streaming (low latency)**: IDR=30-60 (1-2 seconds at 30fps), P=1 - **Standard encoding**: IDR=120-300 (4-10 seconds), P=1-3 - **Long-form video**: IDR=300+ (10+ seconds), P=3

**IDR Frame Interval**: - Lower values (30-60): Better seeking, higher bitrate overhead, faster error recovery - Higher values (240-600): Lower bitrate overhead, slower seeking, slower error recovery

**Example**:

```
int idr = 120;  // Keyframe every 120 frames (4 seconds at 30fps)
int p = 1;      // P frame every frame
h264Encoder.put_SliceIntervals(ref idr, ref p);
```

### Advanced Configuration

#### get\_Usage / put\_Usage

Sets the encoding usage mode (quality vs. speed trade-off): - **0**: Quality Mode - Slower encoding, best quality - **1**: Balanced Mode - Good quality, reasonable speed - **2**: Speed Mode - Fast encoding, lower quality

**Recommendation**: - Use Quality Mode (0) for file-based encoding - Use Balanced Mode (1) for most real-time applications - Use Speed Mode (2) only when encoding performance is critical

#### get\_MbEncoding / put\_MbEncoding

Configures macroblock encoding mode, affecting encoding complexity and compression efficiency.

**Note**: Specific values are encoder-dependent. Consult encoder documentation for supported modes.

#### get\_SequentialTiming / put\_SequentialTiming

Configures sequential timing mode for frame processing.

**Note**: Implementation-specific. Affects frame ordering and presentation timing.

## Usage Examples

### C# Example - High Quality 1080p Encoding

```
using System;
using DirectShowLib;
using VisioForge.DirectShowAPI;

public class H264HighQualityEncoder
{
    public void ConfigureHighQuality1080p(IBaseFilter videoEncoder)
    {
        // Query the H.264 encoder interface
        var h264Encoder = videoEncoder as IH264Encoder;
        if (h264Encoder == null)
        {
            Console.WriteLine("Error: Filter does not support IH264Encoder");
            return;
        }

        // High quality 1080p settings
        h264Encoder.put_Profile(100);           // High Profile
        h264Encoder.put_Level(41);              // Level 4.1 (1080p @ 30fps)
        h264Encoder.put_RateControl(1);         // VBR mode
        h264Encoder.put_Bitrate(10000000);      // 10 Mbps target
        h264Encoder.put_MinBitrate(6000000);    // 6 Mbps minimum
        h264Encoder.put_MaxBitrate(15000000);   // 15 Mbps maximum
        h264Encoder.put_Usage(0);               // Quality mode
        h264Encoder.put_GOP(true);              // Enable GOP structure
        h264Encoder.put_AutoBitrate(true);      // Auto bitrate adjustment

        // Set keyframe interval: 120 frames (4 seconds at 30fps)
        int idr = 120;
        int p = 1;
        h264Encoder.put_SliceIntervals(ref idr, ref p);

        Console.WriteLine("H.264 encoder configured for high-quality 1080p:");
        h264Encoder.get_Bitrate(out int bitrate);
        h264Encoder.get_Profile(out int profile);
        h264Encoder.get_Level(out int level);
        Console.WriteLine($"  Bitrate: {bitrate / 1000000.0:F1} Mbps");
        Console.WriteLine($"  Profile: {profile} (High)");
        Console.WriteLine($"  Level: {level / 10.0:F1}");
    }
}
```

### C# Example - Live Streaming Configuration

```
public class H264LiveStreamingEncoder
{
    public void ConfigureLiveStreaming720p(IBaseFilter videoEncoder)
    {
        var h264Encoder = videoEncoder as IH264Encoder;
        if (h264Encoder == null)
            return;

        // Live streaming 720p settings
        h264Encoder.put_Profile(77);            // Main Profile (good compatibility)
        h264Encoder.put_Level(31);              // Level 3.1 (720p @ 30fps)
        h264Encoder.put_RateControl(0);         // CBR mode for streaming
        h264Encoder.put_Bitrate(3500000);       // 3.5 Mbps constant
        h264Encoder.put_Usage(1);               // Balanced mode
        h264Encoder.put_GOP(true);              // Enable GOP
        h264Encoder.put_AutoBitrate(false);     // Fixed bitrate for streaming

        // Low latency: keyframe every 2 seconds
        int idr = 60;  // 2 seconds at 30fps
        int p = 1;
        h264Encoder.put_SliceIntervals(ref idr, ref p);

        Console.WriteLine("H.264 encoder configured for live streaming");
        Console.WriteLine("  720p @ 3.5 Mbps CBR");
        Console.WriteLine("  Keyframe interval: 2 seconds");
    }
}
```

### C# Example - Fast Encoding for Recording

```
public class H264FastRecording
{
    public void ConfigureFastRecording(IBaseFilter videoEncoder)
    {
        var h264Encoder = videoEncoder as IH264Encoder;
        if (h264Encoder == null)
            return;

        // Fast recording settings
        h264Encoder.put_Profile(66);            // Baseline (fastest encoding)
        h264Encoder.put_Level(40);              // Level 4.0 (1080p @ 30fps)
        h264Encoder.put_RateControl(0);         // CBR mode
        h264Encoder.put_Bitrate(8000000);       // 8 Mbps
        h264Encoder.put_Usage(2);               // Speed mode (fast encoding)
        h264Encoder.put_GOP(true);              // Enable GOP
        h264Encoder.put_AutoBitrate(false);     // Fixed bitrate

        // Longer keyframe interval for faster encoding
        int idr = 300;  // 10 seconds at 30fps
        int p = 1;
        h264Encoder.put_SliceIntervals(ref idr, ref p);

        Console.WriteLine("H.264 encoder configured for fast recording");
    }
}
```

### C++ Example - High Quality Configuration

```
#include <dshow.h>
#include <iostream>
#include "IH264Encoder.h"

void ConfigureH264HighQuality(IBaseFilter* pVideoEncoder)
{
    IH264Encoder* pH264Encoder = NULL;
    HRESULT hr = S_OK;

    // Query the H.264 encoder interface
    hr = pVideoEncoder->QueryInterface(IID_IH264Encoder,
                                       (void**)&pH264Encoder);
    if (FAILED(hr) || !pH264Encoder)
    {
        std::cout << "Error: Filter does not support IH264Encoder" << std::endl;
        return;
    }

    // Configure high quality 1080p encoding
    pH264Encoder->put_Profile(100);           // High Profile
    pH264Encoder->put_Level(41);              // Level 4.1
    pH264Encoder->put_RateControl(1);         // VBR mode
    pH264Encoder->put_Bitrate(10000000);      // 10 Mbps
    pH264Encoder->put_MinBitrate(6000000);    // 6 Mbps min
    pH264Encoder->put_MaxBitrate(15000000);   // 15 Mbps max
    pH264Encoder->put_Usage(0);               // Quality mode
    pH264Encoder->put_GOP(TRUE);              // Enable GOP
    pH264Encoder->put_AutoBitrate(TRUE);      // Auto bitrate

    // Set keyframe interval
    int idr = 120;
    int p = 1;
    pH264Encoder->put_SliceIntervals(&idr, &p);

    // Display configuration
    long bitrate;
    pH264Encoder->get_Bitrate(&bitrate);
    std::cout << "H.264 encoder configured:" << std::endl;
    std::cout << "  Bitrate: " << (bitrate / 1000000.0) << " Mbps" << std::endl;

    pH264Encoder->Release();
}
```

### C++ Example - Live Streaming

```
void ConfigureH264LiveStreaming(IBaseFilter* pVideoEncoder)
{
    IH264Encoder* pH264Encoder = NULL;
    HRESULT hr = pVideoEncoder->QueryInterface(IID_IH264Encoder,
                                               (void**)&pH264Encoder);
    if (SUCCEEDED(hr) && pH264Encoder)
    {
        // Live streaming configuration
        pH264Encoder->put_Profile(77);          // Main Profile
        pH264Encoder->put_Level(31);            // Level 3.1 (720p)
        pH264Encoder->put_RateControl(0);       // CBR for streaming
        pH264Encoder->put_Bitrate(3500000);     // 3.5 Mbps
        pH264Encoder->put_Usage(1);             // Balanced mode
        pH264Encoder->put_GOP(TRUE);            // Enable GOP
        pH264Encoder->put_AutoBitrate(FALSE);   // Fixed bitrate

        // Low latency keyframes
        int idr = 60;  // 2 seconds
        int p = 1;
        pH264Encoder->put_SliceIntervals(&idr, &p);

        std::cout << "H.264 live streaming configured" << std::endl;
        pH264Encoder->Release();
    }
}
```

### Delphi Example - High Quality Encoding

```
uses
  DirectShow9, ActiveX;

procedure ConfigureH264HighQuality(VideoEncoder: IBaseFilter);
var
  H264Encoder: IH264Encoder;
  IDR, P: Integer;
  Bitrate: Integer;
  hr: HRESULT;
begin
  // Query the H.264 encoder interface
  hr := VideoEncoder.QueryInterface(IID_IH264Encoder, H264Encoder);
  if Failed(hr) or (H264Encoder = nil) then
  begin
    WriteLn('Error: Filter does not support IH264Encoder');
    Exit;
  end;

  try
    // Configure high quality 1080p encoding
    H264Encoder.put_Profile(100);           // High Profile
    H264Encoder.put_Level(41);              // Level 4.1
    H264Encoder.put_RateControl(1);         // VBR mode
    H264Encoder.put_Bitrate(10000000);      // 10 Mbps
    H264Encoder.put_MinBitrate(6000000);    // 6 Mbps minimum
    H264Encoder.put_MaxBitrate(15000000);   // 15 Mbps maximum
    H264Encoder.put_Usage(0);               // Quality mode
    H264Encoder.put_GOP(True);              // Enable GOP
    H264Encoder.put_AutoBitrate(True);      // Auto bitrate

    // Set keyframe interval
    IDR := 120;
    P := 1;
    H264Encoder.put_SliceIntervals(IDR, P);

    // Display configuration
    H264Encoder.get_Bitrate(Bitrate);
    WriteLn('H.264 encoder configured for high quality:');
    WriteLn('  Bitrate: ', Bitrate / 1000000:0:1, ' Mbps');
  finally
    H264Encoder := nil;
  end;
end;
```

### Delphi Example - Live Streaming

```
procedure ConfigureH264LiveStreaming(VideoEncoder: IBaseFilter);
var
  H264Encoder: IH264Encoder;
  IDR, P: Integer;
begin
  if Succeeded(VideoEncoder.QueryInterface(IID_IH264Encoder, H264Encoder)) then
  begin
    try
      // Live streaming configuration
      H264Encoder.put_Profile(77);          // Main Profile
      H264Encoder.put_Level(31);            // Level 3.1 (720p)
      H264Encoder.put_RateControl(0);       // CBR mode
      H264Encoder.put_Bitrate(3500000);     // 3.5 Mbps
      H264Encoder.put_Usage(1);             // Balanced mode
      H264Encoder.put_GOP(True);            // Enable GOP
      H264Encoder.put_AutoBitrate(False);   // Fixed bitrate

      // Low latency keyframes
      IDR := 60;  // 2 seconds at 30fps
      P := 1;
      H264Encoder.put_SliceIntervals(IDR, P);

      WriteLn('H.264 live streaming configured');
    finally
      H264Encoder := nil;
    end;
  end;
end;
```

## Best Practices

### Bitrate Selection Guidelines

**Resolution-Based Recommendations**:

| Resolution | CBR (Streaming) | VBR Target | VBR Min-Max |
| --- | --- | --- | --- |
| 360p (SD) | 0.8 Mbps | 1 Mbps | 0.5 - 1.5 Mbps |
| 480p (SD) | 1.5 Mbps | 2 Mbps | 1 - 3 Mbps |
| 720p (HD) | 3 Mbps | 4 Mbps | 2.5 - 6 Mbps |
| 1080p (Full HD) | 6 Mbps | 8 Mbps | 5 - 12 Mbps |
| 1440p (2K) | 12 Mbps | 16 Mbps | 10 - 24 Mbps |
| 2160p (4K UHD) | 25 Mbps | 35 Mbps | 20 - 50 Mbps |

**Content Type Adjustments**: - **Low motion** (presentations, talking head): Use 60-70% of recommended bitrate - **Medium motion** (standard video): Use recommended bitrate - **High motion** (sports, action): Use 120-150% of recommended bitrate

### Profile Selection

**Use Baseline Profile (66) when**: - Maximum device compatibility required - Targeting old mobile devices or web browsers - Real-time encoding performance is critical

**Use Main Profile (77) when**: - Good balance between quality and compatibility needed - Live streaming to mixed audiences - Standard broadcast applications

**Use High Profile (100) when** (recommended): - Best quality is required - Modern device compatibility is acceptable (post-2010 devices) - File-based encoding for distribution - **Most production scenarios**

### GOP Structure Recommendations

**Streaming Applications**: - IDR interval: 60-120 frames (2-4 seconds at 30fps) - Shorter intervals: Better seeking, faster error recovery, slightly higher bitrate - Longer intervals: Lower bitrate overhead, but slower seeking

**File-Based Encoding**: - IDR interval: 240-300 frames (8-10 seconds at 30fps) - Balance between file size and seeking capability

**Low-Latency Applications** (video conferencing): - IDR interval: 30-60 frames (1-2 seconds at 30fps) - Short intervals reduce lag from dropped frames

**All-Intra Encoding** (editing workflows): - Disable GOP (`put_GOP(false)`) - Every frame is a keyframe - Higher bitrate required (typically 3-5x normal encoding) - Perfect frame-accurate editing

### Usage Mode Selection

**Quality Mode (0)**: - Slowest encoding, best quality - Use for: File-based encoding, archival, VOD content - Not suitable for real-time encoding on slower hardware

**Balanced Mode (1)** (recommended): - Good quality, reasonable performance - Use for: Most real-time applications, live streaming - Best choice for general-purpose encoding

**Speed Mode (2)**: - Fastest encoding, lower quality - Use for: High-resolution real-time encoding on limited hardware - Screen recording, surveillance applications

## Troubleshooting

### Low Video Quality

**Symptoms**: Blocky artifacts, blurring, loss of detail

**Possible Causes**: 1. Bitrate too low for resolution 2. Wrong profile selection 3. GOP interval too long 4. Usage mode set to Speed instead of Quality

**Solutions**: - Increase bitrate to recommended levels (see table above) - Switch to High Profile (100) for better compression - Shorten IDR interval to 120-180 frames - Use Balanced (1) or Quality (0) usage mode - For VBR, increase minimum bitrate

### Encoding Too Slow / Cannot Keep Up

**Symptoms**: Dropped frames, encoding slower than real-time

**Solutions**: 1. Switch to Baseline Profile (66) for faster encoding 2. Set Usage mode to Speed (2) 3. Reduce bitrate to lower computational requirements 4. Increase IDR interval (longer GOP = less processing) 5. Consider hardware encoder (NVENC, QuickSync) instead

### Large File Sizes

**Symptoms**: Files larger than expected

**Possible Causes**: 1. Bitrate too high for target quality 2. CBR mode with conservative bitrate setting 3. GOP disabled (all I-frames) 4. Wrong level setting

**Solutions**: - Switch from CBR to VBR for variable content - Enable GOP structure (`put_GOP(true)`) - Reduce target bitrate - Adjust min/max bitrate range for VBR - Use High Profile (100) for better compression

### Streaming Compatibility Issues

**Symptoms**: Video plays on some devices but not others

**Possible Causes**: 1. Profile too advanced (High Profile not supported on old devices) 2. Level too high for device capabilities 3. Incorrect slice configuration

**Solutions**: - Use Main Profile (77) or Baseline Profile (66) for maximum compatibility - Set level to 0 for automatic selection - Test on target devices - Verify player/device H.264 capabilities

### Seeking Issues / Slow Scrubbing

**Symptoms**: Slow or inaccurate seeking in encoded video

**Cause**: IDR interval too long (keyframes too far apart)

**Solutions**: - Reduce IDR interval to 60-120 frames (2-4 seconds) - For editing workflows, consider all-intra encoding (`put_GOP(false)`) - Shorter IDR intervals improve seeking at cost of slightly higher bitrate

---

## See Also

- [NVENC Encoder Interface](../nvenc/) - NVIDIA hardware H.264/HEVC encoding
- [Video Codecs Reference](../../codecs-reference/)
- [Encoding Filters Pack Overview](../../)
- [MP4 Muxer Interface](../mp4-muxer/)

---END OF PAGE---


## LAME MP3 Encoder Settings via DirectShow COM Interface
**URL:** https://www.visioforge.com/help/docs/directshow/filters-enc/interfaces/lame/
**Description:** IAudioEncoderProperties interface for LAME MP3 encoding with variable and constant bitrate modes and quality configuration.
**Tags:** DirectShow, C++, Windows, Streaming, Encoding, MP3, C#
**API:** IBaseFilter, AudioEncoder

# LAME MP3 Encoder Interface Reference

## Overview

The `IAudioEncoderProperties` interface provides comprehensive control over LAME MP3 audio encoding. LAME (LAME Ain't an MP3 Encoder) is a high-quality MP3 encoder that produces excellent audio quality with efficient compression.

This interface allows configuration of bitrate, quality, variable bitrate (VBR) settings, and various encoding flags for optimal MP3 output.

## Interface Definition

- **Interface Name**: `IAudioEncoderProperties`
- **GUID**: `{595EB9D1-F454-41AD-A1FA-EC232AD9DA52}`
- **Inherits From**: `IUnknown`

## Interface Definitions

### C# Definition

```
using System;
using System.Runtime.InteropServices;

namespace VisioForge.DirectShowAPI
{
    /// <summary>
    /// LAME MP3 encoder interface.
    /// </summary>
    /// <remarks>
    /// Configuring MPEG audio encoder parameters with unspecified
    /// input stream type may lead to misbehavior and confusing
    /// results. In most cases the specified parameters will be
    /// overridden by defaults for the input media type.
    /// To achieve proper results use this interface on the
    /// audio encoder filter with input pin connected to a valid source.
    /// </remarks>
    [ComImport]
    [System.Security.SuppressUnmanagedCodeSecurity]
    [Guid("595EB9D1-F454-41AD-A1FA-EC232AD9DA52")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IAudioEncoderProperties
    {
        // PES Output Control
        [PreserveSig]
        int get_PESOutputEnabled(out int dwEnabled);

        [PreserveSig]
        int set_PESOutputEnabled([In] int dwEnabled);

        // Bitrate Configuration
        [PreserveSig]
        int get_Bitrate(out int dwBitrate);

        [PreserveSig]
        int set_Bitrate([In] int dwBitrate);

        // Variable Bitrate (VBR)
        [PreserveSig]
        int get_Variable(out int dwVariable);

        [PreserveSig]
        int set_Variable([In] int dwVariable);

        [PreserveSig]
        int get_VariableMin(out int dwmin);

        [PreserveSig]
        int set_VariableMin([In] int dwmin);

        [PreserveSig]
        int get_VariableMax(out int dwmax);

        [PreserveSig]
        int set_VariableMax([In] int dwmax);

        // Quality Settings
        [PreserveSig]
        int get_Quality(out int dwQuality);

        [PreserveSig]
        int set_Quality([In] int dwQuality);

        [PreserveSig]
        int get_VariableQ(out int dwVBRq);

        [PreserveSig]
        int set_VariableQ([In] int dwVBRq);

        // Source Information
        [PreserveSig]
        int get_SourceSampleRate(out int dwSampleRate);

        [PreserveSig]
        int get_SourceChannels(out int dwChannels);

        // Output Configuration
        [PreserveSig]
        int get_SampleRate(out int dwSampleRate);

        [PreserveSig]
        int set_SampleRate([In] int dwSampleRate);

        [PreserveSig]
        int get_ChannelMode(out int dwChannelMode);

        [PreserveSig]
        int set_ChannelMode([In] int dwChannelMode);

        // Flags
        [PreserveSig]
        int get_CRCFlag(out int dwFlag);

        [PreserveSig]
        int set_CRCFlag([In] int dwFlag);

        [PreserveSig]
        int get_OriginalFlag(out int dwFlag);

        [PreserveSig]
        int set_OriginalFlag([In] int dwFlag);

        [PreserveSig]
        int get_CopyrightFlag(out int dwFlag);

        [PreserveSig]
        int set_CopyrightFlag([In] int dwFlag);

        [PreserveSig]
        int get_EnforceVBRmin(out int dwFlag);

        [PreserveSig]
        int set_EnforceVBRmin([In] int dwFlag);

        [PreserveSig]
        int get_VoiceMode(out int dwFlag);

        [PreserveSig]
        int set_VoiceMode([In] int dwFlag);

        [PreserveSig]
        int get_KeepAllFreq(out int dwFlag);

        [PreserveSig]
        int set_KeepAllFreq([In] int dwFlag);

        [PreserveSig]
        int get_StrictISO(out int dwFlag);

        [PreserveSig]
        int set_StrictISO([In] int dwFlag);

        [PreserveSig]
        int get_NoShortBlock(out int dwDisable);

        [PreserveSig]
        int set_NoShortBlock([In] int dwDisable);

        [PreserveSig]
        int get_XingTag(out int dwXingTag);

        [PreserveSig]
        int set_XingTag([In] int dwXingTag);

        [PreserveSig]
        int get_ForceMS(out int dwFlag);

        [PreserveSig]
        int set_ForceMS([In] int dwFlag);

        [PreserveSig]
        int get_ModeFixed(out int dwFlag);

        [PreserveSig]
        int set_ModeFixed([In] int dwFlag);

        // Configuration Management
        // pcBlock is a BYTE[] buffer in C++; use LPArray with SizeParamIndex=1
        // so the marshaler reads pdwSize bytes back from native code.
        [PreserveSig]
        int get_ParameterBlockSize(
            [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] pcBlock,
            out int pdwSize);

        [PreserveSig]
        int set_ParameterBlockSize(
            [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] pcBlock,
            [In] int dwSize);

        [PreserveSig]
        int DefaultAudioEncoderProperties();

        [PreserveSig]
        int LoadAudioEncoderPropertiesFromRegistry();

        [PreserveSig]
        int SaveAudioEncoderPropertiesToRegistry();

        [PreserveSig]
        int InputTypeDefined();
    }
}
```

### C++ Definition

```
#include <unknwn.h>

// {595EB9D1-F454-41AD-A1FA-EC232AD9DA52}
static const GUID IID_IAudioEncoderProperties =
{ 0x595eb9d1, 0xf454, 0x41ad, { 0xa1, 0xfa, 0xec, 0x23, 0x2a, 0xd9, 0xda, 0x52 } };

DECLARE_INTERFACE_(IAudioEncoderProperties, IUnknown)
{
    // PES Output
    STDMETHOD(get_PESOutputEnabled)(THIS_ int* dwEnabled) PURE;
    STDMETHOD(set_PESOutputEnabled)(THIS_ int dwEnabled) PURE;

    // Bitrate
    STDMETHOD(get_Bitrate)(THIS_ int* dwBitrate) PURE;
    STDMETHOD(set_Bitrate)(THIS_ int dwBitrate) PURE;

    // Variable Bitrate
    STDMETHOD(get_Variable)(THIS_ int* dwVariable) PURE;
    STDMETHOD(set_Variable)(THIS_ int dwVariable) PURE;
    STDMETHOD(get_VariableMin)(THIS_ int* dwmin) PURE;
    STDMETHOD(set_VariableMin)(THIS_ int dwmin) PURE;
    STDMETHOD(get_VariableMax)(THIS_ int* dwmax) PURE;
    STDMETHOD(set_VariableMax)(THIS_ int dwmax) PURE;

    // Quality
    STDMETHOD(get_Quality)(THIS_ int* dwQuality) PURE;
    STDMETHOD(set_Quality)(THIS_ int dwQuality) PURE;
    STDMETHOD(get_VariableQ)(THIS_ int* dwVBRq) PURE;
    STDMETHOD(set_VariableQ)(THIS_ int dwVBRq) PURE;

    // Source Information
    STDMETHOD(get_SourceSampleRate)(THIS_ int* dwSampleRate) PURE;
    STDMETHOD(get_SourceChannels)(THIS_ int* dwChannels) PURE;

    // Output Configuration
    STDMETHOD(get_SampleRate)(THIS_ int* dwSampleRate) PURE;
    STDMETHOD(set_SampleRate)(THIS_ int dwSampleRate) PURE;
    STDMETHOD(get_ChannelMode)(THIS_ int* dwChannelMode) PURE;
    STDMETHOD(set_ChannelMode)(THIS_ int dwChannelMode) PURE;

    // Flags
    STDMETHOD(get_CRCFlag)(THIS_ int* dwFlag) PURE;
    STDMETHOD(set_CRCFlag)(THIS_ int dwFlag) PURE;
    STDMETHOD(get_OriginalFlag)(THIS_ int* dwFlag) PURE;
    STDMETHOD(set_OriginalFlag)(THIS_ int dwFlag) PURE;
    STDMETHOD(get_CopyrightFlag)(THIS_ int* dwFlag) PURE;
    STDMETHOD(set_CopyrightFlag)(THIS_ int dwFlag) PURE;
    STDMETHOD(get_EnforceVBRmin)(THIS_ int* dwFlag) PURE;
    STDMETHOD(set_EnforceVBRmin)(THIS_ int dwFlag) PURE;
    STDMETHOD(get_VoiceMode)(THIS_ int* dwFlag) PURE;
    STDMETHOD(set_VoiceMode)(THIS_ int dwFlag) PURE;
    STDMETHOD(get_KeepAllFreq)(THIS_ int* dwFlag) PURE;
    STDMETHOD(set_KeepAllFreq)(THIS_ int dwFlag) PURE;
    STDMETHOD(get_StrictISO)(THIS_ int* dwFlag) PURE;
    STDMETHOD(set_StrictISO)(THIS_ int dwFlag) PURE;
    STDMETHOD(get_NoShortBlock)(THIS_ int* dwDisable) PURE;
    STDMETHOD(set_NoShortBlock)(THIS_ int dwDisable) PURE;
    STDMETHOD(get_XingTag)(THIS_ int* dwXingTag) PURE;
    STDMETHOD(set_XingTag)(THIS_ int dwXingTag) PURE;
    STDMETHOD(get_ForceMS)(THIS_ int* dwFlag) PURE;
    STDMETHOD(set_ForceMS)(THIS_ int dwFlag) PURE;
    STDMETHOD(get_ModeFixed)(THIS_ int* dwFlag) PURE;
    STDMETHOD(set_ModeFixed)(THIS_ int dwFlag) PURE;

    // Configuration Management
    STDMETHOD(get_ParameterBlockSize)(THIS_ byte* pcBlock, int* pdwSize) PURE;
    STDMETHOD(set_ParameterBlockSize)(THIS_ byte* pcBlock, int dwSize) PURE;
    STDMETHOD(DefaultAudioEncoderProperties)(THIS) PURE;
    STDMETHOD(LoadAudioEncoderPropertiesFromRegistry)(THIS) PURE;
    STDMETHOD(SaveAudioEncoderPropertiesToRegistry)(THIS) PURE;
    STDMETHOD(InputTypeDefined)(THIS) PURE;
};
```

### Delphi Definition

```
uses
  ActiveX, ComObj;

const
  IID_IAudioEncoderProperties: TGUID = '{595EB9D1-F454-41AD-A1FA-EC232AD9DA52}';

type
  IAudioEncoderProperties = interface(IUnknown)
    ['{595EB9D1-F454-41AD-A1FA-EC232AD9DA52}']

    // PES Output
    function get_PESOutputEnabled(out dwEnabled: Integer): HRESULT; stdcall;
    function set_PESOutputEnabled(dwEnabled: Integer): HRESULT; stdcall;

    // Bitrate
    function get_Bitrate(out dwBitrate: Integer): HRESULT; stdcall;
    function set_Bitrate(dwBitrate: Integer): HRESULT; stdcall;

    // Variable Bitrate
    function get_Variable(out dwVariable: Integer): HRESULT; stdcall;
    function set_Variable(dwVariable: Integer): HRESULT; stdcall;
    function get_VariableMin(out dwmin: Integer): HRESULT; stdcall;
    function set_VariableMin(dwmin: Integer): HRESULT; stdcall;
    function get_VariableMax(out dwmax: Integer): HRESULT; stdcall;
    function set_VariableMax(dwmax: Integer): HRESULT; stdcall;

    // Quality
    function get_Quality(out dwQuality: Integer): HRESULT; stdcall;
    function set_Quality(dwQuality: Integer): HRESULT; stdcall;
    function get_VariableQ(out dwVBRq: Integer): HRESULT; stdcall;
    function set_VariableQ(dwVBRq: Integer): HRESULT; stdcall;

    // Source Information
    function get_SourceSampleRate(out dwSampleRate: Integer): HRESULT; stdcall;
    function get_SourceChannels(out dwChannels: Integer): HRESULT; stdcall;

    // Output Configuration
    function get_SampleRate(out dwSampleRate: Integer): HRESULT; stdcall;
    function set_SampleRate(dwSampleRate: Integer): HRESULT; stdcall;
    function get_ChannelMode(out dwChannelMode: Integer): HRESULT; stdcall;
    function set_ChannelMode(dwChannelMode: Integer): HRESULT; stdcall;

    // Flags
    function get_CRCFlag(out dwFlag: Integer): HRESULT; stdcall;
    function set_CRCFlag(dwFlag: Integer): HRESULT; stdcall;
    function get_OriginalFlag(out dwFlag: Integer): HRESULT; stdcall;
    function set_OriginalFlag(dwFlag: Integer): HRESULT; stdcall;
    function get_CopyrightFlag(out dwFlag: Integer): HRESULT; stdcall;
    function set_CopyrightFlag(dwFlag: Integer): HRESULT; stdcall;
    function get_EnforceVBRmin(out dwFlag: Integer): HRESULT; stdcall;
    function set_EnforceVBRmin(dwFlag: Integer): HRESULT; stdcall;
    function get_VoiceMode(out dwFlag: Integer): HRESULT; stdcall;
    function set_VoiceMode(dwFlag: Integer): HRESULT; stdcall;
    function get_KeepAllFreq(out dwFlag: Integer): HRESULT; stdcall;
    function set_KeepAllFreq(dwFlag: Integer): HRESULT; stdcall;
    function get_StrictISO(out dwFlag: Integer): HRESULT; stdcall;
    function set_StrictISO(dwFlag: Integer): HRESULT; stdcall;
    function get_NoShortBlock(out dwDisable: Integer): HRESULT; stdcall;
    function set_NoShortBlock(dwDisable: Integer): HRESULT; stdcall;
    function get_XingTag(out dwXingTag: Integer): HRESULT; stdcall;
    function set_XingTag(dwXingTag: Integer): HRESULT; stdcall;
    function get_ForceMS(out dwFlag: Integer): HRESULT; stdcall;
    function set_ForceMS(dwFlag: Integer): HRESULT; stdcall;
    function get_ModeFixed(out dwFlag: Integer): HRESULT; stdcall;
    function set_ModeFixed(dwFlag: Integer): HRESULT; stdcall;

    // Configuration Management
    function get_ParameterBlockSize(out pcBlock: Byte; out pdwSize: Integer): HRESULT; stdcall;
    function set_ParameterBlockSize(pcBlock: Byte; dwSize: Integer): HRESULT; stdcall;
    function DefaultAudioEncoderProperties: HRESULT; stdcall;
    function LoadAudioEncoderPropertiesFromRegistry: HRESULT; stdcall;
    function SaveAudioEncoderPropertiesToRegistry: HRESULT; stdcall;
    function InputTypeDefined: HRESULT; stdcall;
  end;
```

---

## Methods Reference

### Bitrate Configuration

#### set\_Bitrate / get\_Bitrate

Sets or retrieves the target compression bitrate in Kbits/s. **Parameters**: - `dwBitrate`: Bitrate in kilobits per second **Common MP3 Bitrates**: - **320 kbps** - Highest quality, near-transparent - **256 kbps** - Very high quality - **192 kbps** - High quality (recommended for music) - **128 kbps** - Standard quality (acceptable for most content) - **96 kbps** - Lower quality, smaller files - **64 kbps** - Voice/podcast quality **Example (C#)**:

```
var lame = audioEncoder as IAudioEncoderProperties;
if (lame != null)
{
    // Set high quality 192 kbps
    lame.set_Bitrate(192);
}
```

---

### Variable Bitrate (VBR)

#### set\_Variable / get\_Variable

Enables or disables variable bitrate mode.

**Parameters**: - `dwVariable`: 1 to enable VBR, 0 to disable (CBR mode)

**Usage Notes**: - VBR provides better quality-to-size ratio than CBR - VBR allocates more bits to complex audio passages - CBR provides predictable file sizes - VBR is recommended for music archival

#### set\_VariableMin / get\_VariableMin

Sets the minimum bitrate for VBR mode.

**Parameters**: - `dwmin`: Minimum bitrate in kbps

#### set\_VariableMax / get\_VariableMax

Sets the maximum bitrate for VBR mode.

**Parameters**: - `dwmax`: Maximum bitrate in kbps

**Example (C#)**:

```
// Enable VBR with 128-256 kbps range
lame.set_Variable(1);
lame.set_VariableMin(128);
lame.set_VariableMax(256);
lame.set_VariableQ(4); // VBR quality level
```

---

### Quality Settings

#### set\_Quality / get\_Quality

Sets the encoding quality for CBR mode. **Parameters**: - `dwQuality`: Quality level (0-9) - **0** - Highest quality (slowest) - **2** - Near-highest quality (recommended) - **5** - Good quality/speed balance - **7** - Faster encoding, lower quality - **9** - Lowest quality (fastest) **Example (C++)**:

```
IAudioEncoderProperties* pLame = nullptr;
pFilter->QueryInterface(IID_IAudioEncoderProperties, (void**)&pLame);
// High quality CBR encoding
pLame->set_Bitrate(192);
pLame->set_Quality(2);
pLame->Release();
```

#### set\_VariableQ / get\_VariableQ

Sets the quality level for VBR mode. **Parameters**: - `dwVBRq`: VBR quality (0-9) - **0** - Highest quality (~245 kbps) - **2** - Very high quality (~190 kbps) - **4** - High quality (~165 kbps) - recommended - **6** - Medium quality (~130 kbps) - **9** - Lowest quality (~65 kbps)

---

### Channel Mode

#### set\_ChannelMode / get\_ChannelMode

Sets the stereo encoding mode.

**Parameters**: - `dwChannelMode`: Channel mode value - **0** - Stereo - **1** - Joint Stereo (recommended) - **2** - Dual Channel - **3** - Mono

**Usage Notes**: - Joint Stereo provides best quality at lower bitrates - Use Stereo for critical listening at high bitrates - Mono reduces file size for speech/podcasts

**Example (C#)**:

```
// Joint stereo for music at 192 kbps
lame.set_ChannelMode(1);
lame.set_Bitrate(192);
```

---

### Encoding Flags

#### set\_CRCFlag / get\_CRCFlag

Enables CRC error protection. **Parameters**: - `dwFlag`: 1 to enable, 0 to disable **Usage**: Adds error detection, minimal size increase (~0.2%)

#### set\_CopyrightFlag / get\_CopyrightFlag

Sets the copyright flag in MP3 header. **Parameters**: - `dwFlag`: 1 if copyrighted, 0 otherwise

#### set\_OriginalFlag / get\_OriginalFlag

Sets the original/copy flag. **Parameters**: - `dwFlag`: 1 for original, 0 for copy

#### set\_VoiceMode / get\_VoiceMode

Optimizes encoding for voice content. **Parameters**: - `dwFlag`: 1 to enable voice optimization **Usage**: Improves quality for speech at lower bitrates **Example (C#)**:

```
// Optimize for podcast/voice content
lame.set_VoiceMode(1);
lame.set_Bitrate(64);
lame.set_ChannelMode(3); // Mono
```

#### set\_XingTag / get\_XingTag

Adds Xing VBR tag for accurate seeking. **Parameters**: - `dwFlag`: 1 to add tag (recommended for VBR) **Usage**: Essential for VBR files to enable proper seeking

---

## Configuration Management

### SaveAudioEncoderPropertiesToRegistry

Saves the current encoder configuration to the registry.

**Usage Notes**: - Must be called after changing properties - Settings persist between sessions - Requires appropriate registry permissions

### LoadAudioEncoderPropertiesFromRegistry

Loads encoder configuration from the registry.

### DefaultAudioEncoderProperties

Resets all encoder properties to default values based on input stream type.

### InputTypeDefined

Checks if the input format has been specified.

**Returns**: - `S_OK` - Input type is defined, encoder can be configured - `E_FAIL` - Input type not specified, configuration may fail

---

## Complete Examples

### Example 1: High Quality Music Encoding (C#)

```
using VisioForge.DirectShowAPI;
public void ConfigureHighQualityMP3(IBaseFilter audioEncoder)
{
    var lame = audioEncoder as IAudioEncoderProperties;
    if (lame == null)
        return;
    // Check if input is connected
    if (lame.InputTypeDefined() != 0)
    {
        Console.WriteLine("Warning: Input not connected, using defaults");
    }
    // High quality VBR settings
    lame.set_Variable(1);              // Enable VBR
    lame.set_VariableQ(2);             // Very high quality
    lame.set_VariableMin(192);         // Min 192 kbps
    lame.set_VariableMax(320);         // Max 320 kbps
    // Joint stereo for efficiency
    lame.set_ChannelMode(1);
    // Quality flags
    lame.set_XingTag(1);               // Add VBR tag
    lame.set_OriginalFlag(1);          // Mark as original
    lame.set_CopyrightFlag(1);         // Set copyright
    // Save settings
    lame.SaveAudioEncoderPropertiesToRegistry();
}
```

### Example 2: Podcast/Voice Encoding (C++)

```
#include "LAME.h"
HRESULT ConfigurePodcastMP3(IBaseFilter* pAudioEncoder)
{
    HRESULT hr;
    IAudioEncoderProperties* pLame = nullptr;
    hr = pAudioEncoder->QueryInterface(IID_IAudioEncoderProperties,
                                       (void**)&pLame);
    if (FAILED(hr))
        return hr;
    // Voice-optimized settings
    pLame->set_VoiceMode(1);           // Voice optimization
    pLame->set_Bitrate(64);            // 64 kbps for speech
    pLame->set_Quality(5);             // Balanced quality
    pLame->set_ChannelMode(3);         // Mono
    // Disable VBR for predictable file size
    pLame->set_Variable(0);
    // Add Xing tag for compatibility
    pLame->set_XingTag(1);
    // Save configuration
    pLame->SaveAudioEncoderPropertiesToRegistry();
    pLame->Release();
    return S_OK;
}
```

### Example 3: Standard Music Encoding (Delphi)

## ``` procedure ConfigureStandardMP3(AudioEncoder: IBaseFilter); var Lame: IAudioEncoderProperties; hr: HRESULT; begin if Succeeded(AudioEncoder.QueryInterface(IID_IAudioEncoderProperties, Lame)) then begin // Standard VBR music settings Lame.set_Variable(1); // Enable VBR Lame.set_VariableQ(4); // High quality (~165 kbps avg) Lame.set_VariableMin(128); // Min 128 kbps Lame.set_VariableMax(256); // Max 256 kbps // Joint stereo Lame.set_ChannelMode(1); // Essential flags Lame.set_XingTag(1); // VBR tag for seeking // Save to registry Lame.SaveAudioEncoderPropertiesToRegistry; Lame := nil; end; end; ```

## Best Practices

### Quality Recommendations

1. **Music Archival**: VBR Q0-Q2 (245-190 kbps average)
2. **Music Distribution**: VBR Q4 (165 kbps) or CBR 192 kbps
3. **Streaming**: CBR 128 kbps
4. **Podcasts/Speech**: CBR 64 kbps mono with voice mode

### Performance Tips

1. **Use Joint Stereo** at bitrates below 192 kbps
2. **Enable VBR** for better quality-to-size ratio
3. **Add Xing Tag** for VBR files
4. **Use Voice Mode** for speech content at <96 kbps

### Configuration Workflow

1. Connect input pin before configuring
2. Check `InputTypeDefined()` before setting properties
3. Configure all desired properties
4. Call `SaveAudioEncoderPropertiesToRegistry()`
5. Verify settings with get methods

---

## Troubleshooting

### Issue: Settings Not Applied

**Solution**:

```
// Ensure input is connected first
if (lame.InputTypeDefined() == 0)
{
    // Configure settings
    lame.set_Bitrate(192);
    lame.SaveAudioEncoderPropertiesToRegistry();
}
else
{
    // Connect input first, then configure
}
```

### Issue: Poor Quality Output

**Solutions**: - Increase VBR quality: `set_VariableQ(2)` or lower - Increase CBR bitrate: `set_Bitrate(192)` or higher - Use better quality setting: `set_Quality(2)` - Disable voice mode for music: `set_VoiceMode(0)`

### Issue: Large File Sizes

**Solutions**:

```
// Use VBR instead of high CBR
pLame->set_Variable(1);
pLame->set_VariableQ(4);        // ~165 kbps average
pLame->set_VariableMax(192);    // Cap maximum bitrate
```

---

## See Also

- [Encoding Filters Pack Overview](../../)
- [Audio Codecs Reference](../../codecs-reference/)
- [AAC Encoder](../aac/)
- [FLAC Encoder](../flac/)

---END OF PAGE---


## MP4 Muxer DirectShow Filter - Timing and Live Streaming
**URL:** https://www.visioforge.com/help/docs/directshow/filters-enc/interfaces/mp4-muxer/
**Description:** MP4 muxer DirectShow interfaces with threading configuration, timing correction, and live streaming options for MP4 container output.
**Tags:** DirectShow, C++, Windows, Streaming, Encoding, MP4, C#
**API:** MP4V10Flags, IBaseFilter, MP4MuxerStandardConfig, MP4MuxerDeterministicConfig, MP4V10LiveStreamingConfig

# MP4 Muxer Interface Reference

## Overview

The MP4 muxer DirectShow filters provide interfaces for configuring MP4 (MPEG-4 Part 14) container output. These interfaces allow developers to control threading behavior, timing correction, and special handling for live streaming scenarios.

Two muxer interfaces are available: - **IMP4MuxerConfig**: Basic MP4 muxer configuration for threading and timing - **IMP4V10MuxerConfig**: Advanced configuration for version 10 muxer with timing flags and live streaming control

## IMP4MuxerConfig Interface

### Overview

The **IMP4MuxerConfig** interface provides basic configuration for MP4 multiplexing, controlling single-threaded operation and timing correction behavior.

**Interface GUID**: `{99DC9BE5-0AFA-45d4-8370-AB021FB07CF4}`

**Inherits From**: `IUnknown`

### Interface Definitions

#### C# Definition

```
using System;
using System.Runtime.InteropServices;

namespace VisioForge.DirectShowAPI
{
    /// <summary>
    /// MP4 muxer configuration interface.
    /// Controls threading and timing behavior for MP4 container creation.
    /// </summary>
    [ComImport]
    [Guid("99DC9BE5-0AFA-45d4-8370-AB021FB07CF4")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IMP4MuxerConfig
    {
        /// <summary>
        /// Gets the single-thread processing state.
        /// </summary>
        /// <param name="pValue">Receives true if single-threaded mode is enabled, false otherwise</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_SingleThread([Out] [MarshalAs(UnmanagedType.Bool)] out bool pValue);

        /// <summary>
        /// Enables or disables single-threaded processing.
        /// When enabled, all muxer operations run on a single thread for deterministic behavior.
        /// </summary>
        /// <param name="value">True to enable single-threaded mode, false for multi-threaded</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_SingleThread([In] [MarshalAs(UnmanagedType.Bool)] bool value);

        /// <summary>
        /// Gets the timing correction state.
        /// </summary>
        /// <param name="pValue">Receives true if timing correction is enabled, false otherwise</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int get_CorrectTiming([Out] [MarshalAs(UnmanagedType.Bool)] out bool pValue);

        /// <summary>
        /// Enables or disables timing correction.
        /// When enabled, the muxer adjusts timestamps to correct timing drift and inconsistencies.
        /// </summary>
        /// <param name="value">True to enable timing correction, false to disable</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int put_CorrectTiming([In] [MarshalAs(UnmanagedType.Bool)] bool value);
    }
}
```

#### C++ Definition

```
#include <unknwn.h>

// {99DC9BE5-0AFA-45d4-8370-AB021FB07CF4}
DEFINE_GUID(IID_IMP4MuxerConfig,
    0x99dc9be5, 0x0afa, 0x45d4, 0x83, 0x70, 0xab, 0x02, 0x1f, 0xb0, 0x7c, 0xf4);

/// <summary>
/// MP4 muxer configuration interface.
/// Controls threading and timing behavior.
/// </summary>
DECLARE_INTERFACE_(IMP4MuxerConfig, IUnknown)
{
    /// <summary>
    /// Gets the single-thread processing state.
    /// </summary>
    /// <param name="pValue">Pointer to receive single-thread enabled state</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_SingleThread)(THIS_
        BOOL* pValue
        ) PURE;

    /// <summary>
    /// Enables or disables single-threaded processing.
    /// </summary>
    /// <param name="value">TRUE to enable single-threaded mode, FALSE for multi-threaded</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_SingleThread)(THIS_
        BOOL value
        ) PURE;

    /// <summary>
    /// Gets the timing correction state.
    /// </summary>
    /// <param name="pValue">Pointer to receive timing correction enabled state</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(get_CorrectTiming)(THIS_
        BOOL* pValue
        ) PURE;

    /// <summary>
    /// Enables or disables timing correction.
    /// </summary>
    /// <param name="value">TRUE to enable timing correction, FALSE to disable</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(put_CorrectTiming)(THIS_
        BOOL value
        ) PURE;
};
```

#### Delphi Definition

```
uses
  ActiveX, ComObj;

const
  IID_IMP4MuxerConfig: TGUID = '{99DC9BE5-0AFA-45d4-8370-AB021FB07CF4}';

type
  /// <summary>
  /// MP4 muxer configuration interface.
  /// </summary>
  IMP4MuxerConfig = interface(IUnknown)
    ['{99DC9BE5-0AFA-45d4-8370-AB021FB07CF4}']

    /// <summary>
    /// Gets the single-thread processing state.
    /// </summary>
    function get_SingleThread(out pValue: BOOL): HRESULT; stdcall;

    /// <summary>
    /// Enables or disables single-threaded processing.
    /// </summary>
    function put_SingleThread(value: BOOL): HRESULT; stdcall;

    /// <summary>
    /// Gets the timing correction state.
    /// </summary>
    function get_CorrectTiming(out pValue: BOOL): HRESULT; stdcall;

    /// <summary>
    /// Enables or disables timing correction.
    /// </summary>
    function put_CorrectTiming(value: BOOL): HRESULT; stdcall;
  end;
```

### Method Reference

#### get\_SingleThread / put\_SingleThread

Controls whether the muxer processes data using a single thread or multiple threads.

**Single-Threaded Mode (enabled)**: - All muxing operations run on one thread - Deterministic, predictable behavior - Easier debugging and troubleshooting - Slightly lower performance on multi-core systems - **Recommended for**: Scenarios requiring consistent, reproducible output

**Multi-Threaded Mode (disabled)**: - Muxer can use multiple threads for processing - Better performance on multi-core processors - Non-deterministic operation order - **Recommended for**: High-performance encoding with multiple streams

**Default**: Typically multi-threaded (false)

**Example**:

```
// Enable single-threaded mode for consistent output
mp4Muxer.put_SingleThread(true);
```

#### get\_CorrectTiming / put\_CorrectTiming

Enables or disables automatic timestamp correction for audio and video streams.

**Timing Correction Enabled (true)**: - Muxer automatically adjusts timestamps to correct drift - Fixes timing inconsistencies from source filters - Ensures proper A/V synchronization - Adds small processing overhead - **Recommended for**: Most scenarios, especially with live sources

**Timing Correction Disabled (false)**: - Timestamps passed through without modification - Assumes source filters provide accurate timestamps - Slightly better performance - **Use only when**: Source provides guaranteed accurate timestamps

**Default**: Typically enabled (true)

**Example**:

```
// Enable timing correction for A/V sync
mp4Muxer.put_CorrectTiming(true);
```

---

## IMP4V10MuxerConfig Interface

### Overview

The **IMP4V10MuxerConfig** interface provides advanced configuration for the version 10 MP4 muxer, including timing override flags and live streaming control. **Interface GUID**: `{9E26CE8B-6708-4535-AAA4-23F9A97C7937}` **Inherits From**: `IUnknown`

### MP4V10Flags Enumeration

```
/// <summary>
/// MP4 v10 muxer configuration flags.
/// </summary>
[Flags]
public enum MP4V10Flags
{
    /// <summary>
    /// No special flags.
    /// </summary>
    None = 0,
    /// <summary>
    /// Time override mode - allows manual timestamp control.
    /// </summary>
    TimeOverride = 0x00000001,
    /// <summary>
    /// Time adjust mode - enables automatic timestamp adjustment.
    /// </summary>
    TimeAdjust = 0x00000002
}
```

### Interface Definitions

#### C# Definition

```
using System;
using System.Runtime.InteropServices;
namespace VisioForge.DirectShowAPI
{
    /// <summary>
    /// MP4 v10 muxer flags.
    /// </summary>
    [Flags]
    public enum MP4V10Flags
    {
        /// <summary>
        /// Default - no special flags.
        /// </summary>
        None = 0,
        /// <summary>
        /// Time override - allows manual timestamp control.
        /// </summary>
        TimeOverride = 0x00000001,
        /// <summary>
        /// Time adjust - enables automatic timestamp adjustment.
        /// </summary>
        TimeAdjust = 0x00000002
    }
    /// <summary>
    /// MP4 version 10 muxer configuration interface.
    /// Provides advanced timing control and live streaming options.
    /// </summary>
    [ComImport]
    [Guid("9E26CE8B-6708-4535-AAA4-23F9A97C7937")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IMP4V10MuxerConfig
    {
        /// <summary>
        /// Sets the muxer configuration flags.
        /// </summary>
        /// <param name="value">Combination of MP4V10Flags values</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetFlags([In] uint value);
        /// <summary>
        /// Gets the current muxer configuration flags.
        /// </summary>
        /// <param name="pValue">Receives the current flags</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int GetFlags([Out] out uint pValue);
        /// <summary>
        /// Disables live streaming optimizations.
        /// When disabled, muxer uses standard file-based output mode.
        /// </summary>
        /// <param name="liveDisabled">True to disable live mode, false to enable</param>
        /// <returns>HRESULT (0 for success)</returns>
        [PreserveSig]
        int SetLiveDisabled([MarshalAs(UnmanagedType.Bool)] bool liveDisabled);
    }
}
```

#### C++ Definition

```
#include <unknwn.h>
// {9E26CE8B-6708-4535-AAA4-23F9A97C7937}
DEFINE_GUID(IID_IMP4V10MuxerConfig,
    0x9e26ce8b, 0x6708, 0x4535, 0xaa, 0xa4, 0x23, 0xf9, 0xa9, 0x7c, 0x79, 0x37);
/// <summary>
/// MP4 v10 muxer flags.
/// </summary>
enum MP4V10Flags
{
    MP4V10_NONE = 0,
    MP4V10_TIME_OVERRIDE = 0x00000001,
    MP4V10_TIME_ADJUST = 0x00000002
};
/// <summary>
/// MP4 version 10 muxer configuration interface.
/// Provides advanced timing control and live streaming options.
/// </summary>
DECLARE_INTERFACE_(IMP4V10MuxerConfig, IUnknown)
{
    /// <summary>
    /// Sets the muxer configuration flags.
    /// </summary>
    /// <param name="value">Combination of MP4V10Flags values</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(SetFlags)(THIS_
        unsigned long value
        ) PURE;
    /// <summary>
    /// Gets the current muxer configuration flags.
    /// </summary>
    /// <param name="pValue">Pointer to receive current flags</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(GetFlags)(THIS_
        unsigned long* pValue
        ) PURE;
    /// <summary>
    /// Disables live streaming optimizations.
    /// </summary>
    /// <param name="liveDisabled">TRUE to disable live mode, FALSE to enable</param>
    /// <returns>S_OK for success</returns>
    STDMETHOD(SetLiveDisabled)(THIS_
        BOOL liveDisabled
        ) PURE;
};
```

#### Delphi Definition

```
uses
  ActiveX, ComObj;
const
  IID_IMP4V10MuxerConfig: TGUID = '{9E26CE8B-6708-4535-AAA4-23F9A97C7937}';
  // MP4V10Flags constants
  MP4V10_NONE = 0;
  MP4V10_TIME_OVERRIDE = $00000001;
  MP4V10_TIME_ADJUST = $00000002;
type
  /// <summary>
  /// MP4 version 10 muxer configuration interface.
  /// </summary>
  IMP4V10MuxerConfig = interface(IUnknown)
    ['{9E26CE8B-6708-4535-AAA4-23F9A97C7937}']
    /// <summary>
    /// Sets the muxer configuration flags.
    /// </summary>
    function SetFlags(value: Cardinal): HRESULT; stdcall;
    /// <summary>
    /// Gets the current muxer configuration flags.
    /// </summary>
    function GetFlags(out pValue: Cardinal): HRESULT; stdcall;
    /// <summary>
    /// Disables live streaming optimizations.
    /// </summary>
    function SetLiveDisabled(liveDisabled: BOOL): HRESULT; stdcall;
  end;
```

### Method Reference

#### SetFlags / GetFlags

Sets or retrieves the muxer configuration flags that control timing behavior. **MP4V10Flags Values**: **None (0)**: - Standard operation - Default timestamp handling - No special timing modifications **TimeOverride (0x00000001)**: - Enables manual timestamp override - Allows application to control timestamps directly - Disables automatic timestamp generation - **Use when**: Application needs full control over timing **TimeAdjust (0x00000002)**: - Enables automatic timestamp adjustment - Muxer corrects timing drift and irregularities - Similar to IMP4MuxerConfig::CorrectTiming - **Use for**: Sources with inconsistent timestamps **Combining Flags**:

```
// Enable both time override and adjust
uint flags = (uint)(MP4V10Flags.TimeOverride | MP4V10Flags.TimeAdjust);
mp4V10Muxer.SetFlags(flags);
```

#### SetLiveDisabled

Controls whether the muxer operates in live streaming mode or file-based mode. **Live Mode Enabled** (liveDisabled = false): - Optimized for live/real-time streaming - Minimal buffering - Lower latency - Progressive MP4 output (can be played while being written) - **Use for**: Live streaming to file, network streaming output **Live Mode Disabled** (liveDisabled = true): - Standard file-based muxing - Can perform multi-pass optimization - Complete MP4 structure written at end - May require seeking in output file - **Use for**: File-based encoding, post-processing scenarios **Example**:

```
// Enable file-based mode (disable live optimizations)
mp4V10Muxer.SetLiveDisabled(true);
```

## Usage Examples

### C# Example - Standard MP4 File Creation

```
using System;
using DirectShowLib;
using VisioForge.DirectShowAPI;
public class MP4MuxerStandardConfig
{
    public void ConfigureStandardMP4(IBaseFilter mp4Muxer)
    {
        // Query the standard MP4 muxer interface
        var muxerConfig = mp4Muxer as IMP4MuxerConfig;
        if (muxerConfig == null)
        {
            Console.WriteLine("Error: Filter does not support IMP4MuxerConfig");
            return;
        }
        // Configure for standard file-based encoding
        muxerConfig.put_SingleThread(false);     // Multi-threaded for performance
        muxerConfig.put_CorrectTiming(true);     // Enable timing correction
        Console.WriteLine("MP4 muxer configured for standard file creation");
        // Verify configuration
        muxerConfig.get_SingleThread(out bool singleThread);
        muxerConfig.get_CorrectTiming(out bool correctTiming);
        Console.WriteLine($"  Single-threaded: {singleThread}");
        Console.WriteLine($"  Timing correction: {correctTiming}");
    }
}
```

### C# Example - Deterministic Output

```
public class MP4MuxerDeterministicConfig
{
    public void ConfigureDeterministicMP4(IBaseFilter mp4Muxer)
    {
        var muxerConfig = mp4Muxer as IMP4MuxerConfig;
        if (muxerConfig == null)
            return;
        // Configure for deterministic, reproducible output
        muxerConfig.put_SingleThread(true);      // Single-threaded for consistency
        muxerConfig.put_CorrectTiming(true);     // Enable timing correction
        Console.WriteLine("MP4 muxer configured for deterministic output");
        Console.WriteLine("  Suitable for regression testing and validation");
    }
}
```

### C# Example - Live Streaming to File (MP4 V10)

```
public class MP4V10LiveStreamingConfig
{
    public void ConfigureLiveStreaming(IBaseFilter mp4V10Muxer)
    {
        // Query the MP4 v10 muxer interface
        var muxerV10Config = mp4V10Muxer as IMP4V10MuxerConfig;
        if (muxerV10Config == null)
        {
            Console.WriteLine("Error: Filter does not support IMP4V10MuxerConfig");
            return;
        }
        // Configure for live streaming to file
        muxerV10Config.SetLiveDisabled(false);   // Enable live mode
        // Enable timing adjustment for live sources
        uint flags = (uint)MP4V10Flags.TimeAdjust;
        muxerV10Config.SetFlags(flags);
        Console.WriteLine("MP4 v10 muxer configured for live streaming");
        // Verify configuration
        muxerV10Config.GetFlags(out uint currentFlags);
        Console.WriteLine($"  Flags: 0x{currentFlags:X8}");
        Console.WriteLine($"  Time Adjust: {((currentFlags & (uint)MP4V10Flags.TimeAdjust) != 0)}");
    }
}
```

### C# Example - Manual Timestamp Control (MP4 V10)

```
public class MP4V10ManualTimestampConfig
{
    public void ConfigureManualTimestamps(IBaseFilter mp4V10Muxer)
    {
        var muxerV10Config = mp4V10Muxer as IMP4V10MuxerConfig;
        if (muxerV10Config == null)
            return;
        // Configure for manual timestamp control
        muxerV10Config.SetLiveDisabled(true);    // Disable live mode
        // Enable time override for manual control
        uint flags = (uint)MP4V10Flags.TimeOverride;
        muxerV10Config.SetFlags(flags);
        Console.WriteLine("MP4 v10 muxer configured for manual timestamp control");
        Console.WriteLine("  Application must provide accurate timestamps");
    }
}
```

### C++ Example - Standard Configuration

```
#include <dshow.h>
#include <iostream>
#include "IMP4MuxerConfig.h"
void ConfigureMP4Muxer(IBaseFilter* pMp4Muxer)
{
    IMP4MuxerConfig* pMuxerConfig = NULL;
    HRESULT hr = S_OK;
    // Query the MP4 muxer interface
    hr = pMp4Muxer->QueryInterface(IID_IMP4MuxerConfig,
                                   (void**)&pMuxerConfig);
    if (FAILED(hr) || !pMuxerConfig)
    {
        std::cout << "Error: Filter does not support IMP4MuxerConfig" << std::endl;
        return;
    }
    // Configure muxer
    pMuxerConfig->put_SingleThread(FALSE);     // Multi-threaded
    pMuxerConfig->put_CorrectTiming(TRUE);     // Enable timing correction
    // Verify configuration
    BOOL singleThread, correctTiming;
    pMuxerConfig->get_SingleThread(&singleThread);
    pMuxerConfig->get_CorrectTiming(&correctTiming);
    std::cout << "MP4 muxer configured:" << std::endl;
    std::cout << "  Single-threaded: " << (singleThread ? "Yes" : "No") << std::endl;
    std::cout << "  Timing correction: " << (correctTiming ? "Yes" : "No") << std::endl;
    pMuxerConfig->Release();
}
```

### C++ Example - Live Streaming (MP4 V10)

```
#include "IMP4V10MuxerConfig.h"
void ConfigureMP4V10LiveStreaming(IBaseFilter* pMp4V10Muxer)
{
    IMP4V10MuxerConfig* pMuxerV10Config = NULL;
    HRESULT hr = pMp4V10Muxer->QueryInterface(IID_IMP4V10MuxerConfig,
                                               (void**)&pMuxerV10Config);
    if (SUCCEEDED(hr) && pMuxerV10Config)
    {
        // Configure for live streaming
        pMuxerV10Config->SetLiveDisabled(FALSE);     // Enable live mode
        // Enable timing adjustment
        unsigned long flags = MP4V10_TIME_ADJUST;
        pMuxerV10Config->SetFlags(flags);
        std::cout << "MP4 v10 muxer configured for live streaming" << std::endl;
        pMuxerV10Config->Release();
    }
}
```

### Delphi Example - Standard Configuration

```
uses
  DirectShow9, ActiveX;
procedure ConfigureMP4Muxer(Mp4Muxer: IBaseFilter);
var
  MuxerConfig: IMP4MuxerConfig;
  SingleThread, CorrectTiming: BOOL;
  hr: HRESULT;
begin
  // Query the MP4 muxer interface
  hr := Mp4Muxer.QueryInterface(IID_IMP4MuxerConfig, MuxerConfig);
  if Failed(hr) or (MuxerConfig = nil) then
  begin
    WriteLn('Error: Filter does not support IMP4MuxerConfig');
    Exit;
  end;
  try
    // Configure muxer
    MuxerConfig.put_SingleThread(False);     // Multi-threaded
    MuxerConfig.put_CorrectTiming(True);     // Enable timing correction
    // Verify configuration
    MuxerConfig.get_SingleThread(SingleThread);
    MuxerConfig.get_CorrectTiming(CorrectTiming);
    WriteLn('MP4 muxer configured:');
    WriteLn('  Single-threaded: ', SingleThread);
    WriteLn('  Timing correction: ', CorrectTiming);
  finally
    MuxerConfig := nil;
  end;
end;
```

### Delphi Example - Live Streaming (MP4 V10)

```
procedure ConfigureMP4V10LiveStreaming(Mp4V10Muxer: IBaseFilter);
var
  MuxerV10Config: IMP4V10MuxerConfig;
  Flags: Cardinal;
begin
  if Succeeded(Mp4V10Muxer.QueryInterface(IID_IMP4V10MuxerConfig, MuxerV10Config)) then
  begin
    try
      // Configure for live streaming
      MuxerV10Config.SetLiveDisabled(False);     // Enable live mode
      // Enable timing adjustment
      Flags := MP4V10_TIME_ADJUST;
      MuxerV10Config.SetFlags(Flags);
      WriteLn('MP4 v10 muxer configured for live streaming');
    finally
      MuxerV10Config := nil;
    end;
  end;
end;
```

## Best Practices

### When to Use IMP4MuxerConfig

**Use IMP4MuxerConfig when**: - You need basic muxer configuration - Working with standard MP4 output - Simple timing correction is sufficient - Don't need advanced live streaming features **Typical Configuration**:

```
mp4Muxer.put_SingleThread(false);    // Multi-threaded for performance
mp4Muxer.put_CorrectTiming(true);    // Enable timing correction
```

### When to Use IMP4V10MuxerConfig

**Use IMP4V10MuxerConfig when**: - Need advanced timing control - Working with live streaming scenarios - Require manual timestamp override - Need progressive MP4 output **Live Streaming Configuration**:

```
mp4V10Muxer.SetLiveDisabled(false);               // Enable live mode
mp4V10Muxer.SetFlags((uint)MP4V10Flags.TimeAdjust); // Auto timing adjustment
```

### Single-Threaded vs Multi-Threaded

**Use Single-Threaded Mode when**: - Debugging muxer behavior - Need deterministic, reproducible output - Running automated tests - Troubleshooting timing issues **Use Multi-Threaded Mode when**: - Performance is critical - Encoding high-resolution video (1080p+) - System has multiple CPU cores available - Standard production encoding

### Timing Correction

**Always Enable Timing Correction when**: - Working with live sources (cameras, capture devices) - Sources may have timestamp inconsistencies - Combining multiple streams (audio + video) - Need reliable A/V synchronization **Can Disable Timing Correction when**: - Source provides guaranteed accurate timestamps - File-based encoding with pre-validated timestamps - Performance is absolutely critical - Using manual timestamp control (TimeOverride flag)

### Live Streaming Optimization

**Enable Live Mode** (SetLiveDisabled = false) **when**: - Encoding for real-time streaming - Output needs to be playable while being written - Creating progressive MP4 files - Low latency is important **Disable Live Mode** (SetLiveDisabled = true) **when**: - Creating files for post-processing - Need complete MP4 structure at end - Can perform multi-pass optimization - Output file will only be played after completion

## Troubleshooting

### Audio/Video Sync Issues

**Symptoms**: Audio and video drift out of sync over time **Solutions**: 1. Enable timing correction: `put_CorrectTiming(true)` 2. For v10 muxer, use TimeAdjust flag: `SetFlags((uint)MP4V10Flags.TimeAdjust)` 3. Verify source filters provide accurate timestamps 4. Check that audio and video sample rates are correct

### File Cannot Be Played While Recording

**Symptom**: MP4 file only playable after encoding completes **Cause**: Live mode is disabled **Solution**: - Use IMP4V10MuxerConfig interface - Enable live mode: `SetLiveDisabled(false)` - This creates progressive MP4 files playable during encoding

### Inconsistent File Output

**Symptoms**: Same input produces different output files **Cause**: Multi-threaded operation with race conditions **Solutions**: 1. Enable single-threaded mode: `put_SingleThread(true)` 2. Enable timing correction: `put_CorrectTiming(true)` 3. Use TimeAdjust flag for v10 muxer

### Performance Issues

**Symptoms**: Encoding slower than expected, high CPU usage **Possible Causes**: 1. Single-threaded mode on multi-core system 2. Excessive timing correction overhead **Solutions**: - Disable single-threaded mode: `put_SingleThread(false)` - If sources have accurate timestamps, can try disabling timing correction - Ensure video encoder (not muxer) is the performance bottleneck - Consider hardware encoding (NVENC, QuickSync)

### Corrupted MP4 Files

**Symptoms**: MP4 file won't play or has errors **Possible Causes**: 1. Timing correction disabled with poor timestamps 2. Incorrect live mode setting for use case 3. Muxer stopped before proper finalization **Solutions**: - Enable timing correction for live sources - Match live mode setting to use case (live vs file-based) - Ensure proper filter graph shutdown and stream finalization - Verify all streams end properly (send EC\_COMPLETE event)

---

## See Also

- [H.264 Encoder Interface](../h264/)
- [AAC Encoder Interfaces](../aac/)
- [Muxers Reference](../../muxers-reference/)
- [Encoding Filters Pack Overview](../../)

---END OF PAGE---


## NVIDIA NVENC Hardware Encoder Settings for DirectShow
**URL:** https://www.visioforge.com/help/docs/directshow/filters-enc/interfaces/nvenc/
**Description:** Configure NVIDIA NVENC hardware encoding in DirectShow with INVEncConfig COM interface. H.264/H.265 codec settings, presets, and GPU selection for C++/C#.
**Tags:** DirectShow, C++, Windows, Streaming, Encoding, H.264, H.265, C#
**API:** IBaseFilter

# INVEncConfig Interface Reference

## Overview

The `INVEncConfig` interface provides comprehensive control over NVIDIA NVENC hardware video encoding. This interface extends the standard DirectShow `IAMVideoCompression` interface with NVENC-specific configuration options for H.264 and H.265 encoding.

NVENC is NVIDIA's dedicated hardware encoder available on GeForce, Quadro, and Tesla GPUs, offering high-performance video encoding with minimal CPU usage.

## Filter and Interface GUIDs

- **Filter CLSID**: `CLSID_NVEncoder` `{6EEC9161-7276-430B-A197-0D4C3BCC87E5}`
- **Interface**: `INVEncConfig` **GUID**: `{9A2AC42C-3E3D-4E6A-84E5-D097292D496B}` **Inherits From**: `IAMVideoCompression` **Header File**: `Intf.h` (C++)
- **Interface**: `INVEncConfig2` **GUID**: `{2A741FB6-6DE1-460B-8FCA-76DB478C9357}` **Inherits From**: `IUnknown` **Header File**: `Intf2.h` (C++)

## Interface Definitions

### C++ Definition (INVEncConfig)

```
#include <strmif.h>

// {9A2AC42C-3E3D-4E6A-84E5-D097292D496B}
static const GUID IID_INVEncConfig =
{ 0x9a2ac42c, 0x3e3d, 0x4e6a, { 0x84, 0xe5, 0xd0, 0x97, 0x29, 0x2d, 0x49, 0x6b } };

// {6EEC9161-7276-430B-A197-0D4C3BCC87E5}
static const GUID CLSID_NVEncoder =
{ 0x6eec9161, 0x7276, 0x430b, { 0xa1, 0x97, 0xd, 0x4c, 0x3b, 0xcc, 0x87, 0xe5 } };

MIDL_INTERFACE("9A2AC42C-3E3D-4E6A-84E5-D097292D496B")
INVEncConfig : public IAMVideoCompression
{
public:
    virtual HRESULT STDMETHODCALLTYPE SetDeviceType(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetDeviceType(int *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetPictureStructure(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetPictureStructure(int *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetNumBuffers(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetNumBuffers(int *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetRateControl(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetRateControl(int *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetPreset(GUID v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetPreset(GUID *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetQp(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetQp(int *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetBFrames(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetBFrames(int *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetGOP(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetGOP(int *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetBitrate(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetBitrate(int *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetVbvBitrate(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetVbvBitrate(int *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetVbvSize(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetVbvSize(int *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetProfile(GUID v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetProfile(GUID *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetLevel(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetLevel(int *v) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetCodec(int v) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetCodec(int *v) = 0;
};
```

### C# Definition (INVEncConfig)

```
using System;
using System.Runtime.InteropServices;
using DirectShowLib;

namespace VisioForge.DirectShowAPI
{
    /// <summary>
    /// NVENC encoder configuration interface.
    /// Provides hardware-accelerated H.264/H.265 encoding on NVIDIA GPUs.
    /// </summary>
    [ComImport]
    [System.Security.SuppressUnmanagedCodeSecurity]
    [Guid("9A2AC42C-3E3D-4E6A-84E5-D097292D496B")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface INVEncConfig
    {
        // Note: Also inherits IAMVideoCompression methods
        // (put_KeyFrameRate, get_KeyFrameRate, put_PFramesPerKeyFrame, etc.)

        /// <summary>Sets the CUDA device index for encoding.</summary>
        /// <param name="v">Device index (0 for first GPU, 1 for second, etc.)</param>
        [PreserveSig]
        int SetDeviceType(int v);

        /// <summary>Gets the CUDA device index.</summary>
        [PreserveSig]
        int GetDeviceType(out int v);

        /// <summary>Sets picture structure (progressive or interlaced).</summary>
        /// <param name="v">0 = Progressive, 1 = Interlaced</param>
        [PreserveSig]
        int SetPictureStructure(int v);

        /// <summary>Gets picture structure.</summary>
        [PreserveSig]
        int GetPictureStructure(out int v);

        /// <summary>Sets number of encoding buffers.</summary>
        /// <param name="v">Buffer count (typically 4-8)</param>
        [PreserveSig]
        int SetNumBuffers(int v);

        /// <summary>Gets number of encoding buffers.</summary>
        [PreserveSig]
        int GetNumBuffers(out int v);

        /// <summary>Sets rate control mode.</summary>
        /// <param name="v">0 = CQP, 1 = VBR, 2 = CBR</param>
        [PreserveSig]
        int SetRateControl(int v);

        /// <summary>Gets rate control mode.</summary>
        [PreserveSig]
        int GetRateControl(out int v);

        /// <summary>Sets encoding preset.</summary>
        /// <param name="v">Preset GUID (P1-P7)</param>
        [PreserveSig]
        int SetPreset(Guid v);

        /// <summary>Gets encoding preset.</summary>
        [PreserveSig]
        int GetPreset(out Guid v);

        /// <summary>Sets quantization parameter for CQP mode.</summary>
        /// <param name="v">QP value (0-51, lower = higher quality)</param>
        [PreserveSig]
        int SetQp(int v);

        /// <summary>Gets quantization parameter.</summary>
        [PreserveSig]
        int GetQp(out int v);

        /// <summary>Sets number of B-frames.</summary>
        /// <param name="v">B-frame count (0-4)</param>
        [PreserveSig]
        int SetBFrames(int v);

        /// <summary>Gets number of B-frames.</summary>
        [PreserveSig]
        int GetBFrames(out int v);

        /// <summary>Sets GOP (Group of Pictures) size.</summary>
        /// <param name="v">GOP size in frames</param>
        [PreserveSig]
        int SetGOP(int v);

        /// <summary>Gets GOP size.</summary>
        [PreserveSig]
        int GetGOP(out int v);

        /// <summary>Sets target bitrate.</summary>
        /// <param name="v">Bitrate in bits per second</param>
        [PreserveSig]
        int SetBitrate(int v);

        /// <summary>Gets target bitrate.</summary>
        [PreserveSig]
        int GetBitrate(out int v);

        /// <summary>Sets VBV buffer bitrate.</summary>
        /// <param name="v">VBV bitrate in bps</param>
        [PreserveSig]
        int SetVbvBitrate(int v);

        /// <summary>Gets VBV buffer bitrate.</summary>
        [PreserveSig]
        int GetVbvBitrate(out int v);

        /// <summary>Sets VBV buffer size.</summary>
        /// <param name="v">VBV size in bits</param>
        [PreserveSig]
        int SetVbvSize(int v);

        /// <summary>Gets VBV buffer size.</summary>
        [PreserveSig]
        int GetVbvSize(out int v);

        /// <summary>Sets encoding profile.</summary>
        /// <param name="v">Profile GUID (Baseline, Main, High, etc.)</param>
        [PreserveSig]
        int SetProfile(Guid v);

        /// <summary>Gets encoding profile.</summary>
        [PreserveSig]
        int GetProfile(out Guid v);

        /// <summary>Sets profile level.</summary>
        /// <param name="v">Level value (30, 31, 40, 41, 50, 51, etc.)</param>
        [PreserveSig]
        int SetLevel(int v);

        /// <summary>Gets profile level.</summary>
        [PreserveSig]
        int GetLevel(out int v);

        /// <summary>Sets video codec.</summary>
        /// <param name="v">0 = H.264, 1 = H.265</param>
        [PreserveSig]
        int SetCodec(int v);

        /// <summary>Gets video codec.</summary>
        [PreserveSig]
        int GetCodec(out int v);
    }

    /// <summary>
    /// NVENC configuration interface 2 - availability check.
    /// </summary>
    [ComImport]
    [System.Security.SuppressUnmanagedCodeSecurity]
    [Guid("2A741FB6-6DE1-460B-8FCA-76DB478C9357")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface INVEncConfig2
    {
        /// <summary>Checks if NVENC is available on the system.</summary>
        /// <param name="result">True if NVENC is available</param>
        /// <param name="status">NVENC status code</param>
        [PreserveSig]
        int CheckNVENCAvailable([MarshalAs(UnmanagedType.Bool)] out bool result, out int status);
    }
}
```

### Delphi Definition (INVEncConfig)

```
uses
  ActiveX, ComObj;

const
  IID_INVEncConfig: TGUID = '{9A2AC42C-3E3D-4E6A-84E5-D097292D496B}';
  IID_INVEncConfig2: TGUID = '{2A741FB6-6DE1-460B-8FCA-76DB478C9357}';
  CLSID_NVEncoder: TGUID = '{6EEC9161-7276-430B-A197-0D4C3BCC87E5}';

type
  /// <summary>
  /// NVENC encoder configuration interface.
  /// Extends IAMVideoCompression with NVENC-specific settings.
  /// </summary>
  INVEncConfig = interface(IUnknown)
    ['{9A2AC42C-3E3D-4E6A-84E5-D097292D496B}']

    // Note: Also inherits IAMVideoCompression methods

    function SetDeviceType(v: Integer): HRESULT; stdcall;
    function GetDeviceType(out v: Integer): HRESULT; stdcall;

    function SetPictureStructure(v: Integer): HRESULT; stdcall;
    function GetPictureStructure(out v: Integer): HRESULT; stdcall;

    function SetNumBuffers(v: Integer): HRESULT; stdcall;
    function GetNumBuffers(out v: Integer): HRESULT; stdcall;

    function SetRateControl(v: Integer): HRESULT; stdcall;
    function GetRateControl(out v: Integer): HRESULT; stdcall;

    function SetPreset(v: TGUID): HRESULT; stdcall;
    function GetPreset(out v: TGUID): HRESULT; stdcall;

    function SetQp(v: Integer): HRESULT; stdcall;
    function GetQp(out v: Integer): HRESULT; stdcall;

    function SetBFrames(v: Integer): HRESULT; stdcall;
    function GetBFrames(out v: Integer): HRESULT; stdcall;

    function SetGOP(v: Integer): HRESULT; stdcall;
    function GetGOP(out v: Integer): HRESULT; stdcall;

    function SetBitrate(v: Integer): HRESULT; stdcall;
    function GetBitrate(out v: Integer): HRESULT; stdcall;

    function SetVbvBitrate(v: Integer): HRESULT; stdcall;
    function GetVbvBitrate(out v: Integer): HRESULT; stdcall;

    function SetVbvSize(v: Integer): HRESULT; stdcall;
    function GetVbvSize(out v: Integer): HRESULT; stdcall;

    function SetProfile(v: TGUID): HRESULT; stdcall;
    function GetProfile(out v: TGUID): HRESULT; stdcall;

    function SetLevel(v: Integer): HRESULT; stdcall;
    function GetLevel(out v: Integer): HRESULT; stdcall;

    function SetCodec(v: Integer): HRESULT; stdcall;
    function GetCodec(out v: Integer): HRESULT; stdcall;
  end;

  /// <summary>
  /// NVENC configuration interface 2 - availability check.
  /// </summary>
  INVEncConfig2 = interface(IUnknown)
    ['{2A741FB6-6DE1-460B-8FCA-76DB478C9357}']

    function CheckNVENCAvailable(out result: BOOL; out status: Integer): HRESULT; stdcall;
  end;
```

## Hardware Requirements

### GPU Generations

| GPU Generation | H.264 | H.265 | Quality | Notes |
| --- | --- | --- | --- | --- |
| **Kepler** (GTX 600/700) | ✓ | ✗ | Basic | 1st generation NVENC |
| **Maxwell** (GTX 900) | ✓ | ✓ | Good | 2nd gen, HEVC support added |
| **Pascal** (GTX 10XX) | ✓ | ✓ | Better | 3rd gen, improved quality |
| **Turing** (RTX 20XX) | ✓ | ✓ | Excellent | 7th gen, B-frame support |
| **Ampere** (RTX 30XX) | ✓ | ✓ | Excellent | 8th gen, AV1 support |
| **Ada/Hopper** (RTX 40XX) | ✓ | ✓ | Best | Latest generation |

### Performance Capabilities

- **1080p @ 60fps**: All NVENC generations
- **4K @ 60fps**: Maxwell and newer
- **8K @ 30fps**: Turing and newer
- **Simultaneous Streams**: 3-5 (varies by GPU)

---

## Methods Reference

All methods inherited from `IAMVideoCompression` are available. The following are NVENC-specific extensions:

### Device Configuration

#### SetDeviceType / GetDeviceType

Sets or retrieves the CUDA device index for encoding. **Syntax (C++)**:

```
HRESULT SetDeviceType(int v);
HRESULT GetDeviceType(int *v);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetDeviceType(int v);
[PreserveSig]
int GetDeviceType(out int v);
```

**Parameters**: - `v`: CUDA device index (0 for first GPU, 1 for second GPU, etc.) **Returns**: `S_OK` (0) on success. **Usage Notes**: - Must be called **before** connecting the encoder filter - Use 0 for systems with single GPU - For multi-GPU systems, select the GPU to use for encoding - Query available CUDA devices using CUDA API or NVIDIA tools **Example (C++)**:

```
INVEncConfig* pNVEnc = nullptr;
pFilter->QueryInterface(IID_INVEncConfig, (void**)&pNVEnc);
// Use first GPU
pNVEnc->SetDeviceType(0);
pNVEnc->Release();
```

---

### Picture Structure

#### SetPictureStructure / GetPictureStructure

Sets the picture coding type (progressive or interlaced).

**Syntax (C++)**:

```
HRESULT SetPictureStructure(int v);
HRESULT GetPictureStructure(int *v);
```

**Parameters**: - `v`: Picture structure type - `0` - Progressive (frame-based) - `1` - Interlaced (field-based)

**Returns**: `S_OK` on success.

**Usage Notes**: - Default is progressive (0) - Use interlaced (1) only for broadcast/DVD content - Progressive is recommended for modern content

**Example (C++)**:

```
// Set progressive encoding
pNVEnc->SetPictureStructure(0);
```

---

### Buffer Configuration

#### SetNumBuffers / GetNumBuffers

Sets the number of encoding buffers. **Syntax (C++)**:

```
HRESULT SetNumBuffers(int v);
HRESULT GetNumBuffers(int *v);
```

**Parameters**: - `v`: Number of buffers (typically 4-8) **Returns**: `S_OK` on success. **Usage Notes**: - More buffers = higher latency but smoother encoding - Fewer buffers = lower latency but potential frame drops - Recommended values: - Low latency: 4 buffers - Normal: 6 buffers - High quality: 8 buffers **Example (C++)**:

```
// Low latency configuration
pNVEnc->SetNumBuffers(4);
```

---

### Rate Control

#### SetRateControl / GetRateControl

Sets the rate control mode for bitrate management.

**Syntax (C++)**:

```
HRESULT SetRateControl(int v);
HRESULT GetRateControl(int *v);
```

**Parameters**: - `v`: Rate control mode - `0` - **CQP** (Constant Quantization Parameter) - Fixed quality - `1` - **VBR** (Variable Bitrate) - Variable bitrate, target quality - `2` - **CBR** (Constant Bitrate) - Fixed bitrate for streaming

**Returns**: `S_OK` on success.

**Rate Control Mode Details**:

| Mode | Bitrate Behavior | Use Case | Quality | File Size |
| --- | --- | --- | --- | --- |
| **CQP** | Varies widely | Archival, highest quality | Excellent | Unpredictable |
| **VBR** | Varies moderately | File storage, YouTube | Very Good | Moderate |
| **CBR** | Constant | Live streaming, broadcasting | Good | Predictable |

**Example (C++)**:

```
// Use CBR for live streaming
pNVEnc->SetRateControl(2);
pNVEnc->SetBitrate(5000000); // 5 Mbps
```

**Example (C#)**:

```
// Use VBR for file recording
nvenc.SetRateControl(1);
nvenc.SetBitrate(8000000); // 8 Mbps target
```

---

### Preset Configuration

#### SetPreset / GetPreset

Sets the encoding preset which balances speed and quality. **Syntax (C++)**:

```
HRESULT SetPreset(GUID v);
HRESULT GetPreset(GUID *v);
```

**Parameters**: - `v`: Preset GUID from NVENC SDK **Preset Options** (typical values): | Preset | Description | Speed | Quality | Use Case | |--------|-------------|-------|---------|----------| | **P1** | Fastest | ★★★★★ | ★☆☆☆☆ | Real-time low-latency | | **P2** | Faster | ★★★★☆ | ★★☆☆☆ | Live streaming | | **P3** | Fast | ★★★☆☆ | ★★★☆☆ | Standard streaming | | **P4** | Medium | ★★☆☆☆ | ★★★★☆ | Balanced (recommended) | | **P5** | Slow | ★☆☆☆☆ | ★★★★☆ | High quality streaming | | **P6** | Slower | ☆☆☆☆☆ | ★★★★★ | Archive quality | | **P7** | Slowest | ☆☆☆☆☆ | ★★★★★ | Maximum quality | **Usage Notes**: - P4 is recommended for most use cases - P1-P2 for low-latency applications - P6-P7 for maximum quality (slower encoding) - Preset affects: motion estimation, lookahead, subpixel motion **Example (C++)**:

```
// Use P4 preset (balanced)
GUID presetP4 = /* GUID for P4 preset */;
pNVEnc->SetPreset(presetP4);
```

---

### Quality Parameter (QP)

#### SetQp / GetQp

Sets the quantization parameter for CQP mode.

**Syntax (C++)**:

```
HRESULT SetQp(int v);
HRESULT GetQp(int *v);
```

**Parameters**: - `v`: QP value (0-51) - Lower values = higher quality, larger files - Higher values = lower quality, smaller files - Typical range: 18-28

**Returns**: `S_OK` on success.

**Usage Notes**: - Only effective when using CQP rate control mode - Ignored in CBR/VBR modes - Recommended values: - High quality: 18-22 - Medium quality: 23-26 - Low quality: 27-30

**Example (C++)**:

```
// High quality CQP encoding
pNVEnc->SetRateControl(0); // CQP mode
pNVEnc->SetQp(20);         // High quality
```

---

### B-Frames Configuration

#### SetBFrames / GetBFrames

Sets the number of B-frames between I and P frames. **Syntax (C++)**:

```
HRESULT SetBFrames(int v);
HRESULT GetBFrames(int *v);
```

**Parameters**: - `v`: Number of B-frames (0-4) - `0` - No B-frames (lowest latency) - `1-2` - Moderate compression improvement - `3-4` - Best compression (higher latency) **Returns**: `S_OK` on success. **Usage Notes**: - B-frames improve compression efficiency - More B-frames = higher latency - Requires Turing (RTX 20XX) or newer for full support - Recommended values: - Low latency: 0 - Streaming: 2 - Recording: 3 **Example (C++)**:

```
// Low latency - disable B-frames
pNVEnc->SetBFrames(0);
// High quality recording - use B-frames
pNVEnc->SetBFrames(3);
```

---

### GOP Configuration

#### SetGOP / GetGOP

Sets the Group of Pictures (keyframe interval) size.

**Syntax (C++)**:

```
HRESULT SetGOP(int v);
HRESULT GetGOP(int *v);
```

**Parameters**: - `v`: GOP size in frames - Typical values: 30-300 frames - Frame rate × seconds = GOP size - Example: 60 fps × 2 seconds = 120 GOP size

**Returns**: `S_OK` on success.

**Usage Notes**: - Smaller GOP = better seeking, larger file - Larger GOP = better compression, poor seeking - For streaming: 2-4 seconds (fps × 2-4) - For recording: 5-10 seconds

**Example (C++)**:

```
// 2-second GOP for 30fps streaming
pNVEnc->SetGOP(60);

// 5-second GOP for 60fps recording
pNVEnc->SetGOP(300);
```

---

### Bitrate Configuration

#### SetBitrate / GetBitrate

Sets the target bitrate for encoding. **Syntax (C++)**:

```
HRESULT SetBitrate(int v);
HRESULT GetBitrate(int *v);
```

**Parameters**: - `v`: Bitrate in bits per second (bps) **Returns**: `S_OK` on success. **Recommended Bitrates**: | Resolution | Framerate | Bitrate (H.264) | Bitrate (H.265) | |------------|-----------|-----------------|-----------------| | 720p | 30 fps | 2.5-4 Mbps | 1.5-2.5 Mbps | | 720p | 60 fps | 4-6 Mbps | 2.5-4 Mbps | | 1080p | 30 fps | 4-6 Mbps | 2.5-4 Mbps | | 1080p | 60 fps | 8-12 Mbps | 5-8 Mbps | | 1440p | 30 fps | 10-15 Mbps | 6-10 Mbps | | 1440p | 60 fps | 15-25 Mbps | 10-15 Mbps | | 4K | 30 fps | 25-40 Mbps | 15-25 Mbps | | 4K | 60 fps | 45-70 Mbps | 30-45 Mbps | **Example (C++)**:

```
// 1080p @ 60fps streaming
pNVEnc->SetBitrate(10000000); // 10 Mbps
```

---

### VBV Buffer Configuration

#### SetVbvBitrate / GetVbvBitrate

Sets the VBV (Video Buffering Verifier) buffer bitrate.

**Syntax (C++)**:

```
HRESULT SetVbvBitrate(int v);
HRESULT GetVbvBitrate(int *v);
```

**Parameters**: - `v`: VBV bitrate in bps (usually same as or higher than target bitrate)

**Usage Notes**: - Controls maximum bitrate spikes - Typically set to 1.0-1.5× target bitrate - Important for streaming to prevent buffer underruns

---

#### SetVbvSize / GetVbvSize

Sets the VBV buffer size. **Syntax (C++)**:

```
HRESULT SetVbvSize(int v);
HRESULT GetVbvSize(int *v);
```

**Parameters**: - `v`: VBV buffer size in bits **Usage Notes**: - Larger buffer = smoother bitrate but higher latency - Smaller buffer = lower latency but more bitrate variance - Typical: 1-2 seconds of video at target bitrate **Example (C++)**:

```
// 10 Mbps stream with 2-second buffer
pNVEnc->SetBitrate(10000000);
pNVEnc->SetVbvBitrate(12000000);  // 1.2× bitrate
pNVEnc->SetVbvSize(20000000);     // 2 seconds
```

---

### Profile Configuration

#### SetProfile / GetProfile

Sets the H.264/H.265 encoding profile.

**Syntax (C++)**:

```
HRESULT SetProfile(GUID v);
HRESULT GetProfile(GUID *v);
```

**Parameters**: - `v`: Profile GUID

**H.264 Profiles**: - **Baseline** - Basic features, mobile compatibility - **Main** - Standard features, most devices - **High** - Advanced features, HD/4K content

**H.265 Profiles**: - **Main** - 8-bit, 4:2:0 - **Main 10** - 10-bit, HDR support

**Usage Notes**: - Use High profile for H.264 in most cases - Use Main profile for maximum compatibility - HEVC Main 10 for HDR content

---

### Level Configuration

#### SetLevel / GetLevel

Sets the profile level (resolution/bitrate constraints). **Syntax (C++)**:

```
HRESULT SetLevel(int v);
HRESULT GetLevel(int *v);
```

**Parameters**: - `v`: Level value (see H.264/H.265 level table) **Common H.264 Levels**: - **30** (3.0) - SD video - **31** (3.1) - 720p @ 30fps - **40** (4.0) - 1080p @ 30fps - **41** (4.1) - 1080p @ 60fps - **50** (5.0) - 4K @ 30fps - **51** (5.1) - 4K @ 60fps **Example (C++)**:

```
// 1080p @ 60fps
pNVEnc->SetLevel(41);
```

---

### Codec Selection

#### SetCodec / GetCodec

Sets the video codec to use.

**Syntax (C++)**:

```
HRESULT SetCodec(int v);
HRESULT GetCodec(int *v);
```

**Parameters**: - `v`: Codec type - `0` - H.264/AVC - `1` - H.265/HEVC

**Returns**: `S_OK` on success.

**Usage Notes**: - H.264 for maximum compatibility - H.265 for better compression (40-50% smaller files) - H.265 requires Maxwell (GTX 900) or newer GPU

**Example (C++)**:

```
// Use H.265
pNVEnc->SetCodec(1);
```

---

## INVEncConfig2 Methods

### CheckNVENCAvailable

Checks if NVENC hardware encoding is available on the system. **Syntax (C++)**:

```
HRESULT CheckNVENCAvailable(BOOL* result, int* status);
```

**Syntax (C#)**:

```
[PreserveSig]
int CheckNVENCAvailable([MarshalAs(UnmanagedType.Bool)] out bool result, out int status);
```

**Parameters**: - `result`: Receives `TRUE` if NVENC is available, `FALSE` otherwise - `status`: Receives NVENC status code (vendor-specific) **Returns**: `S_OK` (0) on success. **Usage Notes**: - Call this before attempting to use NVENC encoder - Returns `FALSE` if: - No NVIDIA GPU is present - GPU doesn't support NVENC (pre-Kepler) - NVIDIA drivers are not installed - NVENC library is not available - The status code provides additional diagnostic information **Example (C++)**:

```
#include "Intf2.h"
HRESULT CheckNVENCSupport(IBaseFilter* pEncoder)
{
    HRESULT hr;
    INVEncConfig2* pNVEnc2 = nullptr;
    hr = pEncoder->QueryInterface(IID_INVEncConfig2, (void**)&pNVEnc2);
    if (FAILED(hr))
    {
        // INVEncConfig2 not supported by this filter
        return hr;
    }
    BOOL available = FALSE;
    int status = 0;
    hr = pNVEnc2->CheckNVENCAvailable(&available, &status);
    if (SUCCEEDED(hr))
    {
        if (available)
        {
            printf("NVENC is available (status: %d)\n", status);
            // Proceed with NVENC configuration
        }
        else
        {
            printf("NVENC not available (status: %d)\n", status);
            // Fall back to software encoder
        }
    }
    pNVEnc2->Release();
    return hr;
}
```

**Example (C#)**:

```
using VisioForge.DirectShowAPI;
public bool IsNVENCAvailable(IBaseFilter encoder)
{
    var nvenc2 = encoder as INVEncConfig2;
    if (nvenc2 == null)
    {
        // INVEncConfig2 not supported
        return false;
    }
    bool available;
    int status;
    int hr = nvenc2.CheckNVENCAvailable(out available, out status);
    if (hr == 0)
    {
        if (available)
        {
            Console.WriteLine($"NVENC is available (status: {status})");
            return true;
        }
        else
        {
            Console.WriteLine($"NVENC not available (status: {status})");
            return false;
        }
    }
    return false;
}
```

**Example (Delphi)**:

```
function CheckNVENCSupport(Encoder: IBaseFilter): Boolean;
var
  NVEnc2: INVEncConfig2;
  Available: BOOL;
  Status: Integer;
  hr: HRESULT;
begin
  Result := False;
  if Succeeded(Encoder.QueryInterface(IID_INVEncConfig2, NVEnc2)) then
  begin
    hr := NVEnc2.CheckNVENCAvailable(Available, Status);
    if Succeeded(hr) then
    begin
      if Available then
      begin
        WriteLn(Format('NVENC is available (status: %d)', [Status]));
        Result := True;
      end
      else
      begin
        WriteLn(Format('NVENC not available (status: %d)', [Status]));
      end;
    end;
    NVEnc2 := nil;
  end;
end;
```

---

## Complete Configuration Examples

### Example 1: Low Latency Streaming (C++)

```
#include "Intf.h"

HRESULT ConfigureLowLatencyNVENC(IBaseFilter* pEncoder)
{
    HRESULT hr;
    INVEncConfig* pNVEnc = nullptr;

    hr = pEncoder->QueryInterface(IID_INVEncConfig, (void**)&pNVEnc);
    if (FAILED(hr))
        return hr;

    // Basic configuration
    pNVEnc->SetDeviceType(0);           // First GPU
    pNVEnc->SetCodec(0);                // H.264
    pNVEnc->SetPictureStructure(0);     // Progressive

    // Low latency settings
    pNVEnc->SetRateControl(2);          // CBR
    pNVEnc->SetBitrate(5000000);        // 5 Mbps
    pNVEnc->SetBFrames(0);              // No B-frames
    pNVEnc->SetGOP(60);                 // 2-second GOP (30fps)
    pNVEnc->SetNumBuffers(4);           // Minimal buffering

    // Fast preset
    GUID presetP2 = /* P2 GUID */;
    pNVEnc->SetPreset(presetP2);

    // Profile/Level for 1080p30
    GUID highProfile = /* High Profile GUID */;
    pNVEnc->SetProfile(highProfile);
    pNVEnc->SetLevel(40);               // Level 4.0

    pNVEnc->Release();
    return S_OK;
}
```

### Example 2: High Quality Recording (C#)

```
using System;
using DirectShowLib;
using VisioForge.DirectShowAPI;

public class NVENCHighQualityRecording
{
    public void ConfigureNVENC(IBaseFilter encoder)
    {
        var nvenc = encoder as INVEncConfig;
        if (nvenc == null)
            throw new NotSupportedException("NVENC not available");

        // Basic configuration
        nvenc.SetDeviceType(0);          // First GPU
        nvenc.SetCodec(1);               // H.265 for better compression
        nvenc.SetPictureStructure(0);    // Progressive

        // High quality VBR settings
        nvenc.SetRateControl(1);         // VBR
        nvenc.SetBitrate(15000000);      // 15 Mbps average
        nvenc.SetBFrames(3);             // Use B-frames
        nvenc.SetGOP(300);               // 5-second GOP (60fps)
        nvenc.SetNumBuffers(8);          // More buffering for quality

        // Quality preset
        Guid presetP6 = /* P6 GUID */;
        nvenc.SetPreset(presetP6);

        // HEVC Main profile for 4K
        Guid hevcMain = /* HEVC Main GUID */;
        nvenc.SetProfile(hevcMain);
        nvenc.SetLevel(51);              // Level 5.1 for 4K60

        // VBV configuration
        nvenc.SetVbvBitrate(20000000);   // 20 Mbps max
        nvenc.SetVbvSize(30000000);      // 2-second buffer
    }
}
```

### Example 3: Balanced Streaming (C++)

```
HRESULT ConfigureBalancedStreaming(IBaseFilter* pEncoder)
{
    INVEncConfig* pNVEnc = nullptr;
    pEncoder->QueryInterface(IID_INVEncConfig, (void**)&pNVEnc);

    // Device and codec
    pNVEnc->SetDeviceType(0);
    pNVEnc->SetCodec(0);                // H.264 for compatibility

    // Balanced CBR streaming
    pNVEnc->SetRateControl(2);          // CBR
    pNVEnc->SetBitrate(8000000);        // 8 Mbps
    pNVEnc->SetBFrames(2);              // Moderate B-frames
    pNVEnc->SetGOP(120);                // 2-second GOP (60fps)
    pNVEnc->SetNumBuffers(6);           // Standard buffering

    // Balanced preset P4
    GUID presetP4 = /* P4 GUID */;
    pNVEnc->SetPreset(presetP4);

    // 1080p60 profile/level
    GUID highProfile = /* High Profile GUID */;
    pNVEnc->SetProfile(highProfile);
    pNVEnc->SetLevel(41);

    // VBV for streaming
    pNVEnc->SetVbvBitrate(10000000);    // 1.25× bitrate
    pNVEnc->SetVbvSize(16000000);       // 2-second buffer

    pNVEnc->Release();
    return S_OK;
}
```

---

## Best Practices

### General Recommendations

1. **Use P4 preset as default** - Best balance of quality and performance
2. **CBR for streaming** - Predictable bitrate for network delivery
3. **VBR for recording** - Better quality for file storage
4. **Disable B-frames for low latency** - Reduces encoding delay
5. **Match GOP to framerate** - 2-4 seconds typical (fps × 2-4)

### Quality Optimization

1. **Higher preset = better quality** - Use P5-P7 when encoding time allows
2. **More B-frames = better compression** - Use 3 for recording
3. **Appropriate bitrate** - Don't go too low, quality suffers significantly
4. **VBV buffer size** - 1-2 seconds at target bitrate

### Performance Optimization

1. **Lower preset = faster encoding** - Use P1-P3 for real-time
2. **Disable B-frames** - Reduces latency and complexity
3. **Fewer encoding buffers** - Lower latency but potential drops
4. **Select appropriate GPU** - Use SetDeviceType() for multi-GPU systems

### Compatibility

1. **Use H.264 High profile** - Maximum compatibility
2. **Set correct level** - Match resolution and framerate
3. **CBR for streaming** - More compatible with players/servers
4. **Standard GOP size** - 2-4 seconds

---

## Troubleshooting

### Issue: NVENC Not Available

**Symptoms**: QueryInterface fails for INVEncConfig

**Solutions**: - Verify NVIDIA GPU is installed - Check GPU generation (Kepler or newer required) - Update NVIDIA drivers to latest version - Verify DirectShow filter is registered

### Issue: Poor Quality Output

**Solutions**:

```
// Increase bitrate
pNVEnc->SetBitrate(15000000);  // Higher bitrate

// Use better preset
pNVEnc->SetPreset(presetP6);   // Slower but better

// Add B-frames
pNVEnc->SetBFrames(3);         // Better compression
```

### Issue: High Latency

**Solutions**:

```
// Disable B-frames
pNVEnc->SetBFrames(0);

// Use faster preset
pNVEnc->SetPreset(presetP1);

// Reduce buffers
pNVEnc->SetNumBuffers(4);

// Smaller GOP
pNVEnc->SetGOP(30);  // 1 second at 30fps
```

### Issue: Bitrate Spikes

**Solutions**:

```
// Use CBR instead of VBR
pNVEnc->SetRateControl(2);

// Configure VBV properly
pNVEnc->SetVbvBitrate(bitrate * 1.2);
pNVEnc->SetVbvSize(bitrate * 2);
```

---

## Performance Benchmarks

### Typical Encoding Performance

| Resolution | Preset | GPU Generation | FPS (approx) |
| --- | --- | --- | --- |
| 1080p | P1 | Pascal+ | 200-300 |
| 1080p | P4 | Pascal+ | 150-200 |
| 1080p | P7 | Pascal+ | 60-100 |
| 4K | P1 | Turing+ | 90-120 |
| 4K | P4 | Turing+ | 60-90 |
| 4K | P7 | Turing+ | 30-50 |
| ### Quality Comparison (PSNR) |  |  |  |
| Preset | Quality vs x264 | Speed vs x264 |  |
| -------- | ----------------- | --------------- |  |
| P1 | -2 dB | 100× faster |  |
| P4 | -0.5 dB | 50× faster |  |
| P7 | ≈ equal | 20× faster |  |
| --- |  |  |  |

## Related Interfaces

- **IAMVideoCompression** - Base DirectShow compression interface
- **IBaseFilter** - DirectShow filter base interface
- **IMediaControl** - Graph control (run, stop)

## See Also

- [Encoding Filters Pack Overview](../../)
- [Codecs Reference](../../codecs-reference/)
- [Code Examples](../../examples/)
- [NVIDIA NVENC Documentation](https://developer.nvidia.com/video-codec-sdk)

---END OF PAGE---


## DirectShow Muxer and Container Format Reference Guide
**URL:** https://www.visioforge.com/help/docs/directshow/filters-enc/muxers-reference/
**Description:** Container format reference for VisioForge DirectShow muxers — MP4, MKV, WebM, MPEG-TS, AVI with codec compatibility and streaming configuration.
**Tags:** DirectShow, C++, Windows, Streaming, Encoding, Decoding, Metadata, HLS, MPEG-DASH, WebRTC, MP4, MKV, WebM, AVI, FLV, TS, OGG, H.264, H.265, VP8, VP9, MPEG-2, AAC, MP3, Opus, FLAC, Vorbis, WAV, AC-3, Speex

# Encoding Filters Pack - Muxers Reference

## Overview

This document provides comprehensive information about all container formats (muxers) supported by the DirectShow Encoding Filters Pack. Muxers combine video and audio streams into container files for storage and streaming.

---

## MP4 Container

### Overview

MPEG-4 Part 14 (MP4) is the most widely used container format for video distribution. **File Extensions**: `.mp4`, `.m4v`, `.m4a` (audio only) **MIME Type**: `video/mp4`, `audio/mp4`

### Supported Codecs

#### Video Codecs

- H.264/AVC ✓ (Primary)
- H.265/HEVC ✓
- MPEG-4 Part 2 ✓
- MPEG-2 ✗ (use MPEG-TS instead)
- VP8/VP9 ✗ (use WebM instead)

#### Audio Codecs

- AAC ✓ (Primary)
- MP3 ✓
- Opus ✗
- Vorbis ✗
- FLAC ✓
- PCM ✓

### Features

**Streaming Support**: - **Progressive Download**: ✓ (with proper moov atom placement) - **Adaptive Streaming**: ✓ (DASH, HLS with fragmented MP4) - **Live Streaming**: ✓ (fragmented MP4) **Metadata Support**: - **Basic Tags**: Title, artist, album, year - **Cover Art**: ✓ - **Chapters**: ✓ - **Subtitles**: ✓ (VTT, SRT, various text formats) **Technical Features**: - **Multiple Audio Tracks**: ✓ - **Multiple Subtitle Tracks**: ✓ - **Fast Start**: ✓ (moov atom at beginning) - **Fragmented MP4**: ✓ (for streaming)

### Best Practices

**For Progressive Download (Web)**:

```
- Place moov atom at beginning (fast start)
- Use H.264 Baseline/Main profile
- AAC-LC audio
- Keyframe interval: 2-4 seconds
```

**For Local Playback**:

```
- H.264 High profile or H.265
- AAC-LC or HE-AAC
- Any keyframe interval
```

**For Streaming (DASH/HLS)**:

```
- Fragmented MP4
- H.264 Main/High profile
- AAC-LC audio
- Short fragments (2-6 seconds)
```

### Compatibility

| Platform/Device | Compatibility |
| --- | --- |
| **Windows Media Player** | ✓ |
| **VLC** | ✓ |
| **Web Browsers** | ✓ |
| **iOS/iPhone** | ✓ |
| **Android** | ✓ |
| **Smart TVs** | ✓ |
| **Game Consoles** | ✓ |
| ### Common Issues |  |
| **Issue**: Video not seekable on web |  |
| - **Solution**: Enable fast start (moov at beginning) |  |
| **Issue**: Audio sync problems |  |
| - **Solution**: Use constant frame rate, check audio sample rate |  |
| --- |  |

## MKV (Matroska) Container

### Overview

Matroska is an open-standard, feature-rich container format.

**File Extensions**: `.mkv` (video), `.mka` (audio), `.mks` (subtitles)

**MIME Type**: `video/x-matroska`, `audio/x-matroska`

### Supported Codecs

#### Video Codecs

- H.264/AVC ✓
- H.265/HEVC ✓
- VP8 ✓
- VP9 ✓
- MPEG-4 Part 2 ✓
- MPEG-2 ✓
- AV1 ✓

#### Audio Codecs

- AAC ✓
- MP3 ✓
- Opus ✓
- Vorbis ✓
- FLAC ✓
- DTS ✓
- AC-3 ✓
- PCM ✓

### Features

**Advanced Features**: - **Multiple Video Tracks**: ✓ - **Multiple Audio Tracks**: ✓ (unlimited) - **Multiple Subtitle Tracks**: ✓ (unlimited) - **Attachments**: ✓ (fonts, cover art) - **Chapters**: ✓ (with nesting) - **Tags/Metadata**: ✓ (extensive) - **Segmenting**: ✓ (linked segments)

**Technical Capabilities**: - **Variable Frame Rate**: ✓ - **Lossless Audio**: ✓ - **3D/Stereoscopic**: ✓ - **HDR Metadata**: ✓

### Best Practices

**For Archival**:

```
- Use FLAC or PCM for lossless audio
- Include all audio/subtitle tracks
- Add chapter markers
- Include metadata tags
```

**For Distribution**:

```
- H.264/H.265 video
- AAC audio (most compatible)
- Embedded soft subtitles
- Reasonable file size
```

**For Streaming**:

```
- Not ideal for streaming
- Consider MP4 or WebM instead
- If used: disable complex features
```

### Compatibility

| Platform/Device | Compatibility |
| --- | --- |
| **Windows Media Player** | ✗ (codec pack required) |
| **VLC** | ✓ |
| **Web Browsers** | ✗ (no native support) |
| **iOS/iPhone** | ✗ (3rd party apps only) |
| **Android** | Limited (app-dependent) |
| **Smart TVs** | Limited (model-dependent) |
| **Media Players** | ✓ (Kodi, Plex, etc.) |

### Common Issues

**Issue**: Seeking is slow - **Solution**: Enable cues (index) during muxing

**Issue**: Playback stuttering with high-quality audio - **Solution**: Check decoder performance, consider AAC instead of lossless

---

## WebM Container

### Overview

WebM is an open, royalty-free format designed for web use. **File Extensions**: `.webm` **MIME Type**: `video/webm`, `audio/webm`

### Supported Codecs

#### Video Codecs

- VP8 ✓ (WebM 1.0)
- VP9 ✓ (WebM 2.0)
- AV1 ✓ (experimental)
- H.264 ✗
- H.265 ✗

#### Audio Codecs

- Vorbis ✓ (Primary)
- Opus ✓ (Recommended)
- AAC ✗
- MP3 ✗

### Features

**Web Optimized**: - **HTML5 Video**: ✓ (native browser support) - **Streaming**: ✓ - **Adaptive Streaming**: ✓ (DASH) - **Low Latency**: ✓ **Metadata Support**: - **Basic Tags**: ✓ - **Chapters**: ✓ - **Subtitles**: ✓ (WebVTT)

### Best Practices

**For YouTube/Web**:

```
- VP9 video codec
- Opus audio codec (96-160 kbps)
- Keyframe interval: 2-4 seconds
- Two-pass encoding for best quality
```

**For Live Streaming**:

```
- VP8 for better encoder performance
- Opus audio (low latency mode)
- CBR bitrate
- Short GOP
```

**For High Quality**:

```
- VP9 with high bitrate
- Opus 128-256 kbps
- Two-pass encoding
- Quality-based rate control
```

### Compatibility

| Platform/Device | Compatibility |
| --- | --- |
| **Chrome** | ✓ |
| **Firefox** | ✓ |
| **Edge** | ✓ |
| **Safari** | Limited (VP8 only) |
| **Android** | ✓ |
| **iOS** | Limited |
| ### Common Issues |  |
| **Issue**: Safari won't play WebM |  |
| - **Solution**: Provide MP4 fallback with H.264 |  |
| **Issue**: Encoding too slow |  |
| - **Solution**: Use VP8 instead of VP9, or hardware-accelerated VP9 if available |  |
| --- |  |

## MPEG-TS (Transport Stream)

### Overview

MPEG Transport Stream is designed for broadcast and streaming, especially where error resilience is important.

**File Extensions**: `.ts`, `.mts`, `.m2ts`

**MIME Type**: `video/mp2t`

### Supported Codecs

#### Video Codecs

- H.264/AVC ✓
- H.265/HEVC ✓
- MPEG-2 ✓
- VP8/VP9 ✗

#### Audio Codecs

- AAC ✓
- MP3 ✓
- AC-3 ✓
- PCM ✓

### Features

**Broadcast Features**: - **Error Resilience**: ✓ (built-in error recovery) - **Time-shifting**: ✓ - **Program Multiplexing**: ✓ (multiple programs in one stream) - **Encryption**: ✓ (conditional access)

**Streaming Features**: - **HLS Streaming**: ✓ (Apple HTTP Live Streaming) - **DVB Broadcasting**: ✓ - **IPTV**: ✓

### Best Practices

**For HLS Streaming**:

```
- H.264 video
- AAC audio
- Segment duration: 6-10 seconds
- CBR encoding
- Closed GOP
```

**For Broadcasting**:

```
- MPEG-2 or H.264
- AC-3 or AAC audio
- Constant bitrate
- Fixed packet size (188 bytes)
```

### Compatibility

| Platform/Device | Compatibility |
| --- | --- |
| **HLS Players** | ✓ |
| **Set-top Boxes** | ✓ |
| **Smart TVs** | ✓ |
| **VLC** | ✓ |
| **Web Browsers** | Via HLS support |

---

## FLV (Flash Video)

### Overview

Legacy format formerly used for web video (YouTube, Flash players). **File Extensions**: `.flv`, `.f4v` **MIME Type**: `video/x-flv` **Status**: ⚠️ Deprecated - Use MP4 or WebM instead

### Supported Codecs

#### Video Codecs

- H.264 ✓
- VP6 ✓ (legacy)
- Sorenson Spark ✓ (legacy)

#### Audio Codecs

- AAC ✓
- MP3 ✓
- Speex ✓

### Features

- **Streaming**: ✓ (RTMP)
- **Metadata**: Basic (onMetaData)
- **Cue Points**: ✓ **Not Recommended**: Flash Player end-of-life (2020) makes FLV obsolete

---

## OGG Container

### Overview

Open-source container primarily for Vorbis audio.

**File Extensions**: `.ogg`, `.oga` (audio), `.ogv` (video)

**MIME Type**: `audio/ogg`, `video/ogg`

### Supported Codecs

#### Video Codecs

- Theora ✓ (legacy quality)
- VP8 ✗ (use WebM)

#### Audio Codecs

- Vorbis ✓ (Primary)
- Opus ✓
- FLAC ✓
- Speex ✓

### Features

- **Streaming**: ✓
- **Chaining**: ✓ (multiple files in sequence)
- **Metadata**: ✓ (Vorbis comments)

### Best Practices

**For Audio**:

```
- Vorbis or Opus codec
- Quality-based encoding
- Vorbis comments for metadata
```

**For Video**:

```
- Not recommended
- Use WebM (VP8/VP9) instead
```

### Compatibility

| Platform/Device | Compatibility |
| --- | --- |
| **Firefox** | ✓ |
| **Chrome** | ✓ |
| **VLC** | ✓ |
| **Most mobile devices** | Limited |

---

## AVI (Audio Video Interleave)

### Overview

Legacy Microsoft container format. **File Extensions**: `.avi` **MIME Type**: `video/x-msvideo` **Status**: ⚠️ Legacy - Use MP4 or MKV for new projects

### Supported Codecs

#### Video Codecs

- H.264 ✓ (limited support)
- MPEG-4 Part 2 ✓
- MPEG-2 ✓
- Various legacy codecs ✓

#### Audio Codecs

- MP3 ✓
- PCM ✓
- AC-3 ✓
- AAC Limited

### Limitations

- **Max File Size**: 2 GB (without OpenDML)
- **Limited Metadata**: Very basic
- **No Streaming**: Not designed for streaming
- **No Chapters**: Not supported

### When to Use

- Legacy system compatibility
- Capture from old hardware
- Specific software requirements **Recommendation**: Use MP4 or MKV for new projects

---

## WAV Container

### Overview

Uncompressed audio container.

**File Extensions**: `.wav`

**MIME Type**: `audio/wav`, `audio/x-wav`

### Features

- **Lossless**: ✓ (PCM)
- **Compressed**: ✓ (MP3, AAC in WAV wrapper)
- **Metadata**: Limited (RIFF tags)

### Common Formats

- **PCM 44.1 kHz 16-bit**: CD quality
- **PCM 48 kHz 24-bit**: Professional audio
- **PCM 96 kHz 24-bit**: High-resolution audio

### Best Practices

**For Audio Production**:

```
- 48 kHz, 24-bit PCM
- Mono or stereo
- Avoid compression
```

**For Distribution**:

```
- Use FLAC or AAC instead
- WAV files are large
```

---

## Container Selection Guide

### For Web Delivery

**Primary**: MP4 (H.264 + AAC) - **Reason**: Universal compatibility - **Fallback**: WebM (VP9 + Opus) for modern browsers

### For Professional Archival

**Primary**: MKV (H.265 + FLAC) - **Reason**: Feature-rich, lossless audio support - **Alternative**: MP4 (H.265 + AAC) for better compatibility

### For Broadcast/IPTV

**Primary**: MPEG-TS (H.264 + AAC) - **Reason**: Error resilience, industry standard - **Alternative**: MPEG-TS (MPEG-2 + AC-3) for legacy systems

### For Live Streaming

**HLS**: MPEG-TS segments (H.264 + AAC) **DASH**: Fragmented MP4 (H.264 + AAC) **WebRTC**: Opus audio, VP8/H.264 video

### For Audio-Only

**High Quality**: FLAC (.flac) or MP3 VBR (.mp3) **Streaming**: AAC in MP4 (.m4a) or Opus in WebM **Voice**: Opus in OGG or Speex

---

## Format Comparison Table

| Feature | MP4 | MKV | WebM | MPEG-TS | FLV | OGG |
| --- | --- | --- | --- | --- | --- | --- |
| **Web Compatibility** | ★★★★★ | ★☆☆☆☆ | ★★★★☆ | ★★☆☆☆ | ☆☆☆☆☆ | ★★☆☆☆ |
| **Mobile Compatibility** | ★★★★★ | ★★☆☆☆ | ★★★☆☆ | ★★★★☆ | ☆☆☆☆☆ | ★☆☆☆☆ |
| **Streaming Support** | ★★★★★ | ★★☆☆☆ | ★★★★★ | ★★★★★ | ★★★☆☆ | ★★★☆☆ |
| **Feature Richness** | ★★★★☆ | ★★★★★ | ★★★☆☆ | ★★★☆☆ | ★★☆☆☆ | ★★☆☆☆ |
| **Codec Support** | ★★★★☆ | ★★★★★ | ★★☆☆☆ | ★★★☆☆ | ★★☆☆☆ | ★★★☆☆ |
| **File Size Efficiency** | ★★★★☆ | ★★★★☆ | ★★★★★ | ★★★☆☆ | ★★★☆☆ | ★★★★☆ |
| **Error Resilience** | ★★☆☆☆ | ★★☆☆☆ | ★★☆☆☆ | ★★★★★ | ★★★☆☆ | ★★☆☆☆ |

---

## Technical Specifications

### MP4 Structure

```
ftyp (file type)
moov (metadata - place at beginning for fast start)
  ├── mvhd (movie header)
  ├── trak (video track)
  ├── trak (audio track)
  └── udta (user data/metadata)
mdat (media data)
```

### Fragmented MP4 (for streaming)

```
ftyp
moov
  └── mvex (movie extends)
moof (movie fragment)
  └── traf (track fragment)
mdat (fragment data)
[repeat moof/mdat for each fragment]
```

### MKV Structure

## ``` EBML Header Segment ├── SeekHead (index) ├── Info (segment information) ├── Tracks (track definitions) ├── Chapters (optional) ├── Attachments (optional) ├── Tags (metadata) └── Cluster (media data) ```

## See Also

- [Encoding Filters Pack Overview](../)
- [Codecs Reference](../codecs-reference/)
- [Code Examples](../examples/)
- [NVENC Interface Reference](../interfaces/nvenc/)

---END OF PAGE---


## Register DirectShow Filters in C++, C#, and Delphi
**URL:** https://www.visioforge.com/help/docs/directshow/how-to-register/
**Description:** Register DirectShow filters and SDKs in C++, C#, and Delphi with IVFRegister interface and alternative registration code examples.
**Tags:** DirectShow, C++, Windows, C#
**API:** IVFRegister

# SDK Registration Guide

DirectShow filters and SDK components often require proper registration to function correctly within your applications. This guide provides detailed implementation methods for registering DirectShow filters across multiple programming languages.

## Registration Overview

Most DirectShow filters in the SDK can be registered using the IVFRegister interface. This standardized approach works consistently across development environments. However, some specialized filters (like RGB2YUV converters) are designed to work without explicit registration.

## Registration Methods by Language

### C++ Implementation

The following C++ code demonstrates how to access the registration interface:

```
// {59E82754-B531-4A8E-A94D-57C75F01DA30}
DEFINE_GUID(IID_IVFRegister,
    0x59E82754, 0xB531, 0x4A8E, 0xA9, 0x4D, 0x57, 0xC7, 0x5F, 0x01, 0xDA, 0x30);

/// <summary>
/// Filter registration interface.
/// </summary>
DECLARE_INTERFACE_(IVFRegister, IUnknown)
{
    /// <summary>
    /// Sets registered.
    /// </summary>
    /// <param name="licenseKey">
    /// License Key.
    /// </param>
    STDMETHOD(SetLicenseKey)
        (THIS_
            WCHAR * licenseKey
            )PURE;
};
```

### C# Implementation

For .NET developers, the registration interface can be imported using the following C# code:

```
    /// <summary>
    /// Public filter registration interface.
    /// </summary>
    [ComImport]
    [System.Security.SuppressUnmanagedCodeSecurity]
    [Guid("59E82754-B531-4A8E-A94D-57C75F01DA30")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IVFRegister
    {
        /// <summary>
        /// Sets registered.
        /// </summary>
        /// <param name="licenseKey">
        /// License Key.
        /// </param>
        [PreserveSig]
        void SetLicenseKey([In, MarshalAs(UnmanagedType.LPWStr)] string licenseKey);
    }
```

### Delphi Implementation

For Delphi developers, implement the registration interface as follows:

```
const
  IID_IVFRegister: TGUID = '{59E82754-B531-4A8E-A94D-57C75F01DA30}';

type
  /// <summary>
  /// Public filter registration interface.
  /// </summary>
  IVFRegister = interface(IUnknown)
    /// <summary>
    /// Sets registered.
    /// </summary>
    /// <param name="licenseKey">
    /// License Key.
    /// </param>
    procedure SetLicenseKey(licenseKey: PWideChar); stdcall;
  end;
```

---END OF PAGE---


## DirectShow Filters for Video Playback, Encoding & Effects
**URL:** https://www.visioforge.com/help/docs/directshow/
**Description:** DirectShow filters for FFmpeg/VLC playback, H.264/H.265/NVENC encoding, 35+ video effects, chroma key, virtual camera, and AES-256 encryption.
**Tags:** DirectShow, C++, Windows

# DirectShow SDKs and Filters for Video Development

## Introduction to DirectShow Technology

DirectShow technology enables developers to create robust multimedia applications for capturing, processing, and playing video content. Our comprehensive suite of DirectShow filters and SDKs provides the essential building blocks for developing sophisticated video processing and playback applications with minimal effort.

## Playback and Decoding Solutions

### High-Performance Source Filters

Our powerful source filters enable seamless playback of diverse video formats in your custom applications. Built upon industry-standard libraries, these filters ensure maximum compatibility and performance.

#### VLC Source DirectShow Filter

The VLC Source filter delivers exceptional playback capabilities for numerous media formats, leveraging the versatile VLC media framework for optimal performance and format support.

- [Explore VLC Source DirectShow Filter](vlc-source-filter/)

#### FFMPEG Source DirectShow Filter

Our FFMPEG-based filters provide unparalleled media format compatibility, utilizing the widely-adopted FFMPEG libraries to handle virtually any video or audio format in your applications.

- [Discover FFMPEG Source DirectShow Filter](ffmpeg-source-filters/)

## Advanced Encoding Solutions

### Professional Encoding Filters

Our encoding filters enable developers to implement high-quality video and audio encoding directly within applications. The suite supports numerous industry-standard codecs for maximum flexibility.

- [Browse the Complete Encoding Filters Pack](filters-enc/)

## Video Processing and Enhancement

### Specialized Processing Filters

Transform and enhance video content with our processing filters that enable rotation, scaling, color grading, overlay capabilities, and numerous other visual effects to create professional-quality video output.

- [Explore Video Processing Filters Pack](proc-filters/)

## Virtual Camera Implementation

### Virtual Camera Development SDK

Create and integrate virtual camera devices into your applications with our specialized SDK. The virtual camera seamlessly interfaces with any DirectShow-compatible application, including popular video conferencing software.

- [Learn about Virtual Camera SDK](virtual-camera-sdk/)

## Secure Video Solutions

### Video Content Encryption SDK

Implement robust video content protection with our encryption SDK. Secure your video assets while maintaining playback compatibility with standard DirectShow players such as Windows Media Player and MPC-BE.

- [Discover Video Encryption SDK](video-encryption-sdk/)

## Implementation Guides

### Technical Documentation and Tutorials

Get started quickly with our detailed technical tutorials designed specifically for developers implementing DirectShow components:

- [DirectShow Filter and SDK Registration Guide](how-to-register/)

---END OF PAGE---


## DirectShow Video Effects Reference - 35+ Filters Guide
**URL:** https://www.visioforge.com/help/docs/directshow/proc-filters/effects-reference/
**Description:** Complete reference for 35+ DirectShow video effects including color filters, deinterlacing, denoising, and artistic effects.
**Tags:** DirectShow, C++, Windows, Streaming, Effects, Mixing, Webcam, C#
**API:** CVFEffectType, CVFEffect, CVFGraphicLogoMain, CVFStretchMode, CVFTextLogoMain

# Video Effects Complete Reference

## Overview

The DirectShow Processing Filters Pack provides 35+ real-time video effects that can be applied individually or chained together. This reference documents all available effects, their parameters, and usage.

## Effect Categories

- **Text and Graphics** - Text logos, graphic overlays
- **Color Filters** - Red, green, blue, greyscale filters
- **Image Adjustment** - Brightness, contrast, saturation
- **Spatial Effects** - Flip, mirror, rotate
- **Artistic Effects** - Marble, solarize, posterize, mosaic
- **Noise and Quality** - Denoising algorithms (CAST, adaptive, mosquito)
- **Deinterlacing** - Blend, triangle, CAVT methods
- **Creative Effects** - Blur, shake, spray, invert

---

## Text and Graphics Effects

### ef\_text\_logo

Renders text overlay on video with extensive customization options. **Effect Type**: `CVFEffectType.ef_text_logo` **Parameters** (`CVFTextLogoMain` structure): | Parameter | Type | Description | Default | |-----------|------|-------------|---------| | `x` | int | X position (pixels) | 0 | | `y` | int | Y position (pixels) | 0 | | `text` | BSTR | Text to display | "" | | `font_name` | BSTR | Font family name | "Arial" | | `font_size` | int | Font size (points) | 12 | | `font_color` | COLORREF | Text color (RGB) | 0xFFFFFF (white) | | `font_italic` | BOOL | Italic style | FALSE | | `font_bold` | BOOL | Bold style | FALSE | | `font_underline` | BOOL | Underline style | FALSE | | `font_strikeout` | BOOL | Strikethrough style | FALSE | | `transparent_bg` | BOOL | Transparent background | TRUE | | `bg_color` | COLORREF | Background color | 0x000000 (black) | | `transp` | DWORD | Transparency level (0-255) | 255 (opaque) | | `align` | CVFTextAlign | Text alignment | `al_left` | | `antialiasing` | CVFTextAntialiasingMode | Anti-aliasing mode | `am_AntiAlias` | | `gradient` | BOOL | Enable gradient | FALSE | | `gradientMode` | CVFTextGradientMode | Gradient direction | `gm_horizontal` | | `gradientColor1` | COLORREF | Gradient start color | 0xFFFFFF | | `gradientColor2` | COLORREF | Gradient end color | 0x000000 | | `borderMode` | CVFTextBorderMode | Border/outline style | `bm_none` | | `innerBorderColor` | COLORREF | Inner border color | 0x000000 | | `outerBorderColor` | COLORREF | Outer border color | 0xFFFFFF | | `innerBorderSize` | int | Inner border width | 1 | | `outerBorderSize` | int | Outer border width | 1 | | `DateMode` | BOOL | Display current date/time | FALSE | | `DateMask` | BSTR | Date format string | "" | **Text Alignment Options**: - `al_left` - Left-aligned - `al_center` - Center-aligned - `al_right` - Right-aligned **Border Modes**: - `bm_none` - No border - `bm_inner` - Inner outline - `bm_outer` - Outer outline - `bm_inner_and_outer` - Both sides - `bm_embossed` - 3D embossed effect - `bm_outline` - Standard outline - `bm_filled_outline` - Solid outline - `bm_halo` - Glow effect **Example (C++)**:

```
CVFEffect effect;
effect.Type = ef_text_logo;
effect.Enabled = TRUE;
effect.TextLogo.x = 10;
effect.TextLogo.y = 10;
effect.TextLogo.text = SysAllocString(L"Live Stream");
effect.TextLogo.font_name = SysAllocString(L"Arial");
effect.TextLogo.font_size = 32;
effect.TextLogo.font_color = RGB(255, 255, 255);
effect.TextLogo.font_bold = TRUE;
effect.TextLogo.borderMode = bm_outline;
effect.TextLogo.outerBorderColor = RGB(0, 0, 0);
effect.TextLogo.outerBorderSize = 2;
pEffects->add_effect(effect);
```

---

### ef\_graphic\_logo

Overlays an image (logo, watermark) on video.

**Effect Type**: `CVFEffectType.ef_graphic_logo`

**Parameters** (`CVFGraphicLogoMain` structure):

| Parameter | Type | Description |
| --- | --- | --- |
| `x` | UINT32 | X position (pixels) |
| `y` | UINT32 | Y position (pixels) |
| `Filename` | BSTR | Path to image file (BMP, PNG, JPG) |
| `hBmp` | int | Handle to bitmap (alternative to filename) |
| `StretchMode` | CVFStretchMode | How to scale image |
| `TranspLevel` | int | Transparency level (0-255) |
| `UseColorKey` | BOOL | Enable color key transparency |
| `ColorKey` | COLORREF | Color to make transparent |

**Stretch Modes**: - `sm_none` - Original size - `sm_stretch` - Stretch to fit - `sm_letterbox` - Fit with aspect ratio - `sm_crop` - Crop to fit

**Example (C#)**:

```
var effect = new CVFEffect
{
    Type = (int)CVFEffectType.ef_graphic_logo,
    Enabled = true,
    GraphicLogo = new CVFGraphicLogoMain
    {
        Filename = @"C:\Images\logo.png",
        x = 20,
        y = 20,
        StretchMode = (int)CVFStretchMode.sm_none,
        TranspLevel = 200,
        UseColorKey = false
    }
};

effectsInterface.add_effect(effect);
```

---

## Color Filter Effects

### ef\_blue

Applies blue color filter (enhances blue, reduces other colors). **Effect Type**: `CVFEffectType.ef_blue` **Parameters**: - `pAmountI` - Filter intensity (0-100, default: 50) **Use Cases**: - Artistic blue tint - Cold atmosphere - Water/ocean scenes

---

### ef\_green

Applies green color filter.

**Effect Type**: `CVFEffectType.ef_green`

**Parameters**: - `pAmountI` - Filter intensity (0-100)

**Use Cases**: - Night vision effect - Forest/nature scenes - Matrix-style effect

---

### ef\_red

Applies red color filter. **Effect Type**: `CVFEffectType.ef_red` **Parameters**: - `pAmountI` - Filter intensity (0-100) **Use Cases**: - Warm atmosphere - Sunset effect - Alert/danger scenes

---

### ef\_filter\_blue / ef\_filter\_blue\_2

Advanced blue filtering with different algorithms.

**Effect Type**: `CVFEffectType.ef_filter_blue` or `ef_filter_blue_2`

**Difference**: `ef_filter_blue_2` uses alternative color math for different visual results.

---

### ef\_filter\_green / ef\_filter\_green2

Advanced green filtering (two variants). **Effect Types**: `CVFEffectType.ef_filter_green`, `ef_filter_green2`

---

### ef\_filter\_red / ef\_filter\_red2

Advanced red filtering (two variants).

**Effect Types**: `CVFEffectType.ef_filter_red`, `ef_filter_red2`

---

### ef\_greyscale

Converts video to black and white. **Effect Type**: `CVFEffectType.ef_greyscale` **Parameters**: None (full greyscale conversion) **Use Cases**: - Classic film look - Artistic effect - Reduce color noise **Example (C++)**:

```
CVFEffect effect;
effect.Type = ef_greyscale;
effect.Enabled = TRUE;
pEffects->add_effect(effect);
```

---

### ef\_invert

Inverts all colors (negative image).

**Effect Type**: `CVFEffectType.ef_invert`

**Parameters**: None

**Use Cases**: - Artistic effect - X-ray appearance - Special visual effects

---

## Image Adjustment Effects

### ef\_contrast

Adjusts image contrast. **Effect Type**: `CVFEffectType.ef_contrast` **Parameters**: - `pAmountI` - Contrast adjustment (-100 to +100) - Negative: Decrease contrast - Positive: Increase contrast - Default: 0 (no change) **Example (C#)**:

```
var effect = new CVFEffect
{
    Type = (int)CVFEffectType.ef_contrast,
    Enabled = true,
    pAmountI = 25  // Increase contrast by 25%
};
```

---

### ef\_lightness

Adjusts overall brightness.

**Effect Type**: `CVFEffectType.ef_lightness`

**Parameters**: - `pAmountI` - Brightness adjustment (-100 to +100) - Negative: Darken - Positive: Brighten - Default: 0

---

### ef\_darkness

Darkens the image (opposite of lightness). **Effect Type**: `CVFEffectType.ef_darkness` **Parameters**: - `pAmountI` - Darkness amount (0-100)

---

### ef\_saturation

Adjusts color saturation.

**Effect Type**: `CVFEffectType.ef_saturation`

**Parameters**: - `pAmountI` - Saturation adjustment (-100 to +100) - -100: Greyscale - 0: Original colors - +100: Hyper-saturated

**Use Cases**: - Vivid colors for promotional content - Desaturate for muted look - Color grading

---

## Spatial Effects

### ef\_flip\_down

Flips video vertically (upside down). **Effect Type**: `CVFEffectType.ef_flip_down` **Parameters**: None **Use Cases**: - Correct upside-down camera - Mirror effect with rotation - Special effects

---

### ef\_flip\_right

Flips video horizontally (mirror).

**Effect Type**: `CVFEffectType.ef_flip_right`

**Parameters**: None

**Use Cases**: - Webcam mirror mode - Correct mirrored camera - Symmetry effects

---

### ef\_mirror\_down

Creates vertical mirror effect (top reflects to bottom). **Effect Type**: `CVFEffectType.ef_mirror_down`

---

### ef\_mirror\_right

Creates horizontal mirror effect (left reflects to right).

**Effect Type**: `CVFEffectType.ef_mirror_right`

---

## Artistic Effects

### ef\_blur

Applies Gaussian blur to the image. **Effect Type**: `CVFEffectType.ef_blur` **Parameters**: - `pAmountI` - Blur amount (0-100) - `pSizeI` - Blur kernel size (1-20) **Use Cases**: - Background blur (depth of field simulation) - Soften image - Privacy (blur faces, license plates) **Example (C++)**:

```
CVFEffect effect;
effect.Type = ef_blur;
effect.Enabled = TRUE;
effect.pAmountI = 50;  // 50% blur strength
effect.pSizeI = 10;    // 10-pixel blur radius
pEffects->add_effect(effect);
```

---

### ef\_marble

Creates marble/swirl texture effect.

**Effect Type**: `CVFEffectType.ef_marble`

**Parameters**: - `pAmountD` - Effect intensity (0.0-1.0) - `pTurbulenceI` - Turbulence amount (0-100) - `pScaleD` - Scale factor (0.1-10.0)

**Use Cases**: - Artistic background - Transition effects - Psychedelic visuals

---

### ef\_posterize

Reduces number of colors (poster art effect). **Effect Type**: `CVFEffectType.ef_posterize` **Parameters**: - `pAmountI` - Color levels (2-256) - Lower values: Fewer colors, more dramatic - Higher values: More colors, subtle effect **Use Cases**: - Pop art style - Comic book effect - Reduce color depth

---

### ef\_mosaic

Creates pixelated/mosaic effect.

**Effect Type**: `CVFEffectType.ef_mosaic`

**Parameters**: - `pSizeI` - Mosaic block size (2-100 pixels)

**Use Cases**: - Privacy (blur faces/identities) - Retro pixel art style - Censorship

**Example (C#)**:

```
var effect = new CVFEffect
{
    Type = (int)CVFEffectType.ef_mosaic,
    Enabled = true,
    pSizeI = 15  // 15x15 pixel blocks
};
```

---

### ef\_solorize

Creates solarization effect (partial color inversion). **Effect Type**: `CVFEffectType.ef_solorize` (legacy spelling preserved in the API — use this exact identifier) **Parameters**: - `pAmountI` - Solarization threshold (0-255) **Use Cases**: - Artistic photography effect - Retro look - Creative transitions

---

### ef\_spray

Creates paint spray/splatter effect.

**Effect Type**: `CVFEffectType.ef_spray`

**Parameters**: - `pAmountI` - Spray intensity (0-100)

---

### ef\_shake\_down

Simulates camera shake effect vertically. **Effect Type**: `CVFEffectType.ef_shake_down` **Parameters**: - `pAmountI` - Shake intensity (0-100) **Use Cases**: - Earthquake effect - Impact vibration - Handheld camera simulation

---

## Noise Processing Effects

### ef\_denoise\_cast

CAST (Combined Adaptive Spatial-Temporal) denoising algorithm.

**Effect Type**: `CVFEffectType.ef_denoise_cast`

**Parameters** (`CVFDenoiseCAST` structure):

| Parameter | Range | Default | Description |
| --- | --- | --- | --- |
| `TemporalDifferenceThreshold` | 0-255 | 16 | Motion detection threshold |
| `NumberOfMotionPixelsThreshold` | 0-16 | 0 | Min pixels for motion |
| `StrongEdgeThreshold` | 0-255 | 8 | Edge preservation |
| `BlockWidth` | 1-16 | 4 | Processing block width |
| `BlockHeight` | 1-16 | 4 | Processing block height |
| `EdgePixelWeight` | 0-255 | 128 | Edge blending weight |
| `NonEdgePixelWeight` | 0-255 | 16 | Smooth area weight |
| `GaussianThresholdY` | int | 12 | Luma noise threshold |
| `GaussianThresholdUV` | int | 6 | Chroma noise threshold |
| `HistoryWeight` | 0-255 | 192 | Temporal filtering strength |

**Use Cases**: - Low-light video cleanup - Webcam noise reduction - Compression artifact removal

**Example (C++)**:

```
CVFEffect effect;
effect.Type = ef_denoise_cast;
effect.Enabled = TRUE;

// Moderate noise reduction
effect.DenoiseCAST.TemporalDifferenceThreshold = 20;
effect.DenoiseCAST.StrongEdgeThreshold = 10;
effect.DenoiseCAST.GaussianThresholdY = 15;
effect.DenoiseCAST.GaussianThresholdUV = 8;

pEffects->add_effect(effect);
```

---

### ef\_denoise\_adaptive

Adaptive noise reduction that adjusts to image content. **Effect Type**: `CVFEffectType.ef_denoise_adaptive` **Parameters**: - `pDenoiseAdaptiveThreshold` - Noise threshold (0-100) - `pDenoiseAdaptiveBlurMode` - Blur method (0-2) **Use Cases**: - General noise reduction - Video cleanup - Quality enhancement

---

### ef\_denoise\_mosquito

Reduces mosquito noise (compression artifacts around edges).

**Effect Type**: `CVFEffectType.ef_denoise_mosquito`

**Parameters**: - `pAmountI` - Reduction strength (0-100)

**Use Cases**: - Clean up heavily compressed video - Remove MPEG/H.264 artifacts - Post-processing for streaming

---

### ef\_color\_noise

Adds color noise (grain) to image. **Effect Type**: `CVFEffectType.ef_color_noise` **Parameters**: - `pAmountI` - Noise amount (0-100) **Use Cases**: - Film grain effect - Retro/vintage look - Artistic texture

---

### ef\_mono\_noise

Adds monochrome (black & white) noise.

**Effect Type**: `CVFEffectType.ef_mono_noise`

**Parameters**: - `pAmountI` - Noise amount (0-100)

---

## Deinterlacing Effects

### ef\_deint\_blend

Blends interlaced fields together. **Effect Type**: `CVFEffectType.ef_deint_blend` **Parameters** (`CVFDeintBlend` structure): | Parameter | Range | Default | Description | |-----------|-------|---------|-------------| | `blendThresh1` | 0-255 | 5 | First blend threshold | | `blendThresh2` | 0-255 | 9 | Second blend threshold | | `blendConstants1` | 0.0-1.0 | 0.3 | First blend weight | | `blendConstants2` | 0.0-1.0 | 0.7 | Second blend weight | **Use Cases**: - Deinterlace analog video - Remove comb artifacts - Convert interlaced to progressive

---

### ef\_deint\_triangle

Triangle interpolation deinterlacing.

**Effect Type**: `CVFEffectType.ef_deint_triangle`

**Parameters**: - `pDeintTriangleWeight` - Interpolation weight (0-100)

**Quality**: Better edge preservation than blend

---

### ef\_deint\_cavt

CAVT (Content Adaptive Vertical Temporal) deinterlacing. **Effect Type**: `CVFEffectType.ef_deint_cavt` **Parameters**: - `pDeintCAVTThreshold` - Motion threshold (0-100) **Quality**: Best quality, most CPU intensive **Use Cases**: - High-quality deinterlacing - Broadcast video conversion - Archival processing

---

## Effect Chaining

Multiple effects can be applied simultaneously. Effects are processed in the order they were added.

**Example: Professional Stream Enhancement**:

```
// 1. Denoise
CVFEffect denoise;
denoise.Type = ef_denoise_adaptive;
denoise.Enabled = TRUE;
denoise.pDenoiseAdaptiveThreshold = 15;
pEffects->add_effect(denoise);

// 2. Color correction
CVFEffect saturation;
saturation.Type = ef_saturation;
saturation.Enabled = TRUE;
saturation.pAmountI = 15;  // Slight saturation boost
pEffects->add_effect(saturation);

// 3. Add branding
CVFEffect logo;
logo.Type = ef_graphic_logo;
logo.Enabled = TRUE;
logo.GraphicLogo.Filename = SysAllocString(L"logo.png");
logo.GraphicLogo.x = 20;
logo.GraphicLogo.y = 20;
pEffects->add_effect(logo);

// 4. Add timestamp
CVFEffect timestamp;
timestamp.Type = ef_text_logo;
timestamp.Enabled = TRUE;
timestamp.TextLogo.DateMode = TRUE;
timestamp.TextLogo.DateMask = SysAllocString(L"%Y-%m-%d %H:%M:%S");
timestamp.TextLogo.x = 20;
timestamp.TextLogo.y = 1050;  // Bottom left
pEffects->add_effect(timestamp);
```

---

## Performance Considerations

### CPU Usage by Effect

**Low Impact** (< 5% CPU): - Color filters - Greyscale - Invert - Flip/Mirror **Medium Impact** (5-15% CPU): - Text/graphic overlays - Contrast/brightness - Posterize - Simple deinterlacing **High Impact** (15-40% CPU): - Blur (large radius) - Denoise (CAST, adaptive) - Mosaic (small blocks) - Marble/artistic effects

### Optimization Tips

1. **Limit simultaneous effects** - Each effect adds processing time
2. **Use appropriate parameters** - Larger blur radius = more CPU
3. **Disable unused effects** - Set `Enabled = FALSE` instead of removing
4. **Process at lower resolution** - Downscale, apply effects, upscale
5. **Use GPU rendering when possible** - Check for GPU-accelerated effects

---

## Common Effect Combinations

### Webcam Enhancement

```
1. ef_denoise_adaptive (threshold: 15)
2. ef_contrast (amount: +10)
3. ef_saturation (amount: +15)
4. ef_flip_right (mirror mode)
```

### Vintage Film Look

```
1. ef_greyscale
2. ef_contrast (amount: +20)
3. ef_mono_noise (amount: 15)
```

### Broadcast Quality

```
1. ef_deint_cavt
2. ef_denoise_mosquito (amount: 20)
3. ef_saturation (amount: +5)
```

### Privacy Mode

```
1. ef_mosaic (size: 20) on specific region
2. ef_blur (amount: 80) as alternative
```

---

## See Also

- [Processing Filters Pack Overview](../)
- [Video Effects Interface Reference](../interfaces/effects-interface/)
- [Chroma Key Interface](../interfaces/chroma-key/)
- [Video Mixer Interface](../interfaces/video-mixer/)
- [Code Examples](../examples/)

---END OF PAGE---


## DirectShow Video Effects, Mixer, and Chroma Key Examples
**URL:** https://www.visioforge.com/help/docs/directshow/proc-filters/examples/
**Description:** Code examples for Video Effects, Video Mixer, and Chroma Key filters in C++, C#, and VB.NET with DirectShow integration.
**Tags:** DirectShow, C++, Windows, Effects, Mixing, C#
**API:** IBaseFilter, IVFChromaKey, IVFVideoMixer

# Processing Filters Pack - Code Examples

## Overview

This page provides practical code examples for using the Processing Filters Pack, which includes:

- **Video Effects** - 35+ real-time effects (text, graphics, color adjustments, denoise)
- **Video Mixer** - 2-16 source mixing with PIP, alpha blending, chroma key
- **Chroma Key** - Green/blue screen compositing

---

## Prerequisites

### C++ Projects

```
#include <dshow.h>
#include <streams.h>
#include "IVFEffects45.h"
#include "IVFVideoMixer.h"
#include "IVFChromaKey.h"
#pragma comment(lib, "strmiids.lib")
```

### C# Projects

```
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;
using System.Runtime.InteropServices;
using System.Drawing;
```

**NuGet Packages**: - VisioForge.DirectShowAPI - MediaFoundationCore

---

## Video Effects Examples

### Example 1: Basic Video Effect

Apply a single video effect to a source.

#### C# Implementation

```
using System;
using System.Runtime.InteropServices;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;

public class VideoEffectsBasicExample
{
    private IFilterGraph2 filterGraph;
    private IMediaControl mediaControl;
    private IBaseFilter sourceFilter;
    private IBaseFilter effectFilter;

    public void PlayWithEffect(string filename, IntPtr videoWindowHandle)
    {
        filterGraph = (IFilterGraph2)new FilterGraph();
        mediaControl = (IMediaControl)filterGraph;

        // Add source filter (e.g., File Source)
        filterGraph.AddSourceFilter(filename, "Source", out sourceFilter);

        // Add Video Effects filter
        effectFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFVideoEffects,
            "Video Effects");

        // Configure effect using IVFEffects45 interface
        var effects = effectFilter as IVFEffects45;
        if (effects != null)
        {
            // Enable Greyscale effect via VideoEffectSimple struct
            var eff = new VideoEffectSimple
            {
                Type = (int)VideoEffectType.Greyscale,
                Enabled = true
            };
            effects.add_effect(eff);
        }
        captureGraph.SetFiltergraph(filterGraph);

        // Render through effect filter
        captureGraph.RenderStream(null, MediaType.Video, sourceFilter, effectFilter, null);
        captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);

        // Set up video window
        var videoWindow = (IVideoWindow)filterGraph;
        videoWindow.put_Owner(videoWindowHandle);
        videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);

        // Run
        mediaControl.Run();

        Marshal.ReleaseComObject(captureGraph);
    }

    public void Stop()
    {
        mediaControl?.Stop();

        FilterGraphTools.RemoveAllFilters(filterGraph);

        if (sourceFilter != null) Marshal.ReleaseComObject(sourceFilter);
        if (effectFilter != null) Marshal.ReleaseComObject(effectFilter);
        if (mediaControl != null) Marshal.ReleaseComObject(mediaControl);
        if (filterGraph != null) Marshal.ReleaseComObject(filterGraph);
    }
}
```

#### C++ Implementation

```
HRESULT ApplyVideoEffect(LPCWSTR filename)
{
    IGraphBuilder* pGraph = NULL;
    IBaseFilter* pSource = NULL;
    IBaseFilter* pEffect = NULL;
    IVFEffects45* pEffects = NULL;

    // Create filter graph
    HRESULT hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
                                  IID_IGraphBuilder, (void**)&pGraph);
    if (FAILED(hr)) return hr;

    // Add source
    hr = pGraph->AddSourceFilter(filename, L"Source", &pSource);
    if (FAILED(hr)) goto cleanup;

    // Create Video Effects filter
    hr = CoCreateInstance(CLSID_VFVideoEffects, NULL, CLSCTX_INPROC_SERVER,
                         IID_IBaseFilter, (void**)&pEffect);
    if (FAILED(hr)) goto cleanup;

    hr = pGraph->AddFilter(pEffect, L"Video Effects");
    if (FAILED(hr)) goto cleanup;

    // Configure effect
    hr = pEffect->QueryInterface(IID_IVFEffects45, (void**)&pEffects);
    if (SUCCEEDED(hr))
    {
        // Enable greyscale via VideoEffectSimple struct
        VideoEffectSimple effect;
        ZeroMemory(&effect, sizeof(effect));
        effect.Type = ef_greyscale;
        effect.Enabled = TRUE;
        pEffects->add_effect(&effect);
        pEffects->Release();
    }

    // Connect filters and render...
    // (Use RenderStream or ConnectFilters)

cleanup:
    if (pEffect) pEffect->Release();
    if (pSource) pSource->Release();
    if (pGraph) pGraph->Release();

    return hr;
}
```

---

### Example 2: Multiple Effects Chain

Apply multiple effects simultaneously.

#### C# Multiple Effects

## ``` public class MultipleEffectsExample { public void ApplyMultipleEffects(IBaseFilter effectFilter) { var effects = effectFilter as IVFEffects45; if (effects != null) { // Add darkness/brightness effect (VideoEffectType.Darkness, AmountI controls level) effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Darkness, Enabled = true, AmountI = 50 // 0 = darkest, 100 = brightest }); // Add contrast effect (AmountI controls intensity) effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Contrast, Enabled = true, AmountI = 75 // Contrast intensity }); // Add saturation effect (AmountI controls saturation level) effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Saturation, Enabled = true, AmountI = 120 // Saturation level }); } } } ```

### Example 3: Text Overlay

Add text logo overlay to video.

#### C# Text Overlay

```
public void ApplyTextOverlay(IBaseFilter effectFilter)
{
    var effects = effectFilter as IVFEffects45;
    if (effects != null)
    {
        var eff = new VideoEffectSimple
        {
            Type = (int)VideoEffectType.TextLogo,
            Enabled = true,
            TextLogo = new MFPTextLogo
            {
                X = 50,
                Y = 50,
                Text = "My Video Title",
                FontName = "Arial",
                FontSize = 36,
                FontColor = 0xFFFFFF,        // White
                FontBold = true,
                TransparentBg = true,
                Transp = 255,                // Fully opaque
                BorderMode = 4,              // bm_outline
                OuterBorderColor = 0x000000, // Black outline
                OuterBorderSize = 2
            }
        };
        effects.add_effect(eff);
    }
}
```

See [effects-reference.md](../effects-reference/) for the full `MFPTextLogo` structure (text alignment, gradient, date/time display, anti-aliasing, etc.).

---

### Example 4: Image Overlay

Add graphic watermark or logo.

#### C# Image Overlay

```
public void ApplyImageOverlay(IBaseFilter effectFilter, string imagePath)
{
    var effects = effectFilter as IVFEffects45;
    if (effects != null)
    {
        var eff = new VideoEffectSimple
        {
            Type = (int)VideoEffectType.ImageLogo,
            Enabled = true,
            GraphicalLogo = new MFPGraphicalLogo
            {
                X = 10,              // X position in pixels
                Y = 10,              // Y position in pixels
                Filename = imagePath,
                TranspLevel = 200,   // Semi-transparent (0-255)
                StretchMode = 2      // 0=None, 1=Stretch, 2=Proportional fit
            }
        };
        effects.add_effect(eff);
    }
}
```

## See [effects-reference.md](../effects-reference/) for the full `MFPGraphicalLogo` structure.

### Example 5: Denoise Filters

Apply noise reduction for cleaner video.

#### C# Denoise Examples

```
public void ApplyDenoise(IBaseFilter effectFilter, VideoEffectType denoiseType)
{
    var effects = effectFilter as IVFEffects45;
    if (effects != null)
    {
        var eff = new VideoEffectSimple
        {
            Type = (int)denoiseType,
            Enabled = true
        };

        switch (denoiseType)
        {
            case VideoEffectType.DenoiseCAST:
                // CAST denoise — configure via DenoiseCAST sub-struct
                eff.DenoiseCAST = new MFPDenoiseCAST
                {
                    TemporalDifferenceThreshold = 16,
                    StrongEdgeThreshold = 8
                };
                break;

            case VideoEffectType.DenoiseAdaptive:
                // Adaptive denoise — threshold controls sensitivity
                eff.DenoiseAdaptiveThreshold = 20;   // 0-255
                eff.DenoiseAdaptiveBlurMode = 0;     // 0-3
                break;

            case VideoEffectType.DenoiseMosquito:
                // Mosquito denoise — AmountI controls reduction strength
                eff.AmountI = 30;
                break;
        }

        effects.add_effect(eff);
    }
}
```

---

### Example 6: All Available Effects

Complete list of effects with basic configuration.

#### C# All Effects Reference

```
public class AllEffectsExample
{
    public void DemonstrateAllEffects(IBaseFilter effectFilter)
    {
        var effects = effectFilter as IVFEffects45;
        if (effects == null) return;

        // Color Filters
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Greyscale, Enabled = true });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Invert, Enabled = true });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.FilterRed, Enabled = true });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.FilterGreen, Enabled = true });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.FilterBlue, Enabled = true });

        // Image Adjustment (AmountI controls intensity)
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Darkness, Enabled = true, AmountI = 50 });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Contrast, Enabled = true, AmountI = 75 });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Saturation, Enabled = true, AmountI = 120 });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Lightness, Enabled = true, AmountI = 45 });

        // Spatial Transforms
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.FlipRight, Enabled = true });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.FlipDown, Enabled = true });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.MirrorHorizontal, Enabled = true });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Rotate, Enabled = true, AmountI = 90 });

        // Artistic Effects
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Blur, Enabled = true, AmountI = 5 });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Sharpen, Enabled = true, AmountI = 2 });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Posterize, Enabled = true, AmountI = 8 });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Solorize, Enabled = true, AmountI = 128 });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Mosaic, Enabled = true, SizeI = 10 });

        // Noise Reduction
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.DenoiseCAST, Enabled = true });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.DenoiseAdaptive, Enabled = true, DenoiseAdaptiveThreshold = 20 });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.DenoiseMosquito, Enabled = true, AmountI = 30 });

        // Deinterlacing
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.DeinterlaceBlend, Enabled = true });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.DeinterlaceTriangle, Enabled = true });
        effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.DeinterlaceCAVT, Enabled = true });

        // Overlays (TextLogo/ImageLogo need sub-struct — see Examples 3 & 4)
        // To disable/remove an effect:
        // effects.remove_effect(effectId);
        // effects.clear_effects();
    }
}
```

> **Note:** For the full list of `VideoEffectType` members and sub-struct parameters, see [effects-reference.md](../effects-reference/).

---

## Video Mixer Examples

### Example 7: Picture-in-Picture (PIP)

Mix two video sources with PIP layout.

#### C# Picture-in-Picture

```
public class VideoMixerPIPExample
{
    private IFilterGraph2 filterGraph;
    private IBaseFilter mixerFilter;

    public void CreatePIP(string mainVideoPath, string pipVideoPath, IntPtr videoWindowHandle)
    {
        filterGraph = (IFilterGraph2)new FilterGraph();

        // Add main video source
        filterGraph.AddSourceFilter(mainVideoPath, "Main Source", out IBaseFilter mainSource);

        // Add PIP video source
        filterGraph.AddSourceFilter(pipVideoPath, "PIP Source", out IBaseFilter pipSource);

        // Add Video Mixer filter
        mixerFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFVideoMixer,
            "Video Mixer");

        // Configure mixer — real IVFVideoMixer interface
        var mixer = mixerFilter as IVFVideoMixer;
        if (mixer != null)
        {
            // Set output size
            mixer.SetOutputParam(new VFPIPVideoOutputParam
            {
                Width = 1920,
                Height = 1080,
                FrameRateTime = 30
            });

            // Configure main video (input 0) - fullscreen
            mixer.SetInputParam(0, new VFPIPVideoInputParam
            {
                X = 0, Y = 0,
                Width = 1920, Height = 1080,
                Alpha = 255
            });

            // Configure PIP video (input 1) - bottom-right corner
            mixer.SetInputParam(1, new VFPIPVideoInputParam
            {
                X = 1440,    // 1920 - 480
                Y = 810,     // 1080 - 270
                Width = 480,
                Height = 270,
                Alpha = 255
            });

            // Set Z-order (layering) — per-pin, not bulk array
            mixer.SetInputOrder(0, 0);  // Main behind
            mixer.SetInputOrder(1, 1);  // PIP on top
        }

        // Connect filters
        ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
        captureGraph.SetFiltergraph(filterGraph);

        // Connect main source to mixer input 0
        captureGraph.RenderStream(null, MediaType.Video, mainSource, null, mixerFilter);

        // Connect PIP source to mixer input 1
        // Note: Requires connecting to specific input pin
        IPin mixerInput1 = DsFindPin.ByDirection(mixerFilter, PinDirection.Input, 1);
        captureGraph.RenderStream(null, MediaType.Video, pipSource, null, null);
        // Connect to mixerInput1 explicitly...

        // Render mixer output
        captureGraph.RenderStream(null, MediaType.Video, mixerFilter, null, null);

        // Setup video window
        var videoWindow = (IVideoWindow)filterGraph;
        videoWindow.put_Owner(videoWindowHandle);
        videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);

        // Run
        var mediaControl = (IMediaControl)filterGraph;
        mediaControl.Run();

        Marshal.ReleaseComObject(captureGraph);
    }
}
```

---

### Example 8: Multi-Source Mixing (4 inputs)

Create a 2x2 grid layout with 4 video sources.

#### C# 2x2 Grid Layout

## ``` public class VideoMixerGridExample { public void Create2x2Grid(string[] videoPaths, IntPtr videoWindowHandle) { if (videoPaths.Length != 4) { throw new ArgumentException("Requires exactly 4 video sources"); } var filterGraph = (IFilterGraph2)new FilterGraph(); // Add all source filters IBaseFilter[] sources = new IBaseFilter[4]; for (int i = 0; i < 4; i++) { filterGraph.AddSourceFilter(videoPaths[i], $"Source {i}", out sources[i]); } // Add Video Mixer var mixerFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFVideoMixer, "Video Mixer"); var mixer = mixerFilter as IVFVideoMixer; if (mixer != null) { // Set output size mixer.SetOutputParam(new VFPIPVideoOutputParam { Width = 1920, Height = 1080, FrameRateTime = 30 }); int halfWidth = 960; // 1920 / 2 int halfHeight = 540; // 1080 / 2 // Top-left (Input 0) mixer.SetInputParam(0, new VFPIPVideoInputParam { X = 0, Y = 0, Width = halfWidth, Height = halfHeight, Alpha = 255 }); // Top-right (Input 1) mixer.SetInputParam(1, new VFPIPVideoInputParam { X = halfWidth, Y = 0, Width = halfWidth, Height = halfHeight, Alpha = 255 }); // Bottom-left (Input 2) mixer.SetInputParam(2, new VFPIPVideoInputParam { X = 0, Y = halfHeight, Width = halfWidth, Height = halfHeight, Alpha = 255 }); // Bottom-right (Input 3) mixer.SetInputParam(3, new VFPIPVideoInputParam { X = halfWidth, Y = halfHeight, Width = halfWidth, Height = halfHeight, Alpha = 255 }); // Set Z-order (per-pin) for (int i = 0; i < 4; i++) { mixer.SetInputOrder(i, i); } } // Connect sources to mixer and render... // (Similar to PIP example) var mediaControl = (IMediaControl)filterGraph; mediaControl.Run(); } } ```

### Example 9: Video Mixer with Chroma Key

Mix sources with transparent background.

#### C# Mixer with Chroma Key

```
public void CreateMixerWithChromaKey(string backgroundPath, string foregroundPath)
{
    var filterGraph = (IFilterGraph2)new FilterGraph();

    // Add sources
    filterGraph.AddSourceFilter(backgroundPath, "Background", out IBaseFilter bgSource);
    filterGraph.AddSourceFilter(foregroundPath, "Foreground", out IBaseFilter fgSource);

    // Add mixer
    var mixerFilter = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFVideoMixer,
        "Video Mixer");

    var mixer = mixerFilter as IVFVideoMixer;
    if (mixer != null)
    {
        // Configure output
        mixer.SetOutputParam(new VFPIPVideoOutputParam
        {
            Width = 1920,
            Height = 1080
        });

        // Background (fullscreen)
        mixer.SetInputParam(0, new VFPIPVideoInputParam
        {
            X = 0, Y = 0, Width = 1920, Height = 1080
        });

        // Foreground (centered, smaller)
        mixer.SetInputParam(1, new VFPIPVideoInputParam
        {
            X = 480, Y = 270, Width = 960, Height = 540
        });

        // Enable chroma key — mixer-wide, 4 args
        mixer.SetChromaSettings(
            enabled: true,
            color: ColorTranslator.ToWin32(Color.FromArgb(0, 255, 0)),  // Green
            tolerance1: 50,
            tolerance2: 10);
    }

    // Connect and run...
}
```

---

## Chroma Key Examples

### Example 10: Green Screen Effect

Standalone chroma key filter for green screen removal.

#### C# Chroma Key Filter

```
public class ChromaKeyExample
{
    public void ApplyGreenScreen(string videoPath, string backgroundImagePath, IntPtr videoWindowHandle)
    {
        var filterGraph = (IFilterGraph2)new FilterGraph();
        // Add video source (with green screen)
        filterGraph.AddSourceFilter(videoPath, "Source", out IBaseFilter sourceFilter);
        // Add Chroma Key filter
        var chromaFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFChromaKey,
            "Chroma Key");
        // Configure chroma key — real IVFChromaKey API
        var chromaKey = chromaFilter as IVFChromaKey;
        if (chromaKey != null)
        {
            // Set key color (green) — single int using RGB macro
            chromaKey.put_color(ColorTranslator.ToWin32(Color.FromArgb(0, 255, 0)));

            // Set contrast range (low, high bounds)
            chromaKey.put_contrast(50, 100);

            // Set background image (optional)
            if (!string.IsNullOrEmpty(backgroundImagePath))
            {
                chromaKey.put_image(backgroundImagePath);
            }
        }
        // Connect filters: Source → Chroma Key → Renderer
        ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
        captureGraph.SetFiltergraph(filterGraph);
        captureGraph.RenderStream(null, MediaType.Video, sourceFilter, chromaFilter, null);
        captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);
        // Setup video window
        var videoWindow = (IVideoWindow)filterGraph;
        videoWindow.put_Owner(videoWindowHandle);
        videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);
        // Run
        var mediaControl = (IMediaControl)filterGraph;
        mediaControl.Run();
        Marshal.ReleaseComObject(captureGraph);
    }
}
```

#### C++ Chroma Key

## ``` HRESULT ApplyChromaKey(IBaseFilter* pChromaFilter) { IVFChromaKey* pChromaKey = NULL; HRESULT hr = pChromaFilter->QueryInterface(IID_IVFChromaKey, (void**)&pChromaKey); if (FAILED(hr)) return hr; // Set green color — single COLORREF argument: RGB(0, 255, 0) hr = pChromaKey->put_color(RGB(0, 255, 0)); if (FAILED(hr)) goto cleanup; // Set contrast range (low, high) hr = pChromaKey->put_contrast(40, 90); if (FAILED(hr)) goto cleanup; // Optional: Set background image hr = pChromaKey->put_image(L"C:\\backgrounds\\studio.jpg"); cleanup: pChromaKey->Release(); return hr; } ```

### Example 11: Blue Screen with Fine Tuning

Configure blue screen chroma key with optimal settings.

#### C# Blue Screen

```
public void ApplyBlueScreen(IBaseFilter chromaFilter)
{
    var chromaKey = chromaFilter as IVFChromaKey;
    if (chromaKey != null)
    {
        // Set blue color — single int via RGB
        chromaKey.put_color(ColorTranslator.ToWin32(Color.FromArgb(0, 0, 255)));

        // Fine-tuned contrast range for blue screen
        // Lower low = more strict (less tolerance)
        // Higher high = more loose (more tolerance)
        chromaKey.put_contrast(30, 80);
    }
}
```

---

### Example 12: Custom Color Chroma Key

Use any custom color for keying.

#### C# Custom Color Key

## ``` public void ApplyCustomColorKey(IBaseFilter chromaFilter, Color keyColor) { var chromaKey = chromaFilter as IVFChromaKey; if (chromaKey != null) { // Use any custom color — single int via RGB chromaKey.put_color(ColorTranslator.ToWin32(keyColor)); // Standard contrast range chromaKey.put_contrast(50, 100); } } // Example usage: // ApplyCustomColorKey(chromaFilter, Color.Magenta); // Magenta screen // ApplyCustomColorKey(chromaFilter, Color.FromArgb(255, 180, 0, 220)); // Custom purple ```

## Complete Processing Pipeline

### Example 13: Combined Effects, Mixing, and Chroma Key

Complete example combining all processing filters.

#### C# Complete Pipeline

```
public class CompleteProcessingPipeline
{
    public void CreateCompleteSetup(
        string mainVideoPath,
        string greenScreenVideoPath,
        string backgroundImagePath,
        IntPtr videoWindowHandle)
    {
        var filterGraph = (IFilterGraph2)new FilterGraph();

        // 1. Main video source
        filterGraph.AddSourceFilter(mainVideoPath, "Main Video", out IBaseFilter mainSource);

        // 2. Green screen video source
        filterGraph.AddSourceFilter(greenScreenVideoPath, "Green Screen", out IBaseFilter gsSource);

        // 3. Add Chroma Key filter for green screen
        var chromaFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFChromaKey,
            "Chroma Key");

        var chromaKey = chromaFilter as IVFChromaKey;
        if (chromaKey != null)
        {
            chromaKey.put_color(ColorTranslator.ToWin32(Color.FromArgb(0, 255, 0)));  // Green
            chromaKey.put_contrast(40, 90);
        }

        // 4. Add Video Effects filter
        var effectsFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFVideoEffects,
            "Video Effects");

        var effects = effectsFilter as IVFEffects45;
        if (effects != null)
        {
            // Apply effects via VideoEffectSimple structs
            effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Darkness, Enabled = true, AmountI = 60 });
            effects.add_effect(new VideoEffectSimple { Type = (int)VideoEffectType.Contrast, Enabled = true, AmountI = 80 });

            // Add text overlay
            effects.add_effect(new VideoEffectSimple
            {
                Type = (int)VideoEffectType.TextLogo,
                Enabled = true,
                TextLogo = new MFPTextLogo
                {
                    Text = "LIVE",
                    FontSize = 48,
                    X = 50,
                    Y = 50,
                    FontColor = 0xFFFFFF,
                    FontBold = true
                }
            });
        }

        // 5. Add Video Mixer
        var mixerFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFVideoMixer,
            "Video Mixer");

        var mixer = mixerFilter as IVFVideoMixer;
        if (mixer != null)
        {
            mixer.SetOutputParam(new VFPIPVideoOutputParam { Width = 1920, Height = 1080, FrameRateTime = 30 });

            // Main video (fullscreen background)
            mixer.SetInputParam(0, new VFPIPVideoInputParam { X = 0, Y = 0, Width = 1920, Height = 1080 });

            // Chroma-keyed video (PIP)
            mixer.SetInputParam(1, new VFPIPVideoInputParam { X = 1200, Y = 700, Width = 640, Height = 360 });

            // Set Z-order (per-pin)
            mixer.SetInputOrder(0, 0);
            mixer.SetInputOrder(1, 1);
        }

        // Connect the pipeline:
        // Main Source → Effects → Mixer Input 0
        // GS Source → Chroma Key → Mixer Input 1
        // Mixer → Renderer

        ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
        captureGraph.SetFiltergraph(filterGraph);

        // Connect main path
        captureGraph.RenderStream(null, MediaType.Video, mainSource, effectsFilter, mixerFilter);

        // Connect chroma key path
        // (Requires pin-level connections to specific mixer input)

        // Render mixer output
        captureGraph.RenderStream(null, MediaType.Video, mixerFilter, null, null);

        // Audio
        captureGraph.RenderStream(null, MediaType.Audio, mainSource, null, null);

        // Setup video window
        var videoWindow = (IVideoWindow)filterGraph;
        videoWindow.put_Owner(videoWindowHandle);
        videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);

        // Run
        var mediaControl = (IMediaControl)filterGraph;
        mediaControl.Run();

        Marshal.ReleaseComObject(captureGraph);
    }
}
```

---

## Troubleshooting

### Issue: Effect Not Visible

**Solution**: Ensure effect is enabled and parameters are set on the VideoEffectSimple struct:

```
var eff = new VideoEffectSimple
{
    Type = (int)VideoEffectType.Darkness,
    Enabled = true,
    AmountI = 75
};
effects.add_effect(eff);
```

### Issue: Chroma Key Not Working Well

**Solution**: Adjust contrast thresholds:

```
// For difficult green screens:
chromaKey.put_contrast(30, 70);  // Tighter range
// For well-lit green screens:
chromaKey.put_contrast(50, 110);  // Wider range
```

### Issue: Video Mixer Inputs Not Showing

**Solution**: Verify input parameters and Z-order:

```
// Ensure inputs are on-screen via VFPIPVideoInputParam struct
mixer.SetInputParam(0, new VFPIPVideoInputParam { X = 0, Y = 0, Width = 640, Height = 480 });
// Set Z-order per-pin
mixer.SetInputOrder(0, 0);  // Input 0 at layer 0
mixer.SetInputOrder(1, 1);  // Input 1 at layer 1
```

---

## See Also

### Documentation

- [Effects Reference](../effects-reference/) - Complete effects list
- [Video Mixer Interface](../interfaces/video-mixer/) - Full API reference
- [Chroma Key Interface](../interfaces/chroma-key/) - Complete interface docs

### External Resources

- [DirectShow Filter Graph](https://learn.microsoft.com/en-us/windows/win32/directshow/building-the-filter-graph)

---END OF PAGE---


## Real-Time Video Processing Filters for DirectShow Apps
**URL:** https://www.visioforge.com/help/docs/directshow/proc-filters/
**Description:** Add 35+ real-time video effects, multi-source video mixer (2-16 inputs), chroma key, deinterlacing, and noise reduction to Windows apps. VisioForge COM filters.
**Tags:** DirectShow, C++, Windows

# DirectShow Processing Filters for Media Applications

## Introduction to DirectShow Processing Filters

The DirectShow Processing Filters Pack delivers a powerful collection of specialized filters built for sophisticated audio and video manipulation in Windows applications. These filters enable developers to implement professional-grade media processing capabilities without developing complex algorithms from scratch.

Designed for developers seeking to enhance their applications with advanced media functionality, this toolkit offers a streamlined approach to implementing robust audio-visual features with minimal code overhead.

---

## Installation

Before using the code samples and integrating the filters into your application, you must first install the DirectShow Processing Filters Pack from the [product page](https://www.visioforge.com/processing-filters-pack).

**Installation Steps**:

1. Download the Processing Filters Pack installer from the product page
2. Run the installer with administrative privileges
3. The installer will register all processing filters
4. Sample applications and source code will be available in the installation directory

**Note**: All filters must be properly registered on the system before they can be used in your applications. The installer handles this automatically.

---

## Key Capabilities and Benefits

### Video Processing Capabilities

#### Advanced Visual Effects

- **Dynamic Effects Processing**: Apply real-time effects to video streams including blur, sharpen, sepia, grayscale, and numerous artistic filters
- **Custom Effect Chaining**: Combine multiple effects sequentially for complex visual transformations
- **Adjustable Parameters**: Fine-tune effect intensity and characteristics for precise control

#### Professional Video Mixing

- **Multi-Source Blending**: Seamlessly combine multiple video streams into a unified output
- **Transition Effects**: Implement smooth transitions between video sources
- **Picture-in-Picture**: Create overlay configurations with customizable positioning and scaling

#### Image and Text Overlay System

- **Dynamic Text Rendering**: Overlay customizable text with font control and animation
- **Image Integration**: Add logos, watermarks, and informational graphics to video content
- **Alpha Channel Support**: Maintain transparency information for professional compositing

#### High-Quality Resize Functionality

- **Multiple Algorithms**: Choose from nearest neighbor, bilinear, bicubic, and Lanczos scaling
- **Aspect Ratio Control**: Maintain or adjust aspect ratios as needed
- **Resolution Optimization**: Scale content for specific output requirements while preserving quality

#### Video Manipulation Tools

- **Rotation and Cropping**: Adjust video orientation and framing with precise control
- **Deinterlacing Options**: Multiple modes available for converting interlaced content
- **Noise Reduction**: Advanced algorithms for improving video clarity and quality

### Audio Processing Capabilities

#### Audio Enhancement Suite

- **Effect Processing**: Apply various audio effects for sound enhancement and creative manipulation
- **Channel Management**: Control stereo imaging and multi-channel configurations

#### Advanced Audio Controls

- **Volume Optimization**: Precise volume adjustment with normalization options
- **Balance Adjustment**: Fine-tune left/right channel balance for optimal sound distribution
- **Pitch Modification**: Alter pitch while maintaining or changing tempo
- **Delay Implementation**: Add customizable delay effects with feedback control

#### Professional Sound Effects

- **Echo Generation**: Create spatial echo effects with adjustable parameters
- **Equalizer System**: Multi-band equalization for frequency adjustment
- **Chorus Effects**: Add richness and depth to audio streams
- **Flanger Processing**: Create sweeping, psychedelic audio effects

## System Requirements

### Compatible Operating Systems

- Windows 11, 10, 8.1, 8, and 7 (both 32-bit and 64-bit versions)

### Development Environment Support

- **Microsoft Visual Studio**: Versions 2022, 2019, 2017, 2015, 2013, 2012, and 2010
- **Embarcadero Tools**: Compatible with Delphi and C++ Builder
- **Additional Environments**: Works with any development platform supporting DirectShow filters

### Technical Prerequisites

- DirectX 9 or later installation
- Minimum 4GB RAM (8GB+ recommended for high-resolution processing)
- Multi-core processor recommended for optimal performance

## Additional Resources

- [Complete Product Information](https://www.visioforge.com/processing-filters-pack)
- [API Documentation](https://api.visioforge.org/proc_filters/api/index.html)
- [Licensing Information](../../eula/)

## Version History and Updates

### Version 15.1 Enhancements

- Integration with .Net SDKs 15.1 architecture
- Significant improvements to audio and video mixing engines
- Enhanced multithreading support for better performance on multi-core systems
- Expanded video effects library with new processing options
- Resolution of audio click artifacts in mixer component
- Optimized support for ultra-high-definition 4K and 8K content processing

### Version 15.0 Improvements

- Full alignment with .Net SDKs 15.0 framework
- Optimized high-resolution processing for brightness, contrast, saturation, and hue filters

### Version 14.0 Updates

- Complete compatibility with .Net SDKs 14.0
- Performance optimization for video resize operations
- Enhanced bicubic video resize algorithm for superior quality

### Version 12.0 Refinements

- Integration with .Net SDKs 12.0 infrastructure
- Redesigned audio mixer with improved performance
- Fixed stability issues when using crop or resize with incorrect parameters

### Version 11.0 Features

- Updated to match .Net SDKs 11.0 specifications
- Improved audio tempo and pitch manipulation algorithms
- Optimized video balance performance for smoother processing

### Version 10.0 Developments

- Alignment with .Net SDKs 10.0 architecture
- Completely revamped Video Mixer component

### Version 9.0 Advancements

- Integration with .Net SDKs 9.2 framework
- Enhanced video effects library
- Specific optimizations for 4K content processing

### Version 8.5 Initial Release

- First public release, featuring filters from .Net SDKs 8.5
- Introduction of Lanczos support in video resize filter for superior quality scaling

---END OF PAGE---


## Chroma Key DirectShow Filter - IVFChromaKey Interface
**URL:** https://www.visioforge.com/help/docs/directshow/proc-filters/interfaces/chroma-key/
**Description:** IVFChromaKey interface for green screen and blue screen compositing with tolerance control and background replacement in DirectShow.
**Tags:** DirectShow, C++, Windows, Effects, Mixing, C#
**API:** IVFChromaKey, CVFChromaColor, IBaseFilter, IVFVideoMixer, IVFEffectsPro

# IVFChromaKey Interface Reference

## Overview

The `IVFChromaKey` interface provides professional chroma key (green screen/blue screen) compositing capabilities for DirectShow applications. This interface enables real-time background replacement by making specific colors transparent, allowing subjects filmed in front of colored backdrops to be composited over different backgrounds.

Chroma keying is essential for virtual production, weather forecasting, video effects, and any scenario where background replacement is needed.

## Interface Definition

- **Interface Name**: `IVFChromaKey`
- **GUID**: `{AF6E8208-30E3-44f0-AAFE-787A6250BAB3}`
- **Inherits From**: `IUnknown`
- **Header File**: `vf_eff_intf.h` (C++), `IVFChromaKey.cs` (.NET)

## Capabilities

- **Color Keys**: Green, blue, red, or custom RGB colors
- **Contrast Adjustment**: Separate low/high contrast thresholds
- **Background Replacement**: Static image or video background
- **Real-Time Processing**: Hardware-accelerated when available
- **Edge Quality**: Adjustable tolerance for smooth edges

---

## Methods Reference

### Contrast Threshold Configuration

#### chroma\_put\_contrast

Sets the contrast threshold range for chroma keying. **Syntax (C++)**:

```
HRESULT chroma_put_contrast(int low, int high);
```

**Syntax (C#)**:

```
[PreserveSig]
int chroma_put_contrast(int low, int high);
```

**Parameters**: - `low`: Low contrast threshold (0-255) - Lower values = remove more similar colors - Higher values = stricter color matching - `high`: High contrast threshold (0-255) - Defines the upper bound for color matching - Creates a range of acceptable key colors **Returns**: `S_OK` (0) on success. **Usage Notes**: - These values define the color similarity range for keying - The range between `low` and `high` creates a gradient for edge smoothing - Typical ranges: - Tight keying: low=10, high=30 - Standard keying: low=30, high=70 - Loose keying: low=50, high=120 - Adjust based on lighting conditions and backdrop quality **How It Works**:

```
Pixels with chroma distance < low    → Fully transparent
Pixels with chroma distance > high   → Fully opaque
Pixels between low and high          → Partially transparent (gradient)
```

**Example (C++)**:

```
IVFChromaKey* pChroma = nullptr;
pFilter->QueryInterface(IID_IVFChromaKey, (void**)&pChroma);
// Standard green screen configuration
pChroma->chroma_put_contrast(40, 80);
pChroma->Release();
```

**Example (C#)**:

```
var chroma = filter as IVFChromaKey;
if (chroma != null)
{
    // Tight keying for clean green screen
    chroma.chroma_put_contrast(20, 50);
}
```

---

### Color Selection

#### chroma\_put\_color

Sets the chroma key color to be made transparent.

**Syntax (C++)**:

```
HRESULT chroma_put_color(int color);
```

**Syntax (C#)**:

```
[PreserveSig]
int chroma_put_color(int color);
```

**Parameters**: - `color`: Chroma key color value

**Color Values** (CVFChromaColor enumeration):

| Value | Color | RGB Equivalent | Use Case |
| --- | --- | --- | --- |
| `0` (Chroma\_Green) | Green | 0x00FF00 | Standard chroma key (most common) |
| `1` (Chroma\_Blue) | Blue | 0x0000FF | Alternative to green |
| `2` (Chroma\_Red) | Red | 0xFF0000 | Special cases |
| Custom RGB | Any color | 0xRRGGBB | Specific color matching |

**Returns**: `S_OK` (0) on success.

**Usage Notes**: - Green is standard for chroma keying (human skin has least green) - Blue used when green objects are in scene - Can use custom RGB value for specific color matching - Color should be uniform across backdrop for best results

**Example (C++)**:

```
// Use green chroma key
pChroma->chroma_put_color(Chroma_Green);

// Use blue chroma key
pChroma->chroma_put_color(Chroma_Blue);

// Use custom color (e.g., magenta)
pChroma->chroma_put_color(0xFF00FF);
```

**Example (C#)**:

```
// Standard green screen
chroma.chroma_put_color((int)CVFChromaColor.Chroma_Green);

// Blue screen
chroma.chroma_put_color((int)CVFChromaColor.Chroma_Blue);

// Custom yellow-green
chroma.chroma_put_color(0x88FF00);
```

---

### Background Image

#### chroma\_put\_image

Sets a replacement background image for transparent areas. **Syntax (C++)**:

```
HRESULT chroma_put_image(BSTR filename);
```

**Syntax (C#)**:

```
[PreserveSig]
int chroma_put_image([MarshalAs(UnmanagedType.BStr)] string filename);
```

**Parameters**: - `filename`: Path to background image file (BMP, PNG, JPG, etc.) **Returns**: `S_OK` (0) on success. **Usage Notes**: - Image is stretched to fill entire frame - Use NULL or empty string to use video background instead - Static image is more efficient than video background - Image is loaded once and cached - Supported formats: BMP, PNG, JPEG, GIF, TIFF **Example (C++)**:

```
// Set office background image
pChroma->chroma_put_image(L"C:\\Backgrounds\\office.jpg");
// Remove background image (use video input instead)
pChroma->chroma_put_image(NULL);
```

**Example (C#)**:

```
// Virtual studio background
chroma.chroma_put_image(@"C:\Backgrounds\studio.png");
// Remove static background
chroma.chroma_put_image(null);
```

---

## Complete Configuration Examples

### Example 1: Basic Green Screen Setup (C++)

```
#include "vf_eff_intf.h"

HRESULT ConfigureBasicGreenScreen(IBaseFilter* pChromaFilter)
{
    HRESULT hr;
    IVFChromaKey* pChroma = nullptr;

    hr = pChromaFilter->QueryInterface(IID_IVFChromaKey, (void**)&pChroma);
    if (FAILED(hr))
        return hr;

    // Set green as key color
    pChroma->chroma_put_color(Chroma_Green);

    // Standard contrast thresholds
    pChroma->chroma_put_contrast(40, 80);

    // Set background image
    pChroma->chroma_put_image(L"C:\\Backgrounds\\office_background.jpg");

    pChroma->Release();
    return S_OK;
}
```

### Example 2: Weather Forecast Studio (C#)

```
using System;
using VisioForge.DirectShowAPI;

public class WeatherStudioSetup
{
    public void ConfigureWeatherChromaKey(IBaseFilter chromaFilter)
    {
        var chroma = chromaFilter as IVFChromaKey;
        if (chroma == null)
            throw new NotSupportedException("IVFChromaKey not available");

        // Blue screen for weather maps
        chroma.chroma_put_color((int)CVFChromaColor.Chroma_Blue);

        // Tighter thresholds for clean keying
        chroma.chroma_put_contrast(25, 60);

        // Weather map background
        chroma.chroma_put_image(@"C:\Weather\maps\current_radar.png");
    }

    public void UpdateWeatherMap(IVFChromaKey chroma, string mapPath)
    {
        // Dynamically update background during broadcast
        chroma.chroma_put_image(mapPath);
    }
}
```

### Example 3: Virtual Production with Custom Color (C++)

```
HRESULT ConfigureVirtualProduction(IVFChromaKey* pChroma)
{
    // Use specific green matching your physical backdrop
    // Measure actual color with color picker
    COLORREF customGreen = RGB(60, 220, 40);  // Specific green shade

    pChroma->chroma_put_color(customGreen);

    // Professional-grade thresholds
    // Lower values for clean, well-lit green screen
    pChroma->chroma_put_contrast(15, 45);

    // Use pre-rendered virtual environment
    pChroma->chroma_put_image(L"D:\\VirtualSets\\studio_environment.png");

    return S_OK;
}
```

### Example 4: Adaptive Chroma Key Settings (C#)

```
public class AdaptiveChromaKey
{
    private IVFChromaKey _chroma;

    public void SetupForLightingConditions(string condition)
    {
        switch (condition.ToLower())
        {
            case "perfect":
                // Clean, evenly lit green screen
                _chroma.chroma_put_color((int)CVFChromaColor.Chroma_Green);
                _chroma.chroma_put_contrast(15, 40);
                break;

            case "good":
                // Standard lighting
                _chroma.chroma_put_color((int)CVFChromaColor.Chroma_Green);
                _chroma.chroma_put_contrast(30, 70);
                break;

            case "challenging":
                // Uneven lighting or wrinkled backdrop
                _chroma.chroma_put_color((int)CVFChromaColor.Chroma_Green);
                _chroma.chroma_put_contrast(50, 110);
                break;

            case "outdoor":
                // Natural light, harder to control
                _chroma.chroma_put_color((int)CVFChromaColor.Chroma_Blue);
                _chroma.chroma_put_contrast(60, 130);
                break;
        }
    }

    public void TestThresholds()
    {
        // Start with tight keying
        for (int low = 10; low <= 60; low += 10)
        {
            int high = low + 40;
            _chroma.chroma_put_contrast(low, high);

            // User reviews result and selects best setting
            Console.WriteLine($"Testing: Low={low}, High={high}");
            System.Threading.Thread.Sleep(2000);
        }
    }
}
```

---

## Chroma Keying Best Practices

### Lighting Setup

1. **Even Illumination**
2. Use multiple light sources
3. Avoid hotspots and shadows on backdrop
4. Maintain consistent color across entire screen
5. **Subject Separation**
6. Position subject 6-10 feet from backdrop
7. Prevents green spill on subject
8. Allows independent lighting control
9. **Backdrop Quality**
10. Use proper chroma key fabric or paint
11. Keep backdrop wrinkle-free
12. Maintain consistent color saturation

### Configuration Strategy

1. **Start Conservative**

   ```
   // Begin with tight thresholds
   pChroma->chroma_put_contrast(20, 50);
   // Gradually increase if needed
   pChroma->chroma_put_contrast(30, 70);
   ```
2. **Test Different Lighting**
3. Adjust thresholds for your specific setup
4. Save presets for different conditions
5. Document working values
6. **Color Selection**
7. Green: Standard choice (least in skin tones)
8. Blue: When green objects in scene
9. Custom: Match actual backdrop color for best results

### Quality Optimization

1. **Camera Settings**
2. Disable auto white balance
3. Manual focus
4. Reduce sharpening (prevents edge artifacts)
5. **Threshold Tuning**
6. Low value: Controls transparency threshold
7. High value: Controls edge softness
8. Wider range = softer edges
9. **Edge Quality**

   ```
   Tight range (low=20, high=40):
   - Sharp edges
   - May show green fringe
   - Best for clean backdrops
   Wide range (low=30, high=90):
   - Softer edges
   - Better color bleeding tolerance
   - More forgiving of imperfect lighting
   ```

---

## Common Chroma Key Scenarios

### Scenario 1: Corporate Video Production

```
// Clean studio environment
pChroma->chroma_put_color(Chroma_Green);
pChroma->chroma_put_contrast(25, 55);
pChroma->chroma_put_image(L"corporate_office.jpg");
```

**Characteristics**: - Controlled lighting - Professional green screen - Static office background - High quality requirements

### Scenario 2: Gaming Streamer

```
// Home studio setup
pChroma->chroma_put_color(Chroma_Green);
pChroma->chroma_put_contrast(35, 75);
pChroma->chroma_put_image(NULL);  // Use game video as background
```

**Characteristics**: - Consumer green screen - Variable lighting - Dynamic video background - Real-time performance critical

### Scenario 3: Weather Broadcasting

```
// Blue screen with weather maps
pChroma->chroma_put_color(Chroma_Blue);
pChroma->chroma_put_contrast(30, 65);
pChroma->chroma_put_image(L"weather_map_current.png");
```

**Characteristics**: - Blue screen (green used in weather maps) - Dynamically changing backgrounds - Professional lighting - Presenter clothing considerations

### Scenario 4: Virtual Event Hosting

```
// Virtual conference background
pChroma->chroma_put_color(Chroma_Green);
pChroma->chroma_put_contrast(40, 85);
pChroma->chroma_put_image(L"conference_hall.jpg");
```

**Characteristics**: - Home/office setup - Variable quality backdrops - Forgiving settings needed - Professional appearance desired

---

## Troubleshooting

### Issue: Green Spill on Subject

**Symptoms**: Green halo or tint on subject edges **Solutions**: 1. Increase subject distance from backdrop 2. Adjust lighting to reduce reflection 3. Use tighter contrast range:

```
pChroma->chroma_put_contrast(15, 35);
```

4. Consider color correction in post

### Issue: Uneven Keying

**Symptoms**: Parts of backdrop not transparent **Solutions**: 1. Check backdrop lighting uniformity 2. Increase high threshold:

```
pChroma->chroma_put_contrast(30, 100);
```

3. Verify backdrop color consistency 4. Consider using custom color matching:

```
// Sample actual backdrop color and use it
pChroma->chroma_put_color(0x40DC28);  // Measured color
```

### Issue: Subject Parts Disappearing

**Symptoms**: Subject clothing or features becoming transparent **Solutions**: 1. Avoid green/blue clothing 2. Reduce contrast range:

```
pChroma->chroma_put_contrast(50, 90);
```

3. Switch key color if needed:

```
pChroma->chroma_put_color(Chroma_Blue);  // If wearing green
```

### Issue: Rough, Jagged Edges

**Symptoms**: Poor edge quality, visible pixelation **Solutions**: 1. Widen contrast range for smoother gradient:

```
pChroma->chroma_put_contrast(25, 85);
```

2. Improve lighting quality 3. Use higher quality video source 4. Ensure subject is well-separated from backdrop

### Issue: Performance Problems

**Symptoms**: Dropped frames, stuttering **Solutions**: 1. Use static image background instead of video 2. Reduce output resolution 3. Optimize threshold values (don't make too wide) 4. Consider hardware-accelerated alternatives

---

## Parameter Reference Table

### Contrast Threshold Guidelines

| Lighting Quality | Backdrop | Low | High | Edge Quality | Performance |
| --- | --- | --- | --- | --- | --- |
| **Excellent** | Clean, even | 15-25 | 35-50 | Sharp | Best |
| **Good** | Minor variations | 25-35 | 50-75 | Good | Good |
| **Fair** | Some unevenness | 35-50 | 75-100 | Soft | Moderate |
| **Poor** | Uneven/wrinkled | 50-70 | 100-140 | Very soft | Lower |

### Color Selection Guide

| Color | RGB | Pros | Cons | Best For |
| --- | --- | --- | --- | --- |
| **Green** | 0x00FF00 | Least in skin, bright | Not for green objects | General use |
| **Blue** | 0x0000FF | Alternative to green | Denim/blue clothing | Special cases |
| **Custom** | Varies | Exact match to backdrop | Requires calibration | Professional |

---

## Integration with Video Mixer

Chroma key filter is often used with Video Mixer for advanced compositing:

```
// Chroma key filter removes green
IVFChromaKey* pChroma = /* ... */;
pChroma->chroma_put_color(Chroma_Green);
pChroma->chroma_put_contrast(30, 70);
// Video mixer combines subject with background
IVFVideoMixer* pMixer = /* ... */;
// Input 0: Background video
// Input 1: Chroma-keyed subject (transparent background)
```

See [Video Mixer Interface](../video-mixer/) for details.

---

## Related Interfaces

- **IVFVideoMixer** - Combine chroma-keyed video with backgrounds
- **IVFEffects45** - Additional video effects
- **IVFEffectsPro** - Advanced effect processing

## See Also

- [Processing Filters Pack Overview](../../)
- [Video Mixer Interface](../video-mixer/)
- [Effects Reference](../../effects-reference/)
- [Code Examples](../../examples/)

---END OF PAGE---


## DirectShow Video Effects and Processing Filter API Reference
**URL:** https://www.visioforge.com/help/docs/directshow/proc-filters/interfaces/effects-interface/
**Description:** DirectShow Processing Filters API reference for video effects, audio enhancement, resize, chroma key, and video mixing interfaces.
**Tags:** DirectShow, C++, Windows, Effects, Mixing, Screen Capture, C#
**API:** VideoEffectType, IVFEffectsPro, IVFResize, IBaseFilter, IVFAudioEnhancer

# Processing Filters - Effects Interfaces Reference

## Overview

This document provides comprehensive API reference for all interfaces in the DirectShow Processing Filters Pack. These interfaces enable video effects, audio enhancement, chroma keying, video mixing, screen capture, and advanced processing capabilities.

---

## Interface Quick Reference

| Interface | GUID | Purpose |
| --- | --- | --- |
| **IVFEffects45** | {5E767DA8-97AF-4607-B95F-8CC6010B84CA} | Simple video effects |
| **IVFEffectsPro** | {9A794ABE-98AD-45AF-BBB0-042172C74C79} | Advanced effects with sample grabber |
| **IVFResize** | {12BC6F20-2812-4660-8684-10F3FD3B4487} | Video resize and crop |
| **IVFVideoMixer** | {3318300E-F6F1-4d81-8BC3-9DB06B09F77A} | Multi-source video mixing |
| **IVFChromaKey** | {AF6E8208-30E3-44f0-AAFE-787A6250BAB3} | Chroma keying (green screen) |
| **IVFAudioEnhancer** | {C2C0512A-AE91-4B4D-B4E0-913A0227DCD7} | Audio channel gains |
| **IVFAudioEnhancer3** | {915E95CE-70F6-4FA5-B608-9B0BCDBE06B3} | IEEE float audio output |
| **IVFAudioChannelMapper** | {EDB8F865-0A81-4E98-866F-B6F5F17C8FC2} | Audio channel mapping |
| **IVFScreenCapture3** | {259E0009-9963-4a71-91AE-34B96D754899} | Screen capture configuration |
| **IVFMotDetConfig** | {B10E9A0C-3D99-46D4-A397-6E0BC5BC3D76} | Motion detection |
| **IVFPushConfig** | {F1876E64-C7AC-4B5B-8F64-67B5BB8CEAE4} | Push source configuration |
| --- |  |  |

## Video Effects Interfaces

### IVFEffects45

Simple interface for adding and managing video effects.

**GUID**: `{5E767DA8-97AF-4607-B95F-8CC6010B84CA}`

**C# Definition**:

```
[ComImport]
[Guid("5E767DA8-97AF-4607-B95F-8CC6010B84CA")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IVFEffects45
{
    /// <summary>
    /// Adds video effect.
    /// </summary>
    [PreserveSig]
    void add_effect([In] VFVideoEffectSimple effect);

    /// <summary>
    /// Sets video effects settings.
    /// </summary>
    [PreserveSig]
    void set_effect_settings([In] VFVideoEffectSimple effect);

    /// <summary>
    /// Removes effect.
    /// </summary>
    [PreserveSig]
    void remove_effect([In] int id);

    /// <summary>
    /// Clears effects.
    /// </summary>
    [PreserveSig]
    void clear_effects();
}
```

**Methods**:

| Method | Description |
| --- | --- |
| `add_effect` | Adds a new video effect to the processing chain |
| `set_effect_settings` | Updates parameters of an existing effect |
| `remove_effect` | Removes effect by its ID |
| `clear_effects` | Removes all effects |

**Example (C#)**:

```
var effects = filter as IVFEffects45;
if (effects != null)
{
    // Add blur effect
    var blur = new VFVideoEffectSimple
    {
        EffectType = VideoEffectType.Blur,
        Enabled = true,
        Id = 1
    };
    effects.add_effect(blur);

    // Add grayscale effect
    var gray = new VFVideoEffectSimple
    {
        EffectType = VideoEffectType.Greyscale,
        Enabled = true,
        Id = 2
    };
    effects.add_effect(gray);
}
```

**VFVideoEffectSimple Structure**:

```
public struct VFVideoEffectSimple
{
    public VideoEffectType EffectType;      // Effect type
    public bool Enabled;                     // Enable/disable
    public int Id;                           // Unique identifier
    public VFTextLogo TextLogo;             // Text logo parameters
    public VFGraphicalLogo GraphicalLogo;   // Image logo parameters (also called ImageLogo)
}
```

---

### IVFEffectsPro

Advanced effects interface with sample grabber callback support. **GUID**: `{9A794ABE-98AD-45AF-BBB0-042172C74C79}` **C# Definition**:

```
[ComImport]
[Guid("9A794ABE-98AD-45AF-BBB0-042172C74C79")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IVFEffectsPro
{
    /// <summary>
    /// Sets filter parts state.
    /// </summary>
    [PreserveSig]
    void set_enabled(
        [In, MarshalAs(UnmanagedType.Bool)] bool effects,
        [In, MarshalAs(UnmanagedType.Bool)] bool motdet,
        [In, MarshalAs(UnmanagedType.Bool)] bool chroma,
        [In, MarshalAs(UnmanagedType.Bool)] bool sg);
    /// <summary>
    /// Sets callback for RGB24 buffer.
    /// </summary>
    [PreserveSig]
    int set_sg_callback_24([MarshalAs(UnmanagedType.FunctionPtr)] BufferCBProc callback);
    /// <summary>
    /// Sets callback for RGB32 buffer.
    /// </summary>
    [PreserveSig]
    int set_sg_callback_32([MarshalAs(UnmanagedType.FunctionPtr)] BufferCBProc callback);
    /// <summary>
    /// Sets sample grabber handle.
    /// </summary>
    [PreserveSig]
    int put_sg_app_handle(object handle);
    /// <summary>
    /// Sets sample grabber unique handle id.
    /// </summary>
    [PreserveSig]
    int put_sg_app_handle_id([MarshalAs(UnmanagedType.U4)] uint handle_id);
}
```

**Buffer Callback Delegate**:

```
public delegate int BufferCBProc(
    [In] IntPtr handle,
    [In] uint handle_id,
    [In] IntPtr pBuffer,
    int bufferLen,
    int width,
    int height,
    long startTime,
    long stopTime,
    [MarshalAs(UnmanagedType.Bool)] ref bool updateFrame);
```

**Methods**: | Method | Description | |--------|-------------| | `set_enabled` | Enable/disable filter components (effects, motion detection, chroma key, sample grabber) | | `set_sg_callback_24` | Set callback for RGB24 format frames | | `set_sg_callback_32` | Set callback for RGB32 format frames | | `put_sg_app_handle` | Set application handle for callbacks | | `put_sg_app_handle_id` | Set unique identifier for callbacks | **Example (C#)**:

```
var effectsPro = filter as IVFEffectsPro;
if (effectsPro != null)
{
    // Enable effects and sample grabber
    effectsPro.set_enabled(
        effects: true,
        motdet: false,
        chroma: false,
        sg: true);
    // Set up frame callback
    effectsPro.put_sg_app_handle(this.Handle);
    effectsPro.put_sg_app_handle_id(12345);
    effectsPro.set_sg_callback_32(OnFrameCallback);
}
private int OnFrameCallback(
    IntPtr handle,
    uint handle_id,
    IntPtr pBuffer,
    int bufferLen,
    int width,
    int height,
    long startTime,
    long stopTime,
    ref bool updateFrame)
{
    // Process frame data
    // pBuffer points to RGB32 data
    return 0;
}
```

---

## Video Resize Interface

### IVFResize

Controls video resizing, cropping, rotation, and resize quality.

**GUID**: `{12BC6F20-2812-4660-8684-10F3FD3B4487}`

**C# Definition**:

```
[ComImport]
[Guid("12BC6F20-2812-4660-8684-10F3FD3B4487")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IVFResize
{
    /// <summary>
    /// Sets resolution.
    /// </summary>
    [PreserveSig]
    int put_Resolution([In] uint x, [In] uint y);

    /// <summary>
    /// Sets resize mode.
    /// </summary>
    [PreserveSig]
    int put_ResizeMode([In] VFResizeMode mode, [In] bool letterbox);

    /// <summary>
    /// Sets crop coordinates.
    /// </summary>
    [PreserveSig]
    int put_Crop([In] uint left, [In] uint top, [In] uint right, [In] uint bottom);

    /// <summary>
    /// Sets filter mode.
    /// </summary>
    [PreserveSig]
    int put_FilterMode([In] VFResizeFilterMode mode);

    /// <summary>
    /// Sets rotate mode.
    /// </summary>
    [PreserveSig]
    int put_RotateMode([In] VFRotateMode mode);
}
```

**VFResizeMode Enumeration**:

```
public enum VFResizeMode
{
    rmStretch = 0,      // Stretch to fit (may distort)
    rmLetterbox = 1,    // Maintain aspect ratio with letterbox
    rmCrop = 2          // Crop to fit
}
```

**VFResizeFilterMode Enumeration**:

```
public enum VFResizeFilterMode
{
    NearestNeighbor = 0,    // Fastest, lowest quality
    Bilinear = 1,           // Good quality, fast
    Bicubic = 2,            // High quality (default)
    Lanczos = 3             // Highest quality, slower
}
```

**VFRotateMode Enumeration**:

```
public enum VFRotateMode
{
    RM_0 = 0,       // No rotation
    RM_90 = 1,      // 90 degrees clockwise
    RM_180 = 2,     // 180 degrees
    RM_270 = 3      // 270 degrees clockwise (90 CCW)
}
```

**Example (C#)**:

```
var resize = filter as IVFResize;
if (resize != null)
{
    // Resize to 1280x720 with letterbox
    resize.put_Resolution(1280, 720);
    resize.put_ResizeMode(VFResizeMode.rmLetterbox, true);

    // Use high quality bicubic resize
    resize.put_FilterMode(VFResizeFilterMode.Bicubic);

    // Rotate 90 degrees
    resize.put_RotateMode(VFRotateMode.RM_90);

    // Crop 10 pixels from each side
    resize.put_Crop(10, 10, 10, 10);
}
```

---

## Audio Enhancement Interfaces

### IVFAudioEnhancer

Controls audio channel gains, auto gain, and normalization. **GUID**: `{C2C0512A-AE91-4B4D-B4E0-913A0227DCD7}` **C# Definition**:

```
[ComImport]
[Guid("C2C0512A-AE91-4B4D-B4E0-913A0227DCD7")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IVFAudioEnhancer
{
    [PreserveSig]
    int get_auto_gain([Out, MarshalAs(UnmanagedType.Bool)] out bool auto_gain);
    [PreserveSig]
    int set_auto_gain([MarshalAs(UnmanagedType.Bool)] bool auto_gain);
    [PreserveSig]
    int get_normalize([Out, MarshalAs(UnmanagedType.Bool)] out bool normalize);
    [PreserveSig]
    int set_normalize([MarshalAs(UnmanagedType.Bool)] bool normalize);
    [PreserveSig]
    int get_input_gains(out float l, out float c, out float r,
                        out float sl, out float sr, out float lfe);
    [PreserveSig]
    int set_input_gains(float l, float c, float r,
                       float sl, float sr, float lfe);
    [PreserveSig]
    int get_output_gains(out float l, out float c, out float r,
                         out float sl, out float sr, out float lfe);
    [PreserveSig]
    int set_output_gains(float l, float c, float r,
                        float sl, float sr, float lfe);
    [PreserveSig]
    int get_time_shift(out int time_shift);
    [PreserveSig]
    int set_time_shift(int time_shift);
}
```

**Channel Parameters**: - `l` - Left channel - `c` - Center channel - `r` - Right channel - `sl` - Surround left - `sr` - Surround right - `lfe` - Low frequency effects (subwoofer) **Example (C#)**:

```
var audio = filter as IVFAudioEnhancer;
if (audio != null)
{
    // Enable auto gain and normalization
    audio.set_auto_gain(true);
    audio.set_normalize(true);
    // Boost left and right channels by 20%
    audio.set_output_gains(
        l: 1.2f,
        c: 1.0f,
        r: 1.2f,
        sl: 1.0f,
        sr: 1.0f,
        lfe: 1.0f);
}
```

---

### IVFAudioEnhancer3

Enables IEEE floating-point audio output format.

**GUID**: `{915E95CE-70F6-4FA5-B608-9B0BCDBE06B3}`

**C# Definition**:

```
[ComImport]
[Guid("915E95CE-70F6-4FA5-B608-9B0BCDBE06B3")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IVFAudioEnhancer3
{
    [PreserveSig]
    int get_ieee_output_enabled([Out, MarshalAs(UnmanagedType.Bool)] out bool enabled);

    [PreserveSig]
    int set_ieee_output_enabled([MarshalAs(UnmanagedType.Bool)] bool enabled);
}
```

**Example (C#)**:

```
var audio3 = filter as IVFAudioEnhancer3;
if (audio3 != null)
{
    // Enable IEEE float output for professional audio processing
    audio3.set_ieee_output_enabled(true);
}
```

---

## Screen Capture Interface

### IVFScreenCapture3

Controls screen capture mode, region, frame rate, and mouse cursor visibility. **GUID**: `{259E0009-9963-4a71-91AE-34B96D754899}` **C# Definition**:

```
[ComImport]
[Guid("259E0009-9963-4a71-91AE-34B96D754899")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IVFScreenCapture3
{
    [PreserveSig]
    int init();
    [PreserveSig]
    int set_fps([In] double fps);
    [PreserveSig]
    int set_rect([In] VFRect rect);
    [PreserveSig]
    int set_mouse([In] bool draw);
    [PreserveSig]
    int set_display_index([In] int index);
    [PreserveSig]
    int set_mode([In] VFScreenCaptureMode mode);
    [PreserveSig]
    int refresh_pic();
    [PreserveSig]
    int set_stream([In] IStream stream, [In] long length);
    [PreserveSig]
    int set_window_handle([In] IntPtr handle);
    [PreserveSig]
    int get_window_size([In] IntPtr handle, [Out] out int width, [Out] out int height);
}
```

**VFScreenCaptureMode Enumeration**:

```
public enum VFScreenCaptureMode
{
    scmScreen = 0,          // Capture entire screen or region
    scmWindow = 1,          // Capture specific window
    scmMemory = 2           // Use memory stream as source
}
```

**VFRect Structure**:

```
public struct VFRect
{
    public int Left;
    public int Top;
    public int Right;
    public int Bottom;
}
```

**Example (C#)**:

```
var capture = filter as IVFScreenCapture3;
if (capture != null)
{
    // Initialize capture
    capture.init();
    // Capture at 30 FPS
    capture.set_fps(30.0);
    // Capture specific region
    var rect = new VFRect
    {
        Left = 100,
        Top = 100,
        Right = 1920,
        Bottom = 1080
    };
    capture.set_rect(rect);
    // Show mouse cursor
    capture.set_mouse(true);
    // Capture primary display
    capture.set_display_index(0);
    // Set screen capture mode
    capture.set_mode(VFScreenCaptureMode.scmScreen);
}
```

**Example: Window Capture**:

```
// Capture specific window
IntPtr windowHandle = FindWindow(null, "Calculator");
if (windowHandle != IntPtr.Zero)
{
    capture.set_mode(VFScreenCaptureMode.scmWindow);
    capture.set_window_handle(windowHandle);
    // Get window size
    capture.get_window_size(windowHandle, out int width, out int height);
    Console.WriteLine($"Window size: {width}x{height}");
}
```

---

## Common Structures and Enumerations

### VFVideoEffectType

Complete enumeration of all available video effects.

```
public enum VideoEffectType
{
    Undefined = -1,             // Undefined effect

    // Text and Graphics
    TextLogo = 0,               // Text overlay
    ImageLogo = 1,              // Image/logo overlay

    // Color Filters
    Blue,                       // Blue color filter
    FilterBlue,                 // Blue channel filter
    FilterGreen,                // Green channel filter
    FilterRed,                  // Red channel filter
    Green,                      // Green color filter
    Red,                        // Red color filter
    Greyscale,                  // Convert to grayscale

    // Image Adjustments
    Blur,                       // Blur effect
    Contrast,                   // Contrast adjustment
    Darkness,                   // Darken effect
    Lightness,                  // Brighten effect
    Saturation,                 // Saturation adjustment
    Sharpen,                    // Sharpen effect
    Smooth,                     // Smooth/soften effect

    // Spatial Transformations
    FlipDown,                   // Flip vertically (deprecated: use FlipVertical)
    FlipRight,                  // Flip horizontally (deprecated: use FlipHorizontal)
    MirrorHorizontal,           // Mirror horizontally
    MirrorVertical,             // Mirror vertically
    Rotate,                     // Rotate effect
    Zoom,                       // Zoom effect
    Pan,                        // Pan/position effect

    // Artistic Effects
    ColorNoise,                 // Color noise
    MonoNoise,                  // Monochrome noise
    Mosaic,                     // Mosaic/pixelate effect
    Posterize,                  // Posterize effect
    ShakeDown,                  // Shake effect
    Solorize,                   // Solarize effect
    Spray,                      // Spray effect
    Invert,                     // Invert colors

    // Denoising
    DenoiseCAST,                // CAST denoising algorithm
    DenoiseAdaptive,            // Adaptive denoising
    DenoiseMosquito,            // Mosquito noise reduction
    DenoiseSNR,                 // SNR-based denoising
    MaxineDenoise,              // NVIDIA Maxine AI denoising

    // Deinterlacing
    DeinterlaceBlend,           // Deinterlace (blend method)
    DeinterlaceTriangle,        // Deinterlace (triangle method)
    DeinterlaceCAVT,            // Deinterlace (CAVT method)

    // Transitions
    FadeIn,                     // Fade-in transition
    FadeOut,                    // Fade-out transition

    // Advanced Effects
    ScrollingTextLogo,          // Scrolling text overlay
    MaxineArtifactReduction,    // NVIDIA Maxine artifact reduction
    LUT,                        // Look-Up Table color grading
}
```

**Effect Categories**:

| Category | Effects |
| --- | --- |
| **Text & Graphics** | TextLogo, ImageLogo, ScrollingTextLogo |
| **Color Filters** | Blue, FilterBlue, FilterGreen, FilterRed, Green, Red, Greyscale |
| **Image Adjustments** | Blur, Contrast, Darkness, Lightness, Saturation, Sharpen, Smooth |
| **Spatial** | FlipDown, FlipRight, MirrorHorizontal, MirrorVertical, Rotate, Zoom, Pan |
| **Artistic** | ColorNoise, MonoNoise, Mosaic, Posterize, ShakeDown, Solorize, Spray, Invert |
| **Denoising** | DenoiseCAST, DenoiseAdaptive, DenoiseMosquito, DenoiseSNR, MaxineDenoise |
| **Deinterlacing** | DeinterlaceBlend, DeinterlaceTriangle, DeinterlaceCAVT |
| **Transitions** | FadeIn, FadeOut |
| **Advanced** | LUT, MaxineArtifactReduction |

**NVIDIA Maxine Effects** (require NVIDIA RTX GPU): - `MaxineDenoise` - AI-powered video denoising - `MaxineArtifactReduction` - Reduce compression artifacts

---

### VFTextLogo

Comprehensive text logo configuration structure.

```
[StructLayout(LayoutKind.Sequential)]
public struct VFTextLogo
{
    public int X;                       // X position
    public int Y;                       // Y position
    public bool TransparentBg;          // Transparent background
    public int FontSize;                // Font size (points)
    public bool FontItalic;             // Italic style
    public bool FontBold;               // Bold style
    public bool FontUnderline;          // Underline style
    public bool FontStrikeout;          // Strikeout style
    public int FontColor;               // Font color (RGB)
    public int BGColor;                 // Background color
    public bool RightToLeft;            // RTL text direction
    public bool Vertical;               // Vertical text
    public int Align;                   // Text alignment
    public int DrawQuality;             // Draw quality
    public int Antialiasing;            // Antialiasing mode
    public int RectWidth;               // Bounding rect width
    public int RectHeight;              // Bounding rect height
    public int RotationMode;            // Text rotation
    public int FlipMode;                // Text flip mode
    public int Transp;                  // Transparency (0-255)
    public bool Gradient;               // Enable gradient
    public int GradientMode;            // Gradient direction
    public int GradientColor1;          // Gradient start color
    public int GradientColor2;          // Gradient end color
    public int InnerBorderColor;        // Inner border color
    public int OuterBorderColor;        // Outer border color
    public int InnerBorderSize;         // Inner border width
    public int OuterBorderSize;         // Outer border width
    public int DrawMode;                // Draw mode
    public int BorderMode;              // Border style
    public int EffectMode;              // Effect mode
    public int ShapeType;               // Text shape
}
```

---

### VFGraphicalLogo

Image logo configuration structure.

```
[StructLayout(LayoutKind.Sequential)]
public struct VFGraphicalLogo
{
    public int X;                       // X position
    public int Y;                       // Y position
    public int Width;                   // Image width
    public int Height;                  // Image height
    public int Transp;                  // Transparency (0-255)
    public int RotationMode;            // Rotation angle
    public int FlipMode;                // Flip mode
    public VFVideoEffectStretchMode StretchMode;  // Stretch mode
}
```

---

## Complete Configuration Examples

### Example 1: Professional Text Overlay (C#)

```
using VisioForge.DirectShowAPI;
public void AddProfessionalTextOverlay(IBaseFilter effectsFilter)
{
    var effects = effectsFilter as IVFEffects45;
    if (effects == null) return;
    var textEffect = new VFVideoEffectSimple
    {
        EffectType = VideoEffectType.TextLogo,
        Enabled = true,
        Id = 1,
        TextLogo = new VFTextLogo
        {
            X = 50,
            Y = 50,
            FontSize = 36,
            FontBold = true,
            FontColor = 0xFFFFFF,          // White
            TransparentBg = true,
            Antialiasing = 2,               // High quality
            Transp = 230,                   // Slightly transparent
            Gradient = true,
            GradientMode = 0,               // Horizontal
            GradientColor1 = 0xFFFFFF,      // White
            GradientColor2 = 0x0080FF,      // Orange
            BorderMode = 6,                 // Filled outline
            OuterBorderColor = 0x000000,    // Black
            OuterBorderSize = 2
        }
    };
    effects.add_effect(textEffect);
}
```

### Example 2: Multi-Effect Chain (C#)

```
public void ApplyMultipleEffects(IBaseFilter effectsFilter)
{
    var effects = effectsFilter as IVFEffects45;
    if (effects == null) return;
    // 1. Deinterlace
    effects.add_effect(new VFVideoEffectSimple
    {
        EffectType = VideoEffectType.DeinterlaceBlend,
        Enabled = true,
        Id = 1
    });
    // 2. Denoise
    effects.add_effect(new VFVideoEffectSimple
    {
        EffectType = VideoEffectType.DenoiseAdaptive,
        Enabled = true,
        Id = 2
    });
    // 3. Adjust contrast
    effects.add_effect(new VFVideoEffectSimple
    {
        EffectType = VideoEffectType.Contrast,
        Enabled = true,
        Id = 3
    });
    // 4. Add watermark
    effects.add_effect(new VFVideoEffectSimple
    {
        EffectType = VideoEffectType.ImageLogo,
        Enabled = true,
        Id = 4,
        GraphicalLogo = new VFGraphicalLogo
        {
            X = 1800,
            Y = 50,
            Width = 100,
            Height = 100,
            Transp = 200,
            StretchMode = VFVideoEffectStretchMode.Stretch
        }
    });
}
```

### Example 3: High-Quality Resize with Rotation (C#)

```
public void ConfigureResizeAndRotate(IBaseFilter resizeFilter)
{
    var resize = resizeFilter as IVFResize;
    if (resize == null) return;
    // Resize to 4K
    resize.put_Resolution(3840, 2160);
    // Maintain aspect ratio with letterbox
    resize.put_ResizeMode(VFResizeMode.rmLetterbox, true);
    // Use highest quality Lanczos algorithm
    resize.put_FilterMode(VFResizeFilterMode.Lanczos);
    // Rotate 90 degrees clockwise
    resize.put_RotateMode(VFRotateMode.RM_90);
    // No cropping
    resize.put_Crop(0, 0, 0, 0);
}
```

### Example 4: Sample Grabber with Effects (C#)

## ``` public class EffectsWithFrameCapture { private IVFEffectsPro _effectsPro; public void Setup(IBaseFilter effectsFilter) { _effectsPro = effectsFilter as IVFEffectsPro; if (_effectsPro == null) return; // Enable effects and sample grabber _effectsPro.set_enabled( effects: true, motdet: false, chroma: false, sg: true); // Set up callback _effectsPro.put_sg_app_handle(IntPtr.Zero); _effectsPro.put_sg_app_handle_id(1); _effectsPro.set_sg_callback_32(OnFrameReceived); } private int OnFrameReceived( IntPtr handle, uint handle_id, IntPtr pBuffer, int bufferLen, int width, int height, long startTime, long stopTime, ref bool updateFrame) { // Process frame Console.WriteLine($"Frame: {width}x{height}, {bufferLen} bytes"); // Can modify frame data in pBuffer // Set updateFrame = true to update the frame return 0; } } ```

## See Also

- [Video Mixer Interface](../video-mixer/) - Multi-source video mixing
- [Chroma Key Interface](../chroma-key/) - Green screen compositing
- [Effects Reference](../../effects-reference/) - Complete effects catalog
- [Processing Filters Pack Overview](../../)
- [Code Examples](../../examples/)

---END OF PAGE---


## DirectShow Video Mixer Filter - PIP and Chroma Key API
**URL:** https://www.visioforge.com/help/docs/directshow/proc-filters/interfaces/video-mixer/
**Description:** IVFVideoMixer interface for mixing 2-16 video sources with PIP, chroma keying, transparency, and customizable layout configurations.
**Tags:** DirectShow, C++, Windows, Effects, Mixing, Webcam, C#
**API:** IVFVideoMixer, IBaseFilter, IVFChromaKey

# IVFVideoMixer Interface Reference

## Overview

The `IVFVideoMixer` interface provides comprehensive control over multi-source video mixing in DirectShow applications. This interface enables Picture-in-Picture (PIP), video compositing, chroma keying, and flexible layout management for combining multiple video streams into a single output.

The Video Mixer filter can handle 2-16 input video sources, each with independent position, size, transparency, and z-order configuration.

## Interface Definition

- **Interface Name**: `IVFVideoMixer`
- **GUID**: `{3318300E-F6F1-4d81-8BC3-9DB06B09F77A}`
- **Inherits From**: `IUnknown`
- **Header File**: `yk_video_mixer_filter_define.h` (C++), `IVFVideoMixer.cs` (.NET)

## Capabilities

- **Input Pins**: 2-16 simultaneous video sources
- **Chroma Keying**: Green/blue screen support per input
- **Resize Quality**: Multiple interpolation algorithms
- **Z-Order**: Independent layering control
- **Transparency**: Per-input alpha blending
- **Position/Size**: Pixel-accurate placement

---

## Methods Reference

### Input Parameter Management

#### SetInputParam

Configures parameters for a specific input pin. **Syntax (C++)**:

```
int SetInputParam(int pin_index, VFPIPVideoInputParam param);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetInputParam([In] int pin_index, [In] VFPIPVideoInputParam param);
```

**Parameters**: - `pin_index`: Zero-based input pin index (0 = first input, 1 = second, etc.) - `param`: Structure containing input configuration (see below) **Returns**: `0` on success, error code otherwise. **VFPIPVideoInputParam Structure**: | Field | Type | Description | |-------|------|-------------| | `Enabled` | bool | Enable/disable this input | | `Left` | int | X position (pixels) | | `Top` | int | Y position (pixels) | | `Width` | int | Width (pixels) | | `Height` | int | Height (pixels) | | `Alpha` | int | Transparency (0-255, 255=opaque) | | `Visible` | bool | Visibility flag | | `ZOrder` | int | Layer order (higher = foreground) | | `StretchMode` | VFPIPResizeQuality | Resize quality | **Usage Notes**: - Pin 0 is typically the background/main source - Pins 1+ are overlay sources - Position (0,0) is top-left corner - Size can differ from source resolution (automatic scaling) - Alpha blending requires some GPU overhead **Example (C++)**:

```
IVFVideoMixer* pMixer = nullptr;
pFilter->QueryInterface(IID_IVFVideoMixer, (void**)&pMixer);
// Configure second input (overlay)
VFPIPVideoInputParam param;
param.Enabled = true;
param.Visible = true;
param.Left = 50;
param.Top = 50;
param.Width = 640;
param.Height = 360;
param.Alpha = 255;        // Fully opaque
param.ZOrder = 10;        // On top of background
pMixer->SetInputParam(1, param);
pMixer->Release();
```

**Example (C#)**:

```
var mixer = filter as IVFVideoMixer;
// Configure PIP in bottom-right corner
var param = new VFPIPVideoInputParam
{
    Enabled = true,
    Visible = true,
    Left = 1600,          // Assuming 1920x1080 output
    Top = 820,
    Width = 320,          // Small PIP
    Height = 180,
    Alpha = 255,
    ZOrder = 100          // Top layer
};
mixer.SetInputParam(1, param);
```

---

#### GetInputParam

Retrieves current parameters for a specific input pin.

**Syntax (C++)**:

```
int GetInputParam(int pin_index, VFPIPVideoInputParam *param);
```

**Syntax (C#)**:

```
[PreserveSig]
int GetInputParam([In] int pin_index, [Out] out VFPIPVideoInputParam param);
```

**Parameters**: - `pin_index`: Zero-based input pin index - `param`: [out] Receives current input configuration

**Returns**: `0` on success.

**Example (C++)**:

```
VFPIPVideoInputParam param;
pMixer->GetInputParam(1, &param);

printf("Input 1 position: %d,%d\n", param.Left, param.Top);
printf("Input 1 size: %dx%d\n", param.Width, param.Height);
```

---

#### GetInputParam2

Retrieves parameters by pin interface reference instead of index. **Syntax (C++)**:

```
int GetInputParam2(IPin *pin, VFPIPVideoInputParam *param);
```

**Syntax (C#)**:

```
[PreserveSig]
int GetInputParam2([In] object pin, [Out] out VFPIPVideoInputParam param);
```

**Parameters**: - `pin`: DirectShow IPin interface pointer - `param`: [out] Receives input configuration **Returns**: `0` on success. **Usage Notes**: - Alternative to GetInputParam when you have pin reference - Useful when enumerating pins dynamically

---

### Output Configuration

#### SetOutputParam

Configures the mixer's output video format.

**Syntax (C++)**:

```
int SetOutputParam(VFPIPVideoOutputParam param);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetOutputParam([In] VFPIPVideoOutputParam param);
```

**Parameters**: - `param`: Output configuration structure

**VFPIPVideoOutputParam Structure**:

| Field | Type | Description |
| --- | --- | --- |
| `Width` | int | Output width (pixels) |
| `Height` | int | Output height (pixels) |
| `FrameRate` | double | Output frame rate (fps) |
| `BackgroundColor` | COLORREF | Background color (RGB) |

**Usage Notes**: - Must be called before connecting downstream filters - All inputs are scaled/positioned relative to output size - Frame rate can differ from inputs (mixer handles timing)

**Example (C++)**:

```
VFPIPVideoOutputParam output;
output.Width = 1920;
output.Height = 1080;
output.FrameRate = 30.0;
output.BackgroundColor = RGB(0, 0, 0);  // Black background

pMixer->SetOutputParam(output);
```

**Example (C#)**:

```
var output = new VFPIPVideoOutputParam
{
    Width = 1280,
    Height = 720,
    FrameRate = 60.0,
    BackgroundColor = 0x003300  // Dark green
};

mixer.SetOutputParam(output);
```

---

#### GetOutputParam

Retrieves current output configuration. **Syntax (C++)**:

```
int GetOutputParam(VFPIPVideoOutputParam *param);
```

**Syntax (C#)**:

```
[PreserveSig]
int GetOutputParam([Out] out VFPIPVideoOutputParam param);
```

**Parameters**: - `param`: [out] Receives output configuration **Returns**: `0` on success.

---

### Chroma Key Configuration

#### SetChromaSettings

Configures chroma key (green/blue screen) settings for compositing.

**Syntax (C++)**:

```
int SetChromaSettings(bool enabled, int color, int tolerance1, int tolerance2);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetChromaSettings([In, MarshalAs(UnmanagedType.Bool)] bool enabled,
                      int color,
                      int tolerance1,
                      int tolerance2);
```

**Parameters**: - `enabled`: Enable/disable chroma keying - `color`: Key color (0=green, 1=blue, 2=red, or custom RGB) - `tolerance1`: Color matching tolerance (0-255) - `tolerance2`: Edge tolerance (0-255)

**Returns**: `0` on success.

**Usage Notes**: - Applies to all inputs that have chroma color - Lower tolerance = stricter color matching - Higher tolerance = more colors removed (may affect subject) - tolerance2 helps with edge smoothing

**Chroma Color Values**: - `0` - Green (most common) - `1` - Blue - `2` - Red - Custom RGB value

**Example (C++)**:

```
// Enable green screen with moderate tolerance
pMixer->SetChromaSettings(true, 0, 50, 30);
```

**Example (C#)**:

```
// Blue screen with tight tolerance
mixer.SetChromaSettings(true, 1, 30, 20);

// Disable chroma keying
mixer.SetChromaSettings(false, 0, 0, 0);
```

---

### Layer Order Management

#### SetInputOrder

Sets the z-order (layer order) for a specific input. **Syntax (C++)**:

```
int SetInputOrder(int pin_index, int order);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetInputOrder(int pin_index, int order);
```

**Parameters**: - `pin_index`: Zero-based input pin index - `order`: Z-order value (higher = foreground) **Returns**: `0` on success. **Usage Notes**: - Higher order values render on top - Typical range: 0-100 - Can be changed dynamically during playback - Alternative to setting ZOrder in VFPIPVideoInputParam **Example (C++)**:

```
// Background
pMixer->SetInputOrder(0, 0);
// Middle layer
pMixer->SetInputOrder(1, 50);
// Top overlay
pMixer->SetInputOrder(2, 100);
```

---

### Quality Configuration

#### SetResizeQuality

Sets the resize quality/algorithm for all inputs.

**Syntax (C++)**:

```
int SetResizeQuality(VFPIPResizeQuality quality);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetResizeQuality(VFPIPResizeQuality quality);
```

**Parameters**: - `quality`: Resize quality mode

**VFPIPResizeQuality Enumeration**:

| Value | Algorithm | Quality | Speed | Use Case |
| --- | --- | --- | --- | --- |
| **NearestNeighbor** | Nearest pixel | Low | ★★★★★ | Pixel art, fast preview |
| **Bilinear** | Linear interpolation | Medium | ★★★★☆ | Standard quality |
| **Bicubic** | Cubic interpolation | High | ★★★☆☆ | High quality (default) |
| **Lanczos** | Lanczos-3 | Highest | ★★☆☆☆ | Professional quality |

**Usage Notes**: - Bicubic is recommended for most use cases - Lanczos for maximum quality when performance allows - Bilinear for real-time performance - NearestNeighbor only for special cases

**Example (C++)**:

```
// High quality mixing
pMixer->SetResizeQuality(VFPIPResizeQuality::Lanczos);

// Performance mode
pMixer->SetResizeQuality(VFPIPResizeQuality::Bilinear);
```

---

## Complete Configuration Examples

### Example 1: Picture-in-Picture (C++)

```
#include "yk_video_mixer_filter_define.h"
HRESULT ConfigurePIPLayout(IBaseFilter* pMixerFilter)
{
    HRESULT hr;
    IVFVideoMixer* pMixer = nullptr;
    hr = pMixerFilter->QueryInterface(IID_IVFVideoMixer, (void**)&pMixer);
    if (FAILED(hr))
        return hr;
    // Set 1080p output
    VFPIPVideoOutputParam output;
    output.Width = 1920;
    output.Height = 1080;
    output.FrameRate = 30.0;
    output.BackgroundColor = RGB(0, 0, 0);
    pMixer->SetOutputParam(output);
    // Configure main video (input 0 - background)
    VFPIPVideoInputParam main;
    main.Enabled = true;
    main.Visible = true;
    main.Left = 0;
    main.Top = 0;
    main.Width = 1920;
    main.Height = 1080;
    main.Alpha = 255;
    main.ZOrder = 0;        // Background
    pMixer->SetInputParam(0, main);
    // Configure PIP (input 1 - bottom-right corner)
    VFPIPVideoInputParam pip;
    pip.Enabled = true;
    pip.Visible = true;
    pip.Left = 1560;        // 1920 - 360 (width) + margin
    pip.Top = 860;          // 1080 - 220 (height) + margin
    pip.Width = 360;
    pip.Height = 202;       // 16:9 aspect
    pip.Alpha = 255;
    pip.ZOrder = 100;       // Foreground
    pMixer->SetInputParam(1, pip);
    // High quality resize
    pMixer->SetResizeQuality(VFPIPResizeQuality::Bicubic);
    pMixer->Release();
    return S_OK;
}
```

### Example 2: Split Screen (C#)

```
using VisioForge.DirectShowAPI;
public class SplitScreenMixer
{
    public void ConfigureSplitScreen(IBaseFilter mixerFilter)
    {
        var mixer = mixerFilter as IVFVideoMixer;
        if (mixer == null)
            throw new NotSupportedException("IVFVideoMixer not available");
        // 1920x1080 output
        var output = new VFPIPVideoOutputParam
        {
            Width = 1920,
            Height = 1080,
            FrameRate = 30.0,
            BackgroundColor = 0x000000
        };
        mixer.SetOutputParam(output);
        // Left half - Input 0
        var leftInput = new VFPIPVideoInputParam
        {
            Enabled = true,
            Visible = true,
            Left = 0,
            Top = 0,
            Width = 960,        // Half width
            Height = 1080,
            Alpha = 255,
            ZOrder = 0
        };
        mixer.SetInputParam(0, leftInput);
        // Right half - Input 1
        var rightInput = new VFPIPVideoInputParam
        {
            Enabled = true,
            Visible = true,
            Left = 960,         // Offset by half
            Top = 0,
            Width = 960,
            Height = 1080,
            Alpha = 255,
            ZOrder = 0
        };
        mixer.SetInputParam(1, rightInput);
        mixer.SetResizeQuality(VFPIPResizeQuality.Bicubic);
    }
}
```

### Example 3: Chroma Key Overlay (C++)

```
HRESULT ConfigureChromaKeyOverlay(IVFVideoMixer* pMixer)
{
    // 1080p output
    VFPIPVideoOutputParam output;
    output.Width = 1920;
    output.Height = 1080;
    output.FrameRate = 30.0;
    output.BackgroundColor = RGB(0, 0, 0);
    pMixer->SetOutputParam(output);
    // Background scene (input 0)
    VFPIPVideoInputParam background;
    background.Enabled = true;
    background.Visible = true;
    background.Left = 0;
    background.Top = 0;
    background.Width = 1920;
    background.Height = 1080;
    background.Alpha = 255;
    background.ZOrder = 0;
    pMixer->SetInputParam(0, background);
    // Person in front of green screen (input 1)
    VFPIPVideoInputParam subject;
    subject.Enabled = true;
    subject.Visible = true;
    subject.Left = 400;
    subject.Top = 100;
    subject.Width = 1120;
    subject.Height = 880;
    subject.Alpha = 255;
    subject.ZOrder = 10;
    pMixer->SetInputParam(1, subject);
    // Enable green screen chroma keying
    pMixer->SetChromaSettings(
        true,   // Enable
        0,      // Green
        60,     // Color tolerance
        40      // Edge tolerance
    );
    // High quality for best chroma key edges
    pMixer->SetResizeQuality(VFPIPResizeQuality::Lanczos);
    return S_OK;
}
```

### Example 4: Multi-Camera Grid (C#)

## ``` public void Configure2x2Grid(IVFVideoMixer mixer) { // 1920x1080 output var output = new VFPIPVideoOutputParam { Width = 1920, Height = 1080, FrameRate = 30.0, BackgroundColor = 0x101010 // Dark gray }; mixer.SetOutputParam(output); int cellWidth = 960; int cellHeight = 540; int gap = 10; // Top-left camera (input 0) mixer.SetInputParam(0, new VFPIPVideoInputParam { Enabled = true, Visible = true, Left = gap, Top = gap, Width = cellWidth - gap * 2, Height = cellHeight - gap * 2, Alpha = 255, ZOrder = 0 }); // Top-right camera (input 1) mixer.SetInputParam(1, new VFPIPVideoInputParam { Enabled = true, Visible = true, Left = cellWidth + gap, Top = gap, Width = cellWidth - gap * 2, Height = cellHeight - gap * 2, Alpha = 255, ZOrder = 0 }); // Bottom-left camera (input 2) mixer.SetInputParam(2, new VFPIPVideoInputParam { Enabled = true, Visible = true, Left = gap, Top = cellHeight + gap, Width = cellWidth - gap * 2, Height = cellHeight - gap * 2, Alpha = 255, ZOrder = 0 }); // Bottom-right camera (input 3) mixer.SetInputParam(3, new VFPIPVideoInputParam { Enabled = true, Visible = true, Left = cellWidth + gap, Top = cellHeight + gap, Width = cellWidth - gap * 2, Height = cellHeight - gap * 2, Alpha = 255, ZOrder = 0 }); mixer.SetResizeQuality(VFPIPResizeQuality.Bicubic); } ```

## Common Mixing Scenarios

### Scenario 1: News Broadcast Style

```
+------------------------------------------+
|                                          |
|        Main Camera (full screen)         |
|                                          |
|                           +-----------+  |
|                           |   Guest   |  |
|                           |  Camera   |  |
|                           +-----------+  |
+------------------------------------------+
```

**Configuration**: - Input 0: Main camera (1920x1080) - Input 1: Guest PIP (320x180, bottom-right) - Z-Order: Guest on top - Resize Quality: Bicubic

### Scenario 2: Gaming Stream

```
+------------------------------------------+
|                                          |
|        Game Capture (main)               |
|                                          |
|  +----------+                            |
|  | Webcam   |                            |
|  +----------+                            |
+------------------------------------------+
```

**Configuration**: - Input 0: Game capture (1920x1080) - Input 1: Webcam (280x210, top-left) - Optional: Chroma key if webcam has green screen - Z-Order: Webcam on top

### Scenario 3: Virtual Production

```
+------------------------------------------+
|                                          |
|    Background Scene (pre-rendered)       |
|                                          |
|         [Person with green screen        |
|          composited on top]              |
|                                          |
+------------------------------------------+
```

**Configuration**: - Input 0: Virtual background - Input 1: Camera with green screen - Chroma key: Enabled, green, tolerance 60/40 - Resize Quality: Lanczos for best edge quality

---

## Performance Considerations

### CPU/GPU Usage

**Low Impact Configurations**: - 2-4 inputs - Bilinear resize - No chroma keying - No transparency (Alpha = 255) **Medium Impact**: - 5-8 inputs - Bicubic resize - Basic chroma keying - Some transparency **High Impact**: - 9+ inputs - Lanczos resize - Complex chroma keying - Multiple transparent layers

### Optimization Tips

1. **Use appropriate resize quality**:
2. Preview: Bilinear
3. Production: Bicubic
4. Maximum quality: Lanczos (if performance allows)
5. **Minimize chroma keying overhead**:
6. Only enable when needed
7. Use tight tolerance values
8. Consider hardware-accelerated alternative
9. **Limit number of inputs**:
10. Each input adds processing overhead
11. Disable unused inputs (Enabled = false)
12. **Match source resolutions**:
13. Less scaling = better performance
14. Pre-scale sources if possible

---

## Best Practices

### Layout Design

1. **Plan z-order carefully** - Background lowest, overlays highest
2. **Leave margins** - Don't position elements at exact edges
3. **Maintain aspect ratios** - Avoid distortion
4. **Test at target resolution** - Verify positioning accuracy

### Chroma Keying

1. **Proper lighting** - Even lighting on green screen
2. **Adjust tolerance** - Start low, increase gradually
3. **Quality setting** - Use Lanczos for best edges
4. **Test conditions** - Different lighting scenarios

### Dynamic Changes

1. **Update parameters smoothly** - Avoid abrupt position changes
2. **Cache configurations** - Store presets for quick switching
3. **Validate parameters** - Check bounds before applying
4. **Handle errors** - Check return values

---

## Troubleshooting

### Issue: Video Not Appearing

**Check**: - `Enabled = true` - `Visible = true` - `Alpha > 0` - Position within output bounds - Source filter is running

### Issue: Poor Quality Scaling

**Solution**:

```
pMixer->SetResizeQuality(VFPIPResizeQuality::Lanczos);
```

### Issue: Chroma Key Not Working

**Check**: - Chroma settings enabled - Correct color selected (0=green, 1=blue) - Increase tolerance values - Verify source has uniform green screen **Example**:

```
// Try higher tolerance
pMixer->SetChromaSettings(true, 0, 80, 60);
```

### Issue: Performance Problems

**Solutions**: - Reduce number of active inputs - Use faster resize quality - Disable chroma keying if not needed - Pre-scale input sources

---

## Related Interfaces

- **IBaseFilter** - DirectShow filter interface
- **IPin** - DirectShow pin interface (for GetInputParam2)
- **IVFEffects45** - Video effects (can combine with mixer)
- **IVFChromaKey** - Dedicated chroma key interface

## See Also

- [Processing Filters Pack Overview](../../)
- [Effects Reference](../../effects-reference/)
- [Chroma Key Interface](../chroma-key/)
- [Code Examples](../../examples/)

---END OF PAGE---


## DirectShow Video Encryption Examples - C#, C++, Delphi
**URL:** https://www.visioforge.com/help/docs/directshow/video-encryption-sdk/examples/
**Description:** Encrypt and decrypt MP4 video files using VisioForge DirectShow filters. AES-256 examples with password protection and binary key modes.
**Tags:** Video Encryption SDK, DirectShow, C++, Windows, Encoding, MP4, H.264, AAC, C#
**API:** IBaseFilter, IVFCryptoConfig, IFileSinkFilter, SourceFilter, VideoEncoder

# Video Encryption SDK - Code Examples

## Overview

This page provides comprehensive, working code examples for encrypting and decrypting video files using the Video Encryption SDK. Examples cover:

- **Basic Encryption** - Encrypt video files with password protection
- **File Decryption** - Decrypt and play encrypted video files
- **Advanced Scenarios** - Binary keys, file-based keys, custom encoding settings
- **Error Handling** - Robust error checking and recovery

All examples include complete implementations in C++, C#, and Delphi.

Interface naming across language wrappers

The native C++ header (`encryptor_intf.h`) declares this interface as `ICryptoConfig` with `IID_ICryptoConfig`. The C# and Delphi wrappers expose the same interface as `IVFCryptoConfig` (and the password provider as `IVFPasswordProvider`). Both names share GUID `{BAA5BD1E-3B30-425e-AB3B-CC20764AC253}` and refer to the same COM interface — the C++ snippets below use `ICryptoConfig` while the C#/Delphi snippets use `IVFCryptoConfig`.

---

## Prerequisites

### C++ Projects

```
#include <dshow.h>
#include <streams.h>
#include "encryptor_intf.h"
#pragma comment(lib, "strmiids.lib")
#pragma comment(lib, "quartz.lib")
```

### C# Projects

```
using System;
using System.Runtime.InteropServices;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;
```

**Required NuGet Packages**: - VisioForge.DirectShowAPI - VisioForge.DirectShowLib

### Delphi Projects

## ``` uses DirectShow9, EncryptorIntf; ```

## Example 1: Basic Video Encryption

Encrypt a video file with string password.

### C# Implementation

```
using System;
using System.Runtime.InteropServices;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;

public class BasicVideoEncryption
{
    private IFilterGraph2 filterGraph;
    private IMediaControl mediaControl;
    private IMediaEventEx mediaEvent;

    public void EncryptVideo(string inputFile, string outputFile, string password)
    {
        try
        {
            // Create filter graph
            filterGraph = (IFilterGraph2)new FilterGraph();
            mediaControl = (IMediaControl)filterGraph;
            mediaEvent = (IMediaEventEx)filterGraph;

            // Add source filter
            int hr = filterGraph.AddSourceFilter(inputFile, "Source", out IBaseFilter sourceFilter);
            DsError.ThrowExceptionForHR(hr);

            // Add video encoder (H.264)
            var videoEncoder = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFH264Encoder,
                "H.264 Encoder"
            );

            // Add audio encoder (AAC)
            var audioEncoder = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFAACEncoder,
                "AAC Encoder"
            );

            // Add encrypt muxer filter
            var encryptMuxer = (IBaseFilter)Activator.CreateInstance(
                Type.GetTypeFromCLSID(new Guid("F1D3727A-88DE-49ab-A635-280BEFEFF902"))
            );

            hr = filterGraph.AddFilter(encryptMuxer, "Encrypt Muxer");
            DsError.ThrowExceptionForHR(hr);

            // Configure encryption password
            var cryptoConfig = encryptMuxer as IVFCryptoConfig;
            if (cryptoConfig != null)
            {
                // Apply password using helper method
                cryptoConfig.ApplyString(password);

                // Verify password is set
                hr = cryptoConfig.HavePassword();
                if (hr != 0)
                {
                    throw new Exception("Failed to set encryption password");
                }

                Console.WriteLine("Encryption password configured successfully");
            }
            else
            {
                throw new Exception("IVFCryptoConfig interface not available");
            }

            // Set output file
            var fileSink = encryptMuxer as IFileSinkFilter;
            if (fileSink != null)
            {
                hr = fileSink.SetFileName(outputFile, null);
                DsError.ThrowExceptionForHR(hr);
            }

            // Build filter graph connections
            ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
            hr = captureGraph.SetFiltergraph(filterGraph);
            DsError.ThrowExceptionForHR(hr);

            // Connect video path: Source → H.264 Encoder → Encrypt Muxer
            hr = captureGraph.RenderStream(
                null,
                MediaType.Video,
                sourceFilter,
                videoEncoder,
                encryptMuxer
            );
            DsError.ThrowExceptionForHR(hr);

            // Connect audio path: Source → AAC Encoder → Encrypt Muxer
            hr = captureGraph.RenderStream(
                null,
                MediaType.Audio,
                sourceFilter,
                audioEncoder,
                encryptMuxer
            );
            DsError.ThrowExceptionForHR(hr);

            Console.WriteLine("Filter graph built successfully");
            Console.WriteLine("Starting encryption...");

            // Start encoding
            hr = mediaControl.Run();
            DsError.ThrowExceptionForHR(hr);

            // Wait for completion
            EventCode eventCode;
            do
            {
                hr = mediaEvent.WaitForCompletion(1000, out eventCode);
            }
            while (eventCode == 0);

            Console.WriteLine("Encryption completed successfully!");

            // Cleanup
            Marshal.ReleaseComObject(captureGraph);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"ERROR: {ex.Message}");
            throw;
        }
        finally
        {
            Stop();
        }
    }

    public void Stop()
    {
        if (mediaControl != null)
        {
            mediaControl.Stop();
        }

        if (filterGraph != null)
        {
            FilterGraphTools.RemoveAllFilters(filterGraph);
        }

        if (mediaEvent != null) Marshal.ReleaseComObject(mediaEvent);
        if (mediaControl != null) Marshal.ReleaseComObject(mediaControl);
        if (filterGraph != null) Marshal.ReleaseComObject(filterGraph);
    }
}

// Usage:
// var encryptor = new BasicVideoEncryption();
// encryptor.EncryptVideo(@"C:\input.mp4", @"C:\output.encrypted.mp4", "MySecurePassword123");
```

### C++ Implementation

```
#include <dshow.h>
#include <streams.h>
#include "encryptor_intf.h"

class BasicVideoEncryption
{
private:
    IGraphBuilder* pGraph;
    IMediaControl* pControl;
    IMediaEvent* pEvent;

public:
    BasicVideoEncryption() : pGraph(NULL), pControl(NULL), pEvent(NULL) {}

    HRESULT EncryptVideo(LPCWSTR inputFile, LPCWSTR outputFile, LPCWSTR password)
    {
        HRESULT hr;

        // Create filter graph
        hr = CoCreateInstance(
            CLSID_FilterGraph,
            NULL,
            CLSCTX_INPROC_SERVER,
            IID_IGraphBuilder,
            (void**)&pGraph
        );
        if (FAILED(hr)) return hr;

        // Get control and event interfaces
        pGraph->QueryInterface(IID_IMediaControl, (void**)&pControl);
        pGraph->QueryInterface(IID_IMediaEvent, (void**)&pEvent);

        // Add source filter
        IBaseFilter* pSource = NULL;
        hr = pGraph->AddSourceFilter(inputFile, L"Source", &pSource);
        if (FAILED(hr)) goto cleanup;

        // Add video encoder (H.264)
        IBaseFilter* pVideoEncoder = NULL;
        hr = CoCreateInstance(
            CLSID_VFH264Encoder,
            NULL,
            CLSCTX_INPROC_SERVER,
            IID_IBaseFilter,
            (void**)&pVideoEncoder
        );
        if (FAILED(hr)) goto cleanup;
        hr = pGraph->AddFilter(pVideoEncoder, L"H.264 Encoder");

        // Add audio encoder (AAC)
        IBaseFilter* pAudioEncoder = NULL;
        hr = CoCreateInstance(
            CLSID_VFAACEncoder,
            NULL,
            CLSCTX_INPROC_SERVER,
            IID_IBaseFilter,
            (void**)&pAudioEncoder
        );
        if (FAILED(hr)) goto cleanup;
        hr = pGraph->AddFilter(pAudioEncoder, L"AAC Encoder");

        // Add encrypt muxer
        IBaseFilter* pMuxer = NULL;
        hr = CoCreateInstance(
            CLSID_EncryptMuxer,
            NULL,
            CLSCTX_INPROC_SERVER,
            IID_IBaseFilter,
            (void**)&pMuxer
        );
        if (FAILED(hr)) goto cleanup;
        hr = pGraph->AddFilter(pMuxer, L"Encrypt Muxer");

        // Configure encryption
        ICryptoConfig* pCrypto = NULL;
        hr = pMuxer->QueryInterface(IID_ICryptoConfig, (void**)&pCrypto);
        if (SUCCEEDED(hr))
        {
            // Set password
            hr = pCrypto->put_Password(
                (LPBYTE)password,
                wcslen(password) * sizeof(wchar_t)
            );

            if (SUCCEEDED(hr))
            {
                // Verify password is set
                HRESULT hrPassword = pCrypto->HavePassword();
                if (hrPassword == S_OK)
                {
                    wprintf(L"Encryption password configured successfully\n");
                }
                else
                {
                    wprintf(L"WARNING: Password not set\n");
                }
            }

            pCrypto->Release();
        }

        // Set output file
        IFileSinkFilter* pFileSink = NULL;
        hr = pMuxer->QueryInterface(IID_IFileSinkFilter, (void**)&pFileSink);
        if (SUCCEEDED(hr))
        {
            hr = pFileSink->SetFileName(outputFile, NULL);
            pFileSink->Release();
        }

        // Build graph using Intelligent Connect
        ICaptureGraphBuilder2* pBuilder = NULL;
        hr = CoCreateInstance(
            CLSID_CaptureGraphBuilder2,
            NULL,
            CLSCTX_INPROC_SERVER,
            IID_ICaptureGraphBuilder2,
            (void**)&pBuilder
        );
        if (SUCCEEDED(hr))
        {
            pBuilder->SetFiltergraph(pGraph);

            // Connect video path
            pBuilder->RenderStream(
                NULL,
                &MEDIATYPE_Video,
                pSource,
                pVideoEncoder,
                pMuxer
            );

            // Connect audio path
            pBuilder->RenderStream(
                NULL,
                &MEDIATYPE_Audio,
                pSource,
                pAudioEncoder,
                pMuxer
            );

            pBuilder->Release();
        }

        wprintf(L"Starting encryption...\n");

        // Run the graph
        hr = pControl->Run();
        if (FAILED(hr)) goto cleanup;

        // Wait for completion
        long evCode;
        pEvent->WaitForCompletion(INFINITE, &evCode);

        wprintf(L"Encryption completed successfully!\n");

cleanup:
        if (pMuxer) pMuxer->Release();
        if (pVideoEncoder) pVideoEncoder->Release();
        if (pAudioEncoder) pAudioEncoder->Release();
        if (pSource) pSource->Release();

        Stop();

        return hr;
    }

    void Stop()
    {
        if (pControl)
        {
            pControl->Stop();
        }

        if (pEvent) pEvent->Release();
        if (pControl) pControl->Release();
        if (pGraph) pGraph->Release();

        pEvent = NULL;
        pControl = NULL;
        pGraph = NULL;
    }
};

// Usage:
// BasicVideoEncryption encryptor;
// encryptor.EncryptVideo(L"C:\\input.mp4", L"C:\\output.encrypted.mp4", L"MySecurePassword123");
```

### Delphi Implementation

```
uses
  DirectShow9,
  ActiveX,
  EncryptorIntf;

type
  TBasicVideoEncryption = class
  private
    FFilterGraph: IGraphBuilder;
    FMediaControl: IMediaControl;
    FMediaEvent: IMediaEvent;
  public
    function EncryptVideo(const InputFile, OutputFile, Password: WideString): HRESULT;
    procedure Stop;
  end;

function TBasicVideoEncryption.EncryptVideo(const InputFile, OutputFile, Password: WideString): HRESULT;
var
  SourceFilter: IBaseFilter;
  VideoEncoder: IBaseFilter;
  AudioEncoder: IBaseFilter;
  EncryptMuxer: IBaseFilter;
  CryptoConfig: IVFCryptoConfig;
  FileSink: IFileSinkFilter;
  CaptureGraph: ICaptureGraphBuilder2;
  EventCode: Integer;
begin
  Result := E_FAIL;

  try
    // Create filter graph
    Result := CoCreateInstance(CLSID_FilterGraph, nil, CLSCTX_INPROC_SERVER,
                               IID_IGraphBuilder, FFilterGraph);
    if Failed(Result) then Exit;

    // Get control and event interfaces
    FFilterGraph.QueryInterface(IID_IMediaControl, FMediaControl);
    FFilterGraph.QueryInterface(IID_IMediaEvent, FMediaEvent);

    // Add source filter
    Result := FFilterGraph.AddSourceFilter(PWideChar(InputFile), 'Source', SourceFilter);
    if Failed(Result) then Exit;

    // Add video encoder (H.264)
    Result := CoCreateInstance(CLSID_VFH264Encoder, nil, CLSCTX_INPROC_SERVER,
                               IID_IBaseFilter, VideoEncoder);
    if Succeeded(Result) then
      FFilterGraph.AddFilter(VideoEncoder, 'H.264 Encoder');

    // Add audio encoder (AAC)
    Result := CoCreateInstance(CLSID_VFAACEncoder, nil, CLSCTX_INPROC_SERVER,
                               IID_IBaseFilter, AudioEncoder);
    if Succeeded(Result) then
      FFilterGraph.AddFilter(AudioEncoder, 'AAC Encoder');

    // Add encrypt muxer
    Result := CoCreateInstance(CLSID_EncryptMuxer, nil, CLSCTX_INPROC_SERVER,
                               IID_IBaseFilter, EncryptMuxer);
    if Failed(Result) then Exit;
    FFilterGraph.AddFilter(EncryptMuxer, 'Encrypt Muxer');

    // Configure encryption
    if Supports(EncryptMuxer, IVFCryptoConfig, CryptoConfig) then
    begin
      // Set password
      // pBuffer is opaque binary data (PByte); cast through PWideChar to reuse
      // the wide-string buffer, length in bytes = char count * 2.
      Result := CryptoConfig.put_Password(PByte(PWideChar(Password)), Length(Password) * 2);

      if Succeeded(Result) then
      begin
        // Verify password is set
        if CryptoConfig.HavePassword = S_OK then
          WriteLn('Encryption password configured successfully')
        else
          WriteLn('WARNING: Password not set');
      end;
    end;

    // Set output file
    if Supports(EncryptMuxer, IFileSinkFilter, FileSink) then
      FileSink.SetFileName(PWideChar(OutputFile), nil);

    // Build graph connections
    Result := CoCreateInstance(CLSID_CaptureGraphBuilder2, nil, CLSCTX_INPROC_SERVER,
                               IID_ICaptureGraphBuilder2, CaptureGraph);
    if Succeeded(Result) then
    begin
      CaptureGraph.SetFiltergraph(FFilterGraph);

      // Connect video path
      CaptureGraph.RenderStream(nil, @MEDIATYPE_Video, SourceFilter,
                                VideoEncoder, EncryptMuxer);

      // Connect audio path
      CaptureGraph.RenderStream(nil, @MEDIATYPE_Audio, SourceFilter,
                                AudioEncoder, EncryptMuxer);
    end;

    WriteLn('Starting encryption...');

    // Run the graph
    Result := FMediaControl.Run;
    if Failed(Result) then Exit;

    // Wait for completion
    repeat
      FMediaEvent.WaitForCompletion(1000, EventCode);
    until EventCode <> 0;

    WriteLn('Encryption completed successfully!');

  finally
    Stop;
  end;
end;

procedure TBasicVideoEncryption.Stop;
begin
  if Assigned(FMediaControl) then
    FMediaControl.Stop;

  FMediaEvent := nil;
  FMediaControl := nil;
  FFilterGraph := nil;
end;

// Usage:
// var
//   Encryptor: TBasicVideoEncryption;
// begin
//   Encryptor := TBasicVideoEncryption.Create;
//   try
//     Encryptor.EncryptVideo('C:\input.mp4', 'C:\output.encrypted.mp4', 'MySecurePassword123');
//   finally
//     Encryptor.Free;
//   end;
// end;
```

---

## Example 2: Video Decryption and Playback

Decrypt an encrypted video file and play it.

### C# Implementation

## ``` public class VideoDecryption { private IFilterGraph2 filterGraph; private IMediaControl mediaControl; private IMediaEventEx mediaEvent; private IVideoWindow videoWindow; public void DecryptAndPlay(string encryptedFile, string password, IntPtr windowHandle) { try { // Create filter graph filterGraph = (IFilterGraph2)new FilterGraph(); mediaControl = (IMediaControl)filterGraph; mediaEvent = (IMediaEventEx)filterGraph; videoWindow = (IVideoWindow)filterGraph; // Add decrypt demuxer filter var decryptDemuxer = (IBaseFilter)Activator.CreateInstance( Type.GetTypeFromCLSID(new Guid("D2C761F0-9988-4f79-9B0E-FB2B79C65851")) ); int hr = filterGraph.AddFilter(decryptDemuxer, "Decrypt Demuxer"); DsError.ThrowExceptionForHR(hr); // Configure decryption (MUST use same password as encryption) var cryptoConfig = decryptDemuxer as IVFCryptoConfig; if (cryptoConfig != null) { // Apply password cryptoConfig.ApplyString(password); // Verify password is set hr = cryptoConfig.HavePassword(); if (hr != 0) { throw new Exception("Failed to set decryption password"); } Console.WriteLine("Decryption password configured successfully"); } else { throw new Exception("IVFCryptoConfig interface not available"); } // Load encrypted file var fileSource = decryptDemuxer as IFileSourceFilter; if (fileSource != null) { hr = fileSource.Load(encryptedFile, null); DsError.ThrowExceptionForHR(hr); } // Build graph - render video and audio outputs ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); hr = captureGraph.SetFiltergraph(filterGraph); DsError.ThrowExceptionForHR(hr); // Render video output hr = captureGraph.RenderStream( null, MediaType.Video, decryptDemuxer, null, null ); DsError.ThrowExceptionForHR(hr); // Render audio output hr = captureGraph.RenderStream( null, MediaType.Audio, decryptDemuxer, null, null ); // Audio is optional, don't fail if not present // Configure video window hr = videoWindow.put_Owner(windowHandle); hr = videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipChildren | WindowStyle.ClipSiblings); hr = videoWindow.put_MessageDrain(windowHandle); Console.WriteLine("Starting playback..."); // Start playback hr = mediaControl.Run(); DsError.ThrowExceptionForHR(hr); Console.WriteLine("Decryption and playback started successfully!"); Marshal.ReleaseComObject(captureGraph); } catch (Exception ex) { Console.WriteLine($"ERROR: {ex.Message}"); throw; } } public void Stop() { if (mediaControl != null) { mediaControl.Stop(); } if (videoWindow != null) { videoWindow.put_Visible(OABool.False); videoWindow.put_Owner(IntPtr.Zero); } if (filterGraph != null) { FilterGraphTools.RemoveAllFilters(filterGraph); } if (videoWindow != null) Marshal.ReleaseComObject(videoWindow); if (mediaEvent != null) Marshal.ReleaseComObject(mediaEvent); if (mediaControl != null) Marshal.ReleaseComObject(mediaControl); if (filterGraph != null) Marshal.ReleaseComObject(filterGraph); } public void SetVideoWindowSize(int width, int height) { if (videoWindow != null) { videoWindow.SetWindowPosition(0, 0, width, height); } } } // Usage: // var decryptor = new VideoDecryption(); // decryptor.DecryptAndPlay(@"C:\output.encrypted.mp4", "MySecurePassword123", this.Handle); ```

## Example 3: Using File as Encryption Key

Use a file's content as the encryption key instead of a password.

### C# Implementation

```
public class FileKeyEncryption
{
    public void EncryptWithFileKey(string inputFile, string outputFile, string keyFile)
    {
        var filterGraph = (IFilterGraph2)new FilterGraph();
        var mediaControl = (IMediaControl)filterGraph;

        try
        {
            // Setup filter graph (source, encoders, muxer)
            // ... (same as Example 1)

            // Add encrypt muxer
            var encryptMuxer = (IBaseFilter)Activator.CreateInstance(
                Type.GetTypeFromCLSID(new Guid("F1D3727A-88DE-49ab-A635-280BEFEFF902"))
            );
            filterGraph.AddFilter(encryptMuxer, "Encrypt Muxer");

            // Configure encryption using file as key
            var cryptoConfig = encryptMuxer as IVFCryptoConfig;
            if (cryptoConfig != null)
            {
                // Use file content as encryption key (SHA-256 hash of file)
                cryptoConfig.ApplyFile(keyFile);

                Console.WriteLine($"Using key file: {keyFile}");
                Console.WriteLine("File content hashed with SHA-256 for encryption");

                // Verify
                int hr = cryptoConfig.HavePassword();
                if (hr == 0)
                {
                    Console.WriteLine("Encryption key configured successfully");
                }
            }

            // Continue with filter graph setup and encoding...
        }
        finally
        {
            // Cleanup
        }
    }

    public void DecryptWithFileKey(string encryptedFile, string keyFile)
    {
        var filterGraph = (IFilterGraph2)new FilterGraph();

        try
        {
            // Add decrypt demuxer
            var decryptDemuxer = (IBaseFilter)Activator.CreateInstance(
                Type.GetTypeFromCLSID(new Guid("D2C761F0-9988-4f79-9B0E-FB2B79C65851"))
            );
            filterGraph.AddFilter(decryptDemuxer, "Decrypt Demuxer");

            // Configure decryption using same key file
            var cryptoConfig = decryptDemuxer as IVFCryptoConfig;
            if (cryptoConfig != null)
            {
                // MUST use same key file as encryption
                cryptoConfig.ApplyFile(keyFile);

                Console.WriteLine($"Using key file for decryption: {keyFile}");
            }

            // Continue with playback setup...
        }
        finally
        {
            // Cleanup
        }
    }
}

// Usage:
// var encryptor = new FileKeyEncryption();
// encryptor.EncryptWithFileKey(@"C:\input.mp4", @"C:\output.encrypted.mp4", @"C:\keys\encryption.key");
// encryptor.DecryptWithFileKey(@"C:\output.encrypted.mp4", @"C:\keys\encryption.key");
```

---

## Example 4: Using Binary Key Data

Generate and use binary key data for encryption.

### C# Implementation

## ``` using System.Security.Cryptography; using System.IO; public class BinaryKeyEncryption { public byte[] GenerateRandomKey(int keySize = 32) { // Generate cryptographically secure random key byte[] key = new byte[keySize]; using (var rng = new RNGCryptoServiceProvider()) { rng.GetBytes(key); } return key; } public void SaveKeyToFile(byte[] key, string keyFile) { File.WriteAllBytes(keyFile, key); Console.WriteLine($"Key saved to: {keyFile}"); } public byte[] LoadKeyFromFile(string keyFile) { return File.ReadAllBytes(keyFile); } public void EncryptWithBinaryKey(string inputFile, string outputFile, byte[] keyData) { var filterGraph = (IFilterGraph2)new FilterGraph(); try { // Setup filter graph and add encrypt muxer var encryptMuxer = (IBaseFilter)Activator.CreateInstance( Type.GetTypeFromCLSID(new Guid("F1D3727A-88DE-49ab-A635-280BEFEFF902")) ); filterGraph.AddFilter(encryptMuxer, "Encrypt Muxer"); // Configure encryption with binary key var cryptoConfig = encryptMuxer as IVFCryptoConfig; if (cryptoConfig != null) { // Apply binary key (will be hashed with SHA-256) cryptoConfig.ApplyBinary(keyData); Console.WriteLine($"Binary key applied (length: {keyData.Length} bytes)"); // Verify int hr = cryptoConfig.HavePassword(); if (hr == 0) { Console.WriteLine("Encryption key configured successfully"); } } // Continue with encoding... } finally { // Cleanup } } public void CompleteWorkflow() { // Generate random encryption key byte[] encryptionKey = GenerateRandomKey(32); Console.WriteLine($"Generated {encryptionKey.Length * 8}-bit encryption key"); // Save key securely string keyFile = @"C:\keys\video_encryption_key.bin"; SaveKeyToFile(encryptionKey, keyFile); // Encrypt video with binary key EncryptWithBinaryKey( @"C:\input.mp4", @"C:\output.encrypted.mp4", encryptionKey ); Console.WriteLine("Video encrypted successfully!"); Console.WriteLine($"Key file: {keyFile}"); Console.WriteLine("Keep this key file secure - it's required for decryption!"); // Later, for decryption: // byte[] key = LoadKeyFromFile(keyFile); // DecryptWithBinaryKey(@"C:\output.encrypted.mp4", key); } } // Usage: // var encryptor = new BinaryKeyEncryption(); // encryptor.CompleteWorkflow(); ```

## Example 5: Encryption with Custom Encoder Settings

Encrypt video with specific H.264 encoding parameters.

### C# Implementation

```
public class CustomEncodingEncryption
{
    public void EncryptWithCustomSettings(
        string inputFile,
        string outputFile,
        string password,
        int videoBitrate = 5000000,
        int audioBitrate = 192000)
    {
        var filterGraph = (IFilterGraph2)new FilterGraph();
        var mediaControl = (IMediaControl)filterGraph;

        try
        {
            // Add source
            filterGraph.AddSourceFilter(inputFile, "Source", out IBaseFilter sourceFilter);

            // Add and configure H.264 encoder
            var videoEncoder = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFH264Encoder,
                "H.264 Encoder"
            );

            // Configure H.264 encoder (if interface available)
            var h264Config = videoEncoder as IH264Encoder;
            if (h264Config != null)
            {
                h264Config.put_Bitrate(videoBitrate);
                h264Config.put_Profile(77); // Main profile
                h264Config.put_Level(41);   // Level 4.1 (1080p)
                h264Config.put_RateControl(1); // CBR
                h264Config.put_GOP(60);     // 2 seconds at 30fps

                Console.WriteLine($"H.264 configured: {videoBitrate / 1000000.0} Mbps, Main profile, Level 4.1");
            }

            // Add and configure AAC encoder
            var audioEncoder = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFAACEncoder,
                "AAC Encoder"
            );

            // Configure AAC encoder (if interface available)
            var aacConfig = audioEncoder as IVFAACEncoder;
            if (aacConfig != null)
            {
                aacConfig.SetBitrate((uint)audioBitrate);
                aacConfig.SetProfile(2); // AAC-LC
                aacConfig.SetOutputFormat(0); // Raw AAC for MP4

                Console.WriteLine($"AAC configured: {audioBitrate / 1000} kbps, AAC-LC profile");
            }

            // Add encrypt muxer
            var encryptMuxer = (IBaseFilter)Activator.CreateInstance(
                Type.GetTypeFromCLSID(new Guid("F1D3727A-88DE-49ab-A635-280BEFEFF902"))
            );
            filterGraph.AddFilter(encryptMuxer, "Encrypt Muxer");

            // Configure encryption
            var cryptoConfig = encryptMuxer as IVFCryptoConfig;
            if (cryptoConfig != null)
            {
                cryptoConfig.ApplyString(password);
                Console.WriteLine("Encryption configured");
            }

            // Set output file
            var fileSink = encryptMuxer as IFileSinkFilter;
            fileSink?.SetFileName(outputFile, null);

            // Build connections
            ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
            captureGraph.SetFiltergraph(filterGraph);

            captureGraph.RenderStream(null, MediaType.Video, sourceFilter, videoEncoder, encryptMuxer);
            captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, audioEncoder, encryptMuxer);

            Console.WriteLine("Starting encoding with custom settings...");

            // Run encoding
            int hr = mediaControl.Run();
            DsError.ThrowExceptionForHR(hr);

            // Wait for completion
            var mediaEvent = (IMediaEventEx)filterGraph;
            EventCode eventCode;
            do
            {
                hr = mediaEvent.WaitForCompletion(1000, out eventCode);
            }
            while (eventCode == 0);

            Console.WriteLine("Encoding and encryption completed!");

            Marshal.ReleaseComObject(captureGraph);
        }
        finally
        {
            // Cleanup
            mediaControl?.Stop();
            FilterGraphTools.RemoveAllFilters(filterGraph);
        }
    }
}

// Usage:
// var encryptor = new CustomEncodingEncryption();
// encryptor.EncryptWithCustomSettings(
//     @"C:\input.mp4",
//     @"C:\output.encrypted.mp4",
//     "MySecurePassword123",
//     videoBitrate: 8000000,  // 8 Mbps
//     audioBitrate: 256000    // 256 kbps
// );
```

---

## Example 6: Error Handling and Validation

Comprehensive error handling for encryption/decryption.

### C# Implementation

## ``` public class RobustEncryption { private IFilterGraph2 filterGraph; private IMediaControl mediaControl; public enum EncryptionResult { Success, FileNotFound, InvalidPassword, InterfaceNotAvailable, FilterGraphError, EncodingError, Unknown } public EncryptionResult EncryptVideoSafely( string inputFile, string outputFile, string password) { try { // Validate inputs if (string.IsNullOrEmpty(inputFile)) { Console.WriteLine("ERROR: Input file path is empty"); return EncryptionResult.FileNotFound; } if (!File.Exists(inputFile)) { Console.WriteLine($"ERROR: Input file not found: {inputFile}"); return EncryptionResult.FileNotFound; } if (string.IsNullOrEmpty(password)) { Console.WriteLine("ERROR: Password is empty"); return EncryptionResult.InvalidPassword; } if (password.Length < 8) { Console.WriteLine("WARNING: Password is less than 8 characters (not recommended)"); } Console.WriteLine("Input validation passed"); // Create filter graph filterGraph = (IFilterGraph2)new FilterGraph(); if (filterGraph == null) { Console.WriteLine("ERROR: Failed to create filter graph"); return EncryptionResult.FilterGraphError; } mediaControl = (IMediaControl)filterGraph; // Add source filter int hr = filterGraph.AddSourceFilter(inputFile, "Source", out IBaseFilter sourceFilter); if (hr != 0 || sourceFilter == null) { Console.WriteLine($"ERROR: Failed to add source filter (HRESULT: 0x{hr:X8})"); return EncryptionResult.FilterGraphError; } // Add encoders var videoEncoder = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFH264Encoder, "H.264 Encoder" ); if (videoEncoder == null) { Console.WriteLine("ERROR: Failed to create video encoder"); return EncryptionResult.FilterGraphError; } var audioEncoder = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFAACEncoder, "AAC Encoder" ); // Add encrypt muxer var encryptMuxer = (IBaseFilter)Activator.CreateInstance( Type.GetTypeFromCLSID(new Guid("F1D3727A-88DE-49ab-A635-280BEFEFF902")) ); if (encryptMuxer == null) { Console.WriteLine("ERROR: Failed to create encrypt muxer"); return EncryptionResult.FilterGraphError; } hr = filterGraph.AddFilter(encryptMuxer, "Encrypt Muxer"); if (hr != 0) { Console.WriteLine($"ERROR: Failed to add encrypt muxer (HRESULT: 0x{hr:X8})"); return EncryptionResult.FilterGraphError; } // Configure encryption var cryptoConfig = encryptMuxer as IVFCryptoConfig; if (cryptoConfig == null) { Console.WriteLine("ERROR: IVFCryptoConfig interface not available"); return EncryptionResult.InterfaceNotAvailable; } try { cryptoConfig.ApplyString(password); } catch (Exception ex) { Console.WriteLine($"ERROR: Failed to apply password: {ex.Message}"); return EncryptionResult.InvalidPassword; } // Verify password is set hr = cryptoConfig.HavePassword(); if (hr != 0) { Console.WriteLine("ERROR: Password verification failed"); return EncryptionResult.InvalidPassword; } Console.WriteLine("Encryption password configured successfully"); // Set output file var fileSink = encryptMuxer as IFileSinkFilter; if (fileSink != null) { hr = fileSink.SetFileName(outputFile, null); if (hr != 0) { Console.WriteLine($"ERROR: Failed to set output file (HRESULT: 0x{hr:X8})"); return EncryptionResult.FilterGraphError; } } // Build filter graph ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); hr = captureGraph.SetFiltergraph(filterGraph); hr = captureGraph.RenderStream( null, MediaType.Video, sourceFilter, videoEncoder, encryptMuxer ); if (hr != 0) { Console.WriteLine($"WARNING: Video connection failed (HRESULT: 0x{hr:X8})"); } hr = captureGraph.RenderStream( null, MediaType.Audio, sourceFilter, audioEncoder, encryptMuxer ); if (hr != 0) { Console.WriteLine($"WARNING: Audio connection failed (HRESULT: 0x{hr:X8}) - continuing without audio"); } Console.WriteLine("Filter graph built successfully"); Console.WriteLine("Starting encryption..."); // Start encoding hr = mediaControl.Run(); if (hr != 0) { Console.WriteLine($"ERROR: Failed to start encoding (HRESULT: 0x{hr:X8})"); return EncryptionResult.EncodingError; } // Monitor progress var mediaEvent = (IMediaEventEx)filterGraph; EventCode eventCode; long param1, param2; do { hr = mediaEvent.GetEvent(out eventCode, out param1, out param2, 1000); if (hr == 0) { mediaEvent.FreeEventParams(eventCode, param1, param2); if (eventCode == EventCode.Complete) { break; } else if (eventCode == EventCode.ErrorAbort) { Console.WriteLine($"ERROR: Encoding aborted (event code: {eventCode})"); return EncryptionResult.EncodingError; } } } while (true); Console.WriteLine("Encryption completed successfully!"); // Verify output file exists if (File.Exists(outputFile)) { FileInfo fi = new FileInfo(outputFile); Console.WriteLine($"Output file created: {outputFile}"); Console.WriteLine($"File size: {fi.Length / (1024.0 * 1024.0):F2} MB"); } else { Console.WriteLine("WARNING: Output file not found after encoding"); } Marshal.ReleaseComObject(captureGraph); return EncryptionResult.Success; } catch (Exception ex) { Console.WriteLine($"EXCEPTION: {ex.Message}"); Console.WriteLine($"Stack trace: {ex.StackTrace}"); return EncryptionResult.Unknown; } finally { Cleanup(); } } private void Cleanup() { try { if (mediaControl != null) { mediaControl.Stop(); Marshal.ReleaseComObject(mediaControl); } if (filterGraph != null) { FilterGraphTools.RemoveAllFilters(filterGraph); Marshal.ReleaseComObject(filterGraph); } } catch (Exception ex) { Console.WriteLine($"Cleanup error: {ex.Message}"); } } } // Usage: // var encryptor = new RobustEncryption(); // var result = encryptor.EncryptVideoSafely( // @"C:\input.mp4", // @"C:\output.encrypted.mp4", // "MySecurePassword123" // ); // // if (result == RobustEncryption.EncryptionResult.Success) // { // Console.WriteLine("SUCCESS!"); // } // else // { // Console.WriteLine($"FAILED: {result}"); // } ```

## Best Practices

### Password Security

1. **Use Strong Passwords**
2. Minimum 16 characters
3. Mix of uppercase, lowercase, numbers, symbols
4. Avoid dictionary words
5. Use password managers to generate/store
6. **Key Storage**
7. Never hardcode passwords in source code
8. Use secure key storage (Windows DPAPI, KeyVault, etc.)
9. Implement proper access controls
10. **Key Distribution**
11. Use secure channels for key distribution
12. Consider public-key encryption for key exchange
13. Implement key rotation policies

### Implementation Security

**GOOD: Secure password handling**

```
public void SetEncryptionPassword(IVFCryptoConfig config)
{
    // Get password from secure storage
    string password = SecureStorage.GetPassword();

    try
    {
        config.ApplyString(password);
    }
    finally
    {
        // Clear password from memory
        password = null;
        GC.Collect();
    }
}
```

**BAD: Hardcoded password**

```
public void SetEncryptionPassword(IVFCryptoConfig config)
{
    config.ApplyString("MyPassword123"); // DON'T DO THIS!
}
```

### File Security

- Use appropriate file permissions for encrypted files
- Implement secure deletion for temporary files
- Consider encrypting key files with additional encryption
- Log access to encrypted content for audit trails

### Implementation Guidelines

1. **Always Validate Inputs**
2. Check file existence before processing
3. Validate password is not empty
4. Verify filter interfaces are available
5. **Error Handling**
6. Check HRESULT values from COM calls
7. Use try-catch blocks for exceptions
8. Provide meaningful error messages
9. **Resource Management**
10. Always release COM objects
11. Use `finally` blocks for cleanup
12. Stop filter graph before releasing
13. **Testing**
14. Test with various input formats
15. Verify encrypted files can be decrypted
16. Test error conditions (wrong password, etc.)

---

## Troubleshooting

### Common Error Codes

| HRESULT | Description | Solution |
| --- | --- | --- |
| `E_INVALIDARG` | Invalid buffer or size | Check buffer pointer and size parameters |
| `E_POINTER` | Null pointer | Ensure pointers are valid before calling |
| `E_FAIL` | General failure | Check filter state and configuration |
| `S_FALSE` | No password set | Call `put_Password` before `HavePassword` |
| ### Error Handling Example |  |  |
| ``` public bool ConfigureEncryption(IBaseFilter muxer, string password) {     var cryptoConfig = muxer as IVFCryptoConfig;     if (cryptoConfig == null)     {         Console.WriteLine("ERROR: Filter does not support IVFCryptoConfig");         return false;     }     try     {         // Set password         cryptoConfig.ApplyString(password);         // Verify         int hr = cryptoConfig.HavePassword();         if (hr != 0)         {             Console.WriteLine("ERROR: Password not set correctly");             return false;         }         Console.WriteLine("Encryption configured successfully");         return true;     }     catch (Exception ex)     {         Console.WriteLine($"ERROR: Failed to configure encryption: {ex.Message}");         return false;     } } ``` |  |  |
| --- |  |  |

### Common Issues

#### "Filter not registered" Error

**Problem**: CLSID not found

**Solution**:

```
# Register filters (run as Administrator)
regsvr32 "C:\Path\To\EncryptMuxer.ax"
regsvr32 "C:\Path\To\DecryptDemuxer.ax"
```

#### "Interface not available" Error

**Problem**: Cannot query IVFCryptoConfig

**Solution**: - Verify filter version is correct - Check filter is properly registered - Ensure COM interfaces are compatible

#### Decryption Fails with Garbled Video

**Problem**: Wrong password used for decryption

**Solution**: - Verify same password is used for encryption and decryption - Check password encoding (Unicode vs. ANSI) - Ensure no typos in password

#### Output File is Empty or Corrupt

**Problem**: Encoding failed silently

**Solution**: - Check all encoder filters are properly connected - Verify encoder configurations are valid - Monitor IMediaEventEx for error events - Check disk space is available

---

## See Also

- [Video Encryption SDK Overview](../) - Product features
- [Interface Reference](../interface-reference/) - Complete API documentation
- [DirectShow Encoding Filters Pack](../../filters-enc/) - Compatible encoders
- [GitHub Samples](https://github.com/visioforge/directshow-samples/tree/main/Video%20Encryption%20SDK) - Complete source code

---END OF PAGE---


## AES-256 Video Encryption Using DirectShow COM Filters
**URL:** https://www.visioforge.com/help/docs/directshow/video-encryption-sdk/
**Description:** Encrypt H.264/AAC MP4 video with AES-256 using DirectShow filters. VisioForge SDK with password and binary key modes for C++, C#, and Delphi.
**Tags:** Video Encryption SDK, DirectShow, C++, Windows
**API:** IVFCryptoConfig, IVFPasswordProvider

# Video Encryption SDK

## Introduction to Video Encryption

The [Video Encryption SDK](https://www.visioforge.com/video-encryption-sdk) provides robust tools for encoding video files into MP4 H264/AAC format with advanced encryption capabilities. Developers can secure their media content using custom passwords or binary data encryption methods.

The SDK integrates seamlessly with any DirectShow application through a complete set of filters. These filters come with extensive interfaces allowing developers to fine-tune settings according to specific security requirements and implementation needs.

---

## Installation

Before using the code samples and integrating the SDK into your application, you must first install the Video Encryption SDK from the [product page](https://www.visioforge.com/video-encryption-sdk).

**Installation Steps**:

1. Download the SDK installer from the product page
2. Run the installer with administrative privileges
3. The installer will register all necessary DirectShow filters
4. Sample applications and source code will be available in the installation directory

**Note**: The SDK filters must be properly registered on the system before they can be used in your applications. The installer handles this automatically.

---

## Integration Flexibility

You can implement the SDK in various DirectShow applications as filters for both encryption and decryption processes. The system works effectively with:

- Live video sources
- File-based video sources
- Software video encoders
- GPU-accelerated video encoders from the [DirectShow Encoding Filters pack](https://www.visioforge.com/encoding-filters-pack) (available separately)
- Third-party DirectShow filters for additional video encoding options

## Key Features and Capabilities

### Core Functionality

- **Secure Encryption/Decryption**: Process video files or capture streams with robust security algorithms
- **Format Support**: Full H264 encoder support for video content
- **Audio Handling**: Complete AAC encoder support for audio streams
- **Flexible Security Options**: Implement encryption using either binary data or string passwords

### Performance Optimization

- AES-256 encryption engine for maximum security
- CPU hardware acceleration support
- GPU acceleration compatibility
- Optimized for high-speed encryption processes

## Development Resources

### Code Samples and Documentation

The SDK includes comprehensive code samples for multiple programming languages:

- C# implementation examples
- C++ reference code
- Delphi sample projects

These samples provide practical implementation guidance for developers building secure video applications.

### Demo Application

Explore the included Video Encryptor application for a hands-on demonstration of the SDK's capabilities in a working environment.

---

## API Reference

### Core Interfaces

The SDK provides comprehensive COM interfaces for encryption and decryption:

#### IVFCryptoConfig

Primary interface for configuring encryption settings on the muxer filter (encryption) and demuxer filter (decryption).

**GUID**: `{BAA5BD1E-3B30-425e-AB3B-CC20764AC253}`

**Methods**: - `put_Provider` - Set password provider for advanced scenarios (binary keys, dynamic passwords) - `get_Provider` - Get password provider interface - `put_Password` - Set encryption password or key directly (binary data) - `HavePassword` - Check if password is set

#### IVFPasswordProvider

Callback interface for advanced password provision scenarios such as binary data keys, dynamic password generation, or custom key derivation.

**GUID**: `{6F8162B5-778D-42b5-9242-1BBABB24FFC4}`

**Methods**: - `QueryPassword` - Query password for specific file

**Use Cases**: - Binary key data provision - Dynamic password generation - File-specific encryption keys - Custom key derivation functions

#### Helper Classes

The SDK includes helper extension methods for .NET developers: - `ApplyString` - Apply string password (hashed with SHA-256) - `ApplyFile` - Use file as encryption key (SHA-256 hash of file content) - `ApplyBinary` - Apply binary key data (hashed with SHA-256)

### Filter CLSIDs

| Filter | CLSID | Purpose |
| --- | --- | --- |
| **Encrypt Muxer** | `{F1D3727A-88DE-49ab-A635-280BEFEFF902}` | Muxer with encryption |
| **Decrypt Demuxer** | `{D2C761F0-9988-4f79-9B0E-FB2B79C65851}` | Demuxer with decryption |

For detailed interface documentation and code examples, see the [Interface Reference](interface-reference/).

---

## Code Examples

### Quick Start - Encryption

#### C# Example

```
using VisioForge.DirectShowAPI;

// Get crypto config interface from encrypt muxer
var cryptoConfig = muxerFilter as IVFCryptoConfig;
if (cryptoConfig != null)
{
    // Apply string password
    cryptoConfig.ApplyString("MySecurePassword123");

    // Or use file as key
    // cryptoConfig.ApplyFile(@"C:\keys\mykey.bin");

    // Or use binary data
    // byte[] keyData = new byte[] { 0x01, 0x02, 0x03, ... };
    // cryptoConfig.ApplyBinary(keyData);
}
```

#### C++ Example

```
#include "encryptor_intf.h"

ICryptoConfig* pCrypto = nullptr;
hr = pMuxer->QueryInterface(IID_ICryptoConfig, (void**)&pCrypto);
if (SUCCEEDED(hr))
{
    // Set password
    const wchar_t* password = L"MySecurePassword123";
    hr = pCrypto->put_Password(
        (LPBYTE)password,
        wcslen(password) * sizeof(wchar_t)
    );

    pCrypto->Release();
}
```

### Decryption

#### C# Example

```
// Get crypto config interface from decrypt demuxer
var cryptoConfig = demuxerFilter as IVFCryptoConfig;
if (cryptoConfig != null)
{
    // Must use same password/key as encryption
    cryptoConfig.ApplyString("MySecurePassword123");
}
```

For complete examples including filter graph setup, see the [Examples Page](examples/).

---

## Sample Applications

The SDK includes working sample applications demonstrating encryption and decryption workflows:

### Included Samples

- **Encryption Demo** - Demonstrates video file encryption with H.264/AAC encoding
- **Player Demo** - Shows decryption and playback of encrypted video files

### GitHub Repository

Complete source code for all samples is available: - [Video Encryption SDK Samples](https://github.com/visioforge/directshow-samples/tree/main/Video%20Encryption%20SDK) - C#, C++, and Delphi examples

These samples include: - Complete filter graph construction - Encryption configuration - Decryption and playback - Error handling - Best practices implementation

---

## Licensing Information

- [End User License Agreement](../../eula/)

## Version History

### Version 11.4

- Full compatibility with VisioForge .Net SDKs 11.4
- Enhanced Nvidia NVENC support for H264 and H265 video encoders
- Improved Intel QuickSync support for H264 video encoder
- Added NV12 colorspace support for enhanced performance

### Version 11.0

- Complete compatibility with VisioForge .Net SDKs 11.0
- Enhanced GPU encoders support
- Upgraded AAC encoder functionality

### Version 10.0

- Full compatibility with VisioForge .Net SDKs 10.0
- Enhanced compatibility with H264 and H265 video formats
- Integrated AMD AMF acceleration support
- Added Intel QuickSync technology support

### Version 9.0

- Significantly improved encryption processing speed
- Added CPU hardware acceleration capabilities
- Implemented new engine based on AES-256 encryption
- Added file usage as a key (with binary array support)
- Integrated NVENC support for GPU acceleration
- Enhanced AAC HE encoder support

### Version 8.0

- Updated video and audio encoders
- Improved filter encryption performance

### Version 7.0

- Initial release as a standalone product
- Previously integrated within Video Capture SDK, Video Edit SDK, and Media Player SDK
- Compatible with any DirectShow application without requiring additional VisioForge SDKs

---

## Resources

- [Product Page](https://www.visioforge.com/video-encryption-sdk) - Purchase, licensing, and product information
- [Sample Applications](https://github.com/visioforge/directshow-samples/tree/main/Video%20Encryption%20SDK) - Complete source code examples

---

## See Also

- [Interface Reference](interface-reference/) - Complete API documentation
- [Examples](examples/) - Comprehensive code examples for encryption and decryption
- [DirectShow Encoding Filters Pack](../filters-enc/) - Compatible video encoders (H.264, H.265, AAC)

---END OF PAGE---


## IVFCryptoConfig COM Interface - Video Encryption API
**URL:** https://www.visioforge.com/help/docs/directshow/video-encryption-sdk/interface-reference/
**Description:** IVFCryptoConfig and IVFPasswordProvider COM interfaces for AES-256 video encryption in DirectShow. Methods, GUIDs, and usage for C++, C#, Delphi.
**Tags:** Video Encryption SDK, DirectShow, C++, Windows, C#
**API:** IVFCryptoConfig, IVFPasswordProvider, IBaseFilter, MuxerFilter

# Video Encryption SDK - Interface Reference

## Overview

The Video Encryption SDK provides COM interfaces for encrypting and decrypting MP4 video files with AES-256 encryption. This reference covers all interfaces, methods, and helper classes for C++, C#, and Delphi developers.

---

## IVFCryptoConfig Interface

Primary interface for configuring encryption passwords and keys on both the encryption muxer and decryption demuxer filters.

### Interface GUID

```
{BAA5BD1E-3B30-425e-AB3B-CC20764AC253}
```

### Inheritance

## Inherits from `IUnknown`

### Interface Definitions

#### C++ Definition

```
#include "encryptor_intf.h"

// {BAA5BD1E-3B30-425e-AB3B-CC20764AC253}
DEFINE_GUID(IID_ICryptoConfig,
    0xbaa5bd1e, 0x3b30, 0x425e, 0xab, 0x3b, 0xcc, 0x20, 0x76, 0x4a, 0xc2, 0x53);

DECLARE_INTERFACE_(ICryptoConfig, IUnknown)
{
    STDMETHOD(put_Provider)(THIS_ IPasswordProvider* pProvider) PURE;
    STDMETHOD(get_Provider)(THIS_ IPasswordProvider** ppProvider) PURE;
    STDMETHOD(put_Password)(THIS_ LPBYTE pBuffer, LONG lSize) PURE;
    STDMETHOD(HavePassword)(THIS_) PURE;
};
```

#### C# Definition

```
using System;
using System.Runtime.InteropServices;

[ComImport]
[Guid("BAA5BD1E-3B30-425e-AB3B-CC20764AC253")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IVFCryptoConfig
{
    // NOTE: put_Provider / get_Provider are stubs in the managed wrapper —
    // the parameter is literally named `passwordProviderNotUsed` because the
    // .NET marshaling for IVFPasswordProvider is not wired up. From C# call
    // put_Password directly with the binary key bytes.
    [PreserveSig]
    int put_Provider([In] IVFPasswordProvider passwordProviderNotUsed);

    [PreserveSig]
    int get_Provider([Out] IVFPasswordProvider passwordProviderNotUsed);

    [PreserveSig]
    int put_Password(IntPtr buffer, [In] int size);

    [PreserveSig]
    int HavePassword();
}
```

C# password provider not supported

The managed `put_Provider` / `get_Provider` wrappers are **non-functional stubs** (note the `passwordProviderNotUsed` parameter name). To set passwords from C#, call `put_Password` with the raw key bytes via `IntPtr` (or use the `ApplyString` helper). Custom `IVFPasswordProvider` callbacks must be implemented from C++ or Delphi.

#### Delphi Definition

```
type
  IVFCryptoConfig = interface(IUnknown)
    ['{BAA5BD1E-3B30-425e-AB3B-CC20764AC253}']
    function put_Provider(pProvider: IUnknown): HRESULT; stdcall;
    function get_Provider(out pProvider: IUnknown): HRESULT; stdcall;
    function put_Password(pBuffer: PByte; lSize: Integer): HRESULT; stdcall;
    function HavePassword(): HRESULT; stdcall;
  end;
```

Naming across language wrappers

The native C++ header (`encryptor_intf.h`) uses `ICryptoConfig` / `IPasswordProvider`. The C# and Delphi wrappers expose the same interface as `IVFCryptoConfig` / `IVFPasswordProvider`. Both names refer to the **same** GUID `{BAA5BD1E-3B30-425e-AB3B-CC20764AC253}`.

---

### Methods

#### put\_Provider

Sets a password provider callback interface for advanced encryption scenarios. **C++ Syntax**:

```
HRESULT put_Provider(IPasswordProvider* pProvider);
```

**C# Syntax**:

```
int put_Provider(IVFPasswordProvider passwordProvider);
```

**Parameters**: - `pProvider` / `passwordProvider` - Password provider interface that implements `IVFPasswordProvider` **Return Value**: - `S_OK` (0) on success - Error HRESULT on failure **Remarks**: Use this method for advanced scenarios where you need: - Dynamic password generation based on file name - Binary key data provision through a callback - Custom key derivation functions - File-specific encryption keys - Per-file password policies For simple string passwords, using `put_Password` directly is more straightforward. The password provider is useful when you need runtime password determination or when implementing a custom key management system. **Example Use Cases**: 1. **Binary Key Provider**: Provide 256-bit encryption keys from a key management system 2. **Dynamic Passwords**: Generate different passwords based on file names or metadata 3. **Key Derivation**: Implement custom key derivation functions (PBKDF2, Argon2, etc.) 4. **Secure Storage Integration**: Retrieve keys from hardware security modules (HSM) or key vaults

---

#### get\_Provider

Gets the currently set password provider interface.

**C++ Syntax**:

```
HRESULT get_Provider(IPasswordProvider** ppProvider);
```

**C# Syntax**:

```
int get_Provider(IVFPasswordProvider passwordProvider);
```

**Parameters**: - `ppProvider` / `passwordProvider` - Pointer to receive password provider interface

**Return Value**: - `S_OK` (0) on success - `E_POINTER` if ppProvider is NULL - Error HRESULT on failure

**Remarks**: Retrieves the password provider interface that was previously set with `put_Provider`. Returns NULL if no provider has been set.

---

#### put\_Password

Sets the encryption password or binary key data. **C++ Syntax**:

```
HRESULT put_Password(LPBYTE pBuffer, LONG lSize);
```

**C# Syntax**:

```
int put_Password(IntPtr buffer, int size);
```

**Delphi Syntax**:

```
function put_Password(pBuffer: PByte; lSize: Integer): HRESULT; stdcall;
```

**Parameters**: - `pBuffer` / `buffer` - Pointer to password or binary key data - `lSize` / `size` - Size of buffer in bytes **Return Value**: - `S_OK` (0) on success - `E_INVALIDARG` if buffer is null or size is invalid - Error HRESULT on failure **Remarks**: - The SDK uses AES-256 encryption, which requires a 256-bit (32-byte) key - If you provide a password string, it should be hashed to 256 bits (use SHA-256) - The same password/key must be used for both encryption and decryption - For string passwords, use the helper methods (C# only) or hash manually - Binary data is hashed with SHA-256 internally to generate the encryption key **Example (C++)**:

```
ICryptoConfig* pCrypto = nullptr;
hr = pMuxer->QueryInterface(IID_ICryptoConfig, (void**)&pCrypto);
if (SUCCEEDED(hr))
{
    // Using string password (must convert to proper format)
    const wchar_t* password = L"MySecurePassword123";
    hr = pCrypto->put_Password(
        (LPBYTE)password,
        wcslen(password) * sizeof(wchar_t)
    );
    pCrypto->Release();
}
```

**Example (C#)**:

```
var cryptoConfig = muxerFilter as IVFCryptoConfig;
if (cryptoConfig != null)
{
    // Using helper method (recommended)
    cryptoConfig.ApplyString("MySecurePassword123");
    // Or manually with IntPtr
    string password = "MySecurePassword123";
    IntPtr ptr = Marshal.StringToCoTaskMemUni(password);
    try
    {
        cryptoConfig.put_Password(ptr, password.Length * 2);
    }
    finally
    {
        Marshal.FreeCoTaskMem(ptr);
    }
}
```

**Example (Delphi)**:

```
var
  CryptoConfig: IVFCryptoConfig;
  Password: WideString;
begin
  if Supports(MuxerFilter, IVFCryptoConfig, CryptoConfig) then
  begin
    Password := 'MySecurePassword123';
    // pBuffer is opaque binary data (LPBYTE); cast the wide-string pointer to PByte
    // and pass byte length (UTF-16 chars * 2).
    CryptoConfig.put_Password(PByte(PWideChar(Password)), Length(Password) * 2);
  end;
end;
```

---

#### HavePassword

Checks whether a password has been set on the filter.

**C++ Syntax**:

```
HRESULT HavePassword();
```

**C# Syntax**:

```
int HavePassword();
```

**Delphi Syntax**:

```
function HavePassword(): HRESULT; stdcall;
```

**Parameters**: None

**Return Value**: - `S_OK` (0) if password is set - `S_FALSE` (1) if no password is set - Error HRESULT on failure

**Remarks**: Use this method to verify that a password has been configured before starting the filter graph.

**Example (C++)**:

```
ICryptoConfig* pCrypto = nullptr;
hr = pMuxer->QueryInterface(IID_ICryptoConfig, (void**)&pCrypto);
if (SUCCEEDED(hr))
{
    HRESULT hrPassword = pCrypto->HavePassword();
    if (hrPassword == S_OK)
    {
        // Password is set, can start encoding
    }
    else
    {
        // No password set
        MessageBox(NULL, L"Please set encryption password", L"Error", MB_OK);
    }

    pCrypto->Release();
}
```

**Example (C#)**:

```
var cryptoConfig = muxerFilter as IVFCryptoConfig;
if (cryptoConfig != null)
{
    int hr = cryptoConfig.HavePassword();
    if (hr == 0) // S_OK
    {
        // Password is set
        Console.WriteLine("Password configured successfully");
    }
    else
    {
        // No password
        Console.WriteLine("Warning: No password set");
    }
}
```

---

## IVFPasswordProvider Interface

Callback interface for advanced password provision scenarios including binary key data, dynamic password generation, and custom key derivation functions.

### Interface GUID

```
{6F8162B5-778D-42b5-9242-1BBABB24FFC4}
```

### Inheritance

## Inherits from `IUnknown`

### Interface Definitions

#### C++ Definition

```
// {6F8162B5-778D-42b5-9242-1BBABB24FFC4}
DEFINE_GUID(IID_IPasswordProvider,
    0x6f8162b5, 0x778d, 0x42b5, 0x92, 0x42, 0x1b, 0xba, 0xbb, 0x24, 0xff, 0xc4);

DECLARE_INTERFACE_(IPasswordProvider, IUnknown)
{
    STDMETHOD(QueryPassword)(
        THIS_
        LPCWSTR pszFileName,
        LPBYTE pBuffer,
        LONG* plSize
    ) PURE;
};
```

#### C# Definition

```
[ComImport]
[Guid("6F8162B5-778D-42b5-9242-1BBABB24FFC4")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IVFPasswordProvider
{
    [PreserveSig]
    int QueryPassword(
        [MarshalAs(UnmanagedType.LPWStr)] string pszFileName,
        [In, Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] pBuffer,
        [In, Out] ref int plSize
    );
}
```

---

### Methods

#### QueryPassword

Called by the filter to query the password or binary key data for a specific file. **C++ Syntax**:

```
HRESULT QueryPassword(
    LPCWSTR pszFileName,
    LPBYTE pBuffer,
    LONG* plSize
);
```

**C# Syntax**:

```
int QueryPassword(
    string pszFileName,
    byte[] pBuffer,
    ref int plSize
);
```

**Parameters**: - `pszFileName` - File name for which password is requested (can be used to determine file-specific keys) - `pBuffer` - Buffer to receive password data or binary key - `plSize` - Pointer to buffer size (input: max buffer size, output: actual data size returned) **Return Value**: - `S_OK` (0) if password provided successfully - `E_OUTOFMEMORY` if buffer is too small (set plSize to required size) - Error HRESULT on failure **Remarks**: Implement this interface to: - Provide binary key data (256-bit keys for AES-256) - Generate file-specific encryption keys based on file name - Retrieve keys from external key management systems - Implement custom password derivation logic For simple scenarios with a single password for all files, using `IVFCryptoConfig::put_Password` directly is more straightforward. **Implementation Example (C#)**:

```
public class CustomPasswordProvider : IVFPasswordProvider
{
    public int QueryPassword(string pszFileName, byte[] pBuffer, ref int plSize)
    {
        // Generate file-specific key
        byte[] key = GenerateKeyForFile(pszFileName);
        if (pBuffer == null || plSize < key.Length)
        {
            plSize = key.Length;
            return unchecked((int)0x8007000E); // E_OUTOFMEMORY
        }
        Array.Copy(key, pBuffer, key.Length);
        plSize = key.Length;
        return 0; // S_OK
    }
    private byte[] GenerateKeyForFile(string fileName)
    {
        // Custom key generation logic
        using (var sha256 = SHA256.Create())
        {
            string seed = "MySalt" + fileName;
            return sha256.ComputeHash(Encoding.UTF8.GetBytes(seed));
        }
    }
}
```

---

## C# Helper Methods

The SDK provides convenient extension methods for C# developers in the `VFCryptoConfigHelper` class.

### ApplyString

Applies a string password with automatic SHA-256 hashing.

**Syntax**:

```
public static int ApplyString(this IVFCryptoConfig cryptoConfig, string key)
```

**Parameters**: - `cryptoConfig` - The IVFCryptoConfig interface instance - `key` - String password to apply

**Return Value**: - `0` on success - Throws `Exception` if key is null or empty

**Remarks**: - Automatically converts string to Unicode and applies SHA-256 hashing - Most common method for setting passwords - Ensures consistent password format across encryption/decryption

**Example**:

```
var cryptoConfig = muxerFilter as IVFCryptoConfig;
if (cryptoConfig != null)
{
    cryptoConfig.ApplyString("MySecurePassword123");
}
```

---

### ApplyFile

Uses a file's content as the encryption key (SHA-256 hash of file). **Syntax**:

```
public static int ApplyFile(this IVFCryptoConfig cryptoConfig, string key)
```

**Parameters**: - `cryptoConfig` - The IVFCryptoConfig interface instance - `key` - Path to file to use as encryption key **Return Value**: - `0` on success - Throws `FileNotFoundException` if file doesn't exist - Throws `Exception` if key is null or empty **Remarks**: - Reads entire file content and computes SHA-256 hash - Useful for using key files or certificates as encryption keys - File content is never stored, only the hash - Same file must be used for both encryption and decryption **Example**:

```
var cryptoConfig = muxerFilter as IVFCryptoConfig;
if (cryptoConfig != null)
{
    cryptoConfig.ApplyFile(@"C:\keys\encryption.key");
}
```

**Security Note**: - Store key files securely - Use appropriate file permissions - Consider using dedicated key storage systems for production

---

### ApplyBinary

Applies binary key data with automatic SHA-256 hashing.

**Syntax**:

```
public static int ApplyBinary(this IVFCryptoConfig cryptoConfig, byte[] key)
```

**Parameters**: - `cryptoConfig` - The IVFCryptoConfig interface instance - `key` - Binary key data (any length)

**Return Value**: - `0` on success - Throws `Exception` if key is null or empty

**Remarks**: - Accepts binary key data of any length - Automatically computes SHA-256 hash to generate 256-bit key - Useful for programmatically generated keys or key derivation

**Example**:

```
var cryptoConfig = muxerFilter as IVFCryptoConfig;
if (cryptoConfig != null)
{
    // Generate random key
    byte[] keyData = new byte[32];
    using (var rng = new RNGCryptoServiceProvider())
    {
        rng.GetBytes(keyData);
    }

    // Apply binary key
    cryptoConfig.ApplyBinary(keyData);

    // Store keyData securely for later decryption
    SaveKeyToSecureStorage(keyData);
}
```

---

## Filter CLSIDs

### Encrypt Muxer Filter

Muxes video and audio streams into encrypted format. **CLSID**:

```
// {F1D3727A-88DE-49ab-A635-280BEFEFF902}
DEFINE_GUID(CLSID_EncryptMuxer,
    0xf1d3727a, 0x88de, 0x49ab, 0xa6, 0x35, 0x28, 0xb, 0xef, 0xef, 0xf9, 0x2);
```

**Usage (C++)**:

```
IBaseFilter* pMuxer = nullptr;
hr = CoCreateInstance(
    CLSID_EncryptMuxer,
    NULL,
    CLSCTX_INPROC_SERVER,
    IID_IBaseFilter,
    (void**)&pMuxer
);
```

**Usage (C#)**:

```
var muxerFilter = (IBaseFilter)Activator.CreateInstance(
    Type.GetTypeFromCLSID(new Guid("F1D3727A-88DE-49ab-A635-280BEFEFF902"))
);
```

---

### Decrypt Demuxer Filter

Demuxes and decrypts encrypted files.

**CLSID**:

```
// {D2C761F0-9988-4f79-9B0E-FB2B79C65851}
DEFINE_GUID(CLSID_EncryptDemuxer,
    0xd2c761f0, 0x9988, 0x4f79, 0x9b, 0xe, 0xfb, 0x2b, 0x79, 0xc6, 0x58, 0x51);
```

**Usage (C++)**:

```
IBaseFilter* pDemuxer = nullptr;
hr = CoCreateInstance(
    CLSID_EncryptDemuxer,
    NULL,
    CLSCTX_INPROC_SERVER,
    IID_IBaseFilter,
    (void**)&pDemuxer
);
```

**Usage (C#)**:

```
var demuxerFilter = (IBaseFilter)Activator.CreateInstance(
    Type.GetTypeFromCLSID(new Guid("D2C761F0-9988-4f79-9B0E-FB2B79C65851"))
);
```

---

## See Also

- [Video Encryption SDK Overview](../) - Product features and capabilities
- [Examples](../examples/) - Complete code examples
- [DirectShow Encoding Filters Pack](../../filters-enc/) - Compatible encoders

---END OF PAGE---


## Virtual Camera DirectShow Examples - C++, C#, VB.NET
**URL:** https://www.visioforge.com/help/docs/directshow/virtual-camera-sdk/examples/
**Description:** Stream video to virtual camera devices and capture from them in DirectShow. Code examples for frame rendering, real-time effects, and multi-instance setup.
**Tags:** Virtual Camera SDK, DirectShow, C++, Windows, WinForms, Streaming, Virtual Camera, Webcam, C#
**API:** IBaseFilter, IVFLiveVideoSource, IVFVirtualCameraSink, IVFVirtualCameraSource

# Virtual Camera SDK - Code Examples

## Overview

This page provides practical code examples for using the Virtual Camera SDK. The SDK enables you to:

- **Write TO virtual camera**: Stream video from files, real cameras, or individual frames to virtual camera devices
- **Read FROM virtual camera**: Capture video from virtual camera devices (appears as regular webcam to applications)
- Apply real-time video effects and processing
- Support multiple virtual camera instances

The virtual camera appears as a standard webcam to applications like Zoom, Teams, OBS, and other video conferencing software.

---

## Architecture Overview

The Virtual Camera SDK provides three main filter types: 1. **CLSID\_VFVirtualCameraSource**: Reads FROM virtual camera device (acts as a video capture source) 2. **CLSID\_VFVirtualCameraSink**: Writes TO virtual camera device (acts as a renderer) 3. **CLSID\_VFVideoPushSource**: Push source for frame-by-frame rendering (image sequences, custom rendering) **Typical workflows**: - File/Camera → VirtualCameraSink → Virtual Camera Device → Other Applications - Virtual Camera Device → VirtualCameraSource → Your Application - PushSource (frames) → VirtualCameraSink → Virtual Camera Device → Other Applications

---

## Prerequisites

### C# Projects

```
using System;
using System.Runtime.InteropServices;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;
```

**Required NuGet Packages**:

- `VisioForge.DirectShowAPI` - DirectShow wrapper library

**Key CLSIDs**:

```
// Filter CLSIDs (available in Consts class)
public static readonly Guid CLSID_VFVirtualCameraSource = new Guid("AA4DA14E-644B-487a-A7CB-517A390B4BB8"); // Read from virtual camera
public static readonly Guid CLSID_VFVirtualCameraSink = new Guid("AA6AB4DF-9670-4913-88BB-2CB381C19340"); // Write to virtual camera
public static readonly Guid CLSID_VFVirtualAudioCardSource = new Guid("B5A463DF-4016-4C34-AA4F-48EC1B51C73F"); // Audio source
public static readonly Guid CLSID_VFVirtualAudioCardSink = new Guid("1A2673B0-553E-4027-AECC-839405468950"); // Audio sink

// Push source for frame-by-frame rendering
public static readonly Guid CLSID_VFVideoPushSource = new Guid("38D15306-BBC6-4D6C-A89C-9621604D9FC1");
```

### C++ Projects

```
#include <dshow.h>
#include <streams.h>
#include "ivirtualcamera.h"

#pragma comment(lib, "strmiids.lib")

// Filter CLSIDs
DEFINE_GUID(CLSID_VFVirtualCameraSource,
    0xAA4DA14E, 0x644B, 0x487a, 0xA7, 0xCB, 0x51, 0x7A, 0x39, 0x0B, 0x4B, 0xB8);

DEFINE_GUID(CLSID_VFVirtualCameraSink,
    0xAA6AB4DF, 0x9670, 0x4913, 0x88, 0xBB, 0x2C, 0xB3, 0x81, 0xC1, 0x93, 0x40);

DEFINE_GUID(CLSID_VFVirtualAudioCardSource,
    0xB5A463DF, 0x4016, 0x4C34, 0xAA, 0x4F, 0x48, 0xEC, 0x1B, 0x51, 0xC7, 0x3F);

DEFINE_GUID(CLSID_VFVirtualAudioCardSink,
    0x1A2673B0, 0x553E, 0x4027, 0xAE, 0xCC, 0x83, 0x94, 0x05, 0x46, 0x89, 0x50);

DEFINE_GUID(CLSID_VFVideoPushSource,
    0x38D15306, 0xBBC6, 0x4D6C, 0xA8, 0x9C, 0x96, 0x21, 0x60, 0x4D, 0x9F, 0xC1);
```

---

## Example 1: Stream Video File to Virtual Camera

This example demonstrates streaming a video file to a virtual camera device.

### C# Implementation

```
using System;
using System.Runtime.InteropServices;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;
public class VirtualCameraFileStreaming
{
    private IFilterGraph2 filterGraphSource;
    private ICaptureGraphBuilder2 captureGraphSource;
    private IMediaControl mediaControlSource;
    private IMediaEventEx mediaEventExSource;
    private IBaseFilter sourceVideoFilter;
    private IBaseFilter sinkVideoFilter;
    private IBaseFilter sinkAudioFilter;
    public void StreamFileToVirtualCamera(string videoFile)
    {
        try
        {
            // Create filter graph
            filterGraphSource = (IFilterGraph2)new FilterGraph();
            captureGraphSource = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
            mediaControlSource = (IMediaControl)filterGraphSource;
            mediaEventExSource = (IMediaEventEx)filterGraphSource;
            // Attach the filter graph to the capture graph
            int hr = captureGraphSource.SetFiltergraph(filterGraphSource);
            DsError.ThrowExceptionForHR(hr);
            // Add Virtual Camera Sink for video
            sinkVideoFilter = FilterGraphTools.AddFilterFromClsid(
                filterGraphSource,
                Consts.CLSID_VFVirtualCameraSink,
                "VisioForge Virtual Camera Sink - Video");
            // Optional: Set license key for purchased version
            var sinkIntf = sinkVideoFilter as IVFVirtualCameraSink;
            sinkIntf?.set_license("YOUR-LICENSE-KEY"); // Use "TRIAL" for trial version
            // Add Virtual Camera Sink for audio
            sinkAudioFilter = FilterGraphTools.AddFilterFromClsid(
                filterGraphSource,
                Consts.CLSID_VFVirtualAudioCardSink,
                "VisioForge Virtual Camera Sink - Audio");
            // Add source filter for the video file
            // DirectShow automatically selects appropriate source filter
            filterGraphSource.AddSourceFilter(videoFile, "Source file", out sourceVideoFilter);
            // Render video stream: Source → Virtual Camera Sink
            hr = captureGraphSource.RenderStream(null, null, sourceVideoFilter, null, sinkVideoFilter);
            DsError.ThrowExceptionForHR(hr);
            // Render audio stream: Source → Virtual Camera Sink
            hr = captureGraphSource.RenderStream(null, null, sourceVideoFilter, null, sinkAudioFilter);
            // Note: Audio errors are not critical, better to check if audio is available
            // Start playback
            hr = mediaControlSource.Run();
            DsError.ThrowExceptionForHR(hr);
            Console.WriteLine("Streaming to virtual camera. Press any key to stop...");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
            Cleanup();
            throw;
        }
    }
    public void Cleanup()
    {
        // Stop playback
        if (mediaControlSource != null)
        {
            mediaControlSource.Stop();
        }
        // Stop receiving events
        mediaEventExSource?.SetNotifyWindow(IntPtr.Zero, 0, IntPtr.Zero);
        // Remove all filters
        FilterGraphTools.RemoveAllFilters(filterGraphSource);
        // Release DirectShow interfaces
        if (mediaControlSource != null)
        {
            Marshal.ReleaseComObject(mediaControlSource);
            mediaControlSource = null;
        }
        if (mediaEventExSource != null)
        {
            Marshal.ReleaseComObject(mediaEventExSource);
            mediaEventExSource = null;
        }
        if (sourceVideoFilter != null)
        {
            Marshal.ReleaseComObject(sourceVideoFilter);
            sourceVideoFilter = null;
        }
        if (sinkVideoFilter != null)
        {
            Marshal.ReleaseComObject(sinkVideoFilter);
            sinkVideoFilter = null;
        }
        if (sinkAudioFilter != null)
        {
            Marshal.ReleaseComObject(sinkAudioFilter);
            sinkAudioFilter = null;
        }
        if (captureGraphSource != null)
        {
            Marshal.ReleaseComObject(captureGraphSource);
            captureGraphSource = null;
        }
        if (filterGraphSource != null)
        {
            Marshal.ReleaseComObject(filterGraphSource);
            filterGraphSource = null;
        }
    }
}
```

### C++ Implementation

## ``` #include <dshow.h> #include "ivirtualcamera.h" HRESULT StreamFileToVirtualCamera(LPCWSTR videoFile) { HRESULT hr = S_OK; IGraphBuilder* pGraph = NULL; ICaptureGraphBuilder2* pBuild = NULL; IMediaControl* pControl = NULL; IBaseFilter* pSourceFilter = NULL; IBaseFilter* pSinkVideoFilter = NULL; IBaseFilter* pSinkAudioFilter = NULL; // Initialize COM CoInitialize(NULL); // Create the filter graph manager hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, IID_IGraphBuilder, (void**)&pGraph); if (FAILED(hr)) return hr; // Create the Capture Graph Builder hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER, IID_ICaptureGraphBuilder2, (void**)&pBuild); if (FAILED(hr)) goto cleanup; // Set the filter graph hr = pBuild->SetFiltergraph(pGraph); if (FAILED(hr)) goto cleanup; // Create Virtual Camera Sink filter for video hr = CoCreateInstance(CLSID_VFVirtualCameraSink, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void**)&pSinkVideoFilter); if (FAILED(hr)) goto cleanup; hr = pGraph->AddFilter(pSinkVideoFilter, L"VisioForge Virtual Camera Sink - Video"); if (FAILED(hr)) goto cleanup; // Create Virtual Camera Sink filter for audio hr = CoCreateInstance(CLSID_VFVirtualAudioCardSink, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void**)&pSinkAudioFilter); if (FAILED(hr)) goto cleanup; hr = pGraph->AddFilter(pSinkAudioFilter, L"VisioForge Virtual Camera Sink - Audio"); if (FAILED(hr)) goto cleanup; // Add source filter for the file hr = pGraph->AddSourceFilter(videoFile, L"Source File", &pSourceFilter); if (FAILED(hr)) goto cleanup; // Render video stream hr = pBuild->RenderStream(NULL, NULL, pSourceFilter, NULL, pSinkVideoFilter); if (FAILED(hr)) goto cleanup; // Render audio stream (errors not critical) pBuild->RenderStream(NULL, NULL, pSourceFilter, NULL, pSinkAudioFilter); // Get media control interface hr = pGraph->QueryInterface(IID_IMediaControl, (void**)&pControl); if (SUCCEEDED(hr)) { // Start playback hr = pControl->Run(); } cleanup: // Release interfaces if (pControl) pControl->Release(); if (pSinkAudioFilter) pSinkAudioFilter->Release(); if (pSinkVideoFilter) pSinkVideoFilter->Release(); if (pSourceFilter) pSourceFilter->Release(); if (pBuild) pBuild->Release(); if (pGraph) pGraph->Release(); return hr; } ```

## Example 2: Stream Physical Camera to Virtual Camera

This example demonstrates capturing from a physical webcam and streaming it to a virtual camera device.

### C# Implementation

```
using System;
using System.Runtime.InteropServices;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;

public class VirtualCameraFromPhysicalCamera
{
    private IFilterGraph2 filterGraph;
    private ICaptureGraphBuilder2 captureGraph;
    private IMediaControl mediaControl;
    private IBaseFilter cameraFilter;
    private IBaseFilter virtualCameraSink;

    public void StreamCameraToVirtualCamera(string physicalCameraName)
    {
        try
        {
            // Create filter graph
            filterGraph = (IFilterGraph2)new FilterGraph();
            captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
            mediaControl = (IMediaControl)filterGraph;

            // Attach filter graph to capture graph
            int hr = captureGraph.SetFiltergraph(filterGraph);
            DsError.ThrowExceptionForHR(hr);

            // Add physical camera filter
            cameraFilter = FilterGraphTools.AddFilterByName(
                filterGraph,
                FilterCategory.VideoInputDevice,
                physicalCameraName);

            if (cameraFilter == null)
            {
                throw new Exception($"Camera '{physicalCameraName}' not found");
            }

            // Add Virtual Camera Sink
            virtualCameraSink = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFVirtualCameraSink,
                "Virtual Camera Sink");

            // Optional: Set license
            var sinkIntf = virtualCameraSink as IVFVirtualCameraSink;
            sinkIntf?.set_license("TRIAL");

            // Render stream: Physical Camera → Virtual Camera Sink
            hr = captureGraph.RenderStream(
                null,
                MediaType.Video,
                cameraFilter,
                null,
                virtualCameraSink);
            DsError.ThrowExceptionForHR(hr);

            // Start capture
            hr = mediaControl.Run();
            DsError.ThrowExceptionForHR(hr);

            Console.WriteLine("Streaming physical camera to virtual camera...");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
            Cleanup();
            throw;
        }
    }

    public void Cleanup()
    {
        if (mediaControl != null)
        {
            mediaControl.Stop();
        }

        FilterGraphTools.RemoveAllFilters(filterGraph);

        if (cameraFilter != null)
        {
            Marshal.ReleaseComObject(cameraFilter);
            cameraFilter = null;
        }

        if (virtualCameraSink != null)
        {
            Marshal.ReleaseComObject(virtualCameraSink);
            virtualCameraSink = null;
        }

        if (mediaControl != null)
        {
            Marshal.ReleaseComObject(mediaControl);
            mediaControl = null;
        }

        if (captureGraph != null)
        {
            Marshal.ReleaseComObject(captureGraph);
            captureGraph = null;
        }

        if (filterGraph != null)
        {
            Marshal.ReleaseComObject(filterGraph);
            filterGraph = null;
        }
    }
}
```

---

## Example 3: Stream Image Sequence to Virtual Camera (Frame-by-Frame)

This example demonstrates rendering individual frames (image sequence or slideshow) to a virtual camera device.

### C# Implementation

## ``` using System; using System.Drawing; using System.Drawing.Imaging; using System.IO; using System.Runtime.InteropServices; using VisioForge.DirectShowAPI; using VisioForge.DirectShowLib; public class VirtualCameraFrameByFrame { private IFilterGraph2 filterGraphSource; private ICaptureGraphBuilder2 captureGraphSource; private IMediaControl mediaControlSource; private IBaseFilter sourceVideoFilter; private IBaseFilter sinkVideoFilter; private IVFLiveVideoSource pushSource; private System.Windows.Forms.Timer framePushTimer; private int currentFrameIndex = 0; private Bitmap[] frames; public void StreamImageSequenceToVirtualCamera(string[] imageFiles, float frameRate = 10) { try { // Load images into memory frames = new Bitmap[imageFiles.Length]; for (int i = 0; i < imageFiles.Length; i++) { frames[i] = new Bitmap(imageFiles[i]); } if (frames.Length == 0) { throw new Exception("No images to display"); } int width = frames[0].Width; int height = frames[0].Height; // Create filter graph filterGraphSource = (IFilterGraph2)new FilterGraph(); captureGraphSource = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); mediaControlSource = (IMediaControl)filterGraphSource; int hr = captureGraphSource.SetFiltergraph(filterGraphSource); DsError.ThrowExceptionForHR(hr); // Add Virtual Camera Sink sinkVideoFilter = FilterGraphTools.AddFilterFromClsid( filterGraphSource, Consts.CLSID_VFVirtualCameraSink, "VisioForge Virtual Camera Sink - Video"); var sinkIntf = sinkVideoFilter as IVFVirtualCameraSink; sinkIntf?.set_license("TRIAL"); // Add push source filter Guid CLSID_VFVideoPushSource = new Guid("38D15306-BBC6-4D6C-A89C-9621604D9FC1"); sourceVideoFilter = FilterGraphTools.AddFilterFromClsid( filterGraphSource, CLSID_VFVideoPushSource, "VisioForge Video Push Source"); if (sourceVideoFilter == null) { throw new Exception("Unable to create VisioForge Push Source filter."); } // Get IVFLiveVideoSource interface pushSource = sourceVideoFilter as IVFLiveVideoSource; if (pushSource == null) { throw new Exception("Unable to get IVFLiveVideoSource interface."); } // Configure bitmap format var bmiHeader = new BitmapInfoHeader { BitCount = 24, Compression = 0, Width = width, Height = height, Planes = 1, Size = Marshal.SizeOf(typeof(BitmapInfoHeader)), ImageSize = GetStrideRGB24(width) * height }; pushSource.SetBitmapInfo(bmiHeader); pushSource.SetFrameRate(frameRate); // Connect filters: Push Source → Virtual Camera Sink hr = captureGraphSource.RenderStream(null, null, sourceVideoFilter, null, sinkVideoFilter); DsError.ThrowExceptionForHR(hr); // Start the graph hr = mediaControlSource.Run(); DsError.ThrowExceptionForHR(hr); // Setup timer to push frames framePushTimer = new System.Windows.Forms.Timer(); framePushTimer.Interval = (int)(1000 / frameRate); framePushTimer.Tick += PushFrame; framePushTimer.Start(); Console.WriteLine("Streaming image sequence to virtual camera..."); } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}"); Cleanup(); throw; } } private void PushFrame(object sender, EventArgs e) { if (frames == null || frames.Length == 0 || pushSource == null) return; // Get current frame Bitmap frame = frames[currentFrameIndex]; // Lock bitmap data BitmapData bmpData = frame.LockBits( new Rectangle(0, 0, frame.Width, frame.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb); try { // AddFrame takes an AVFrameData (LPStruct), NOT a raw IntPtr. // Build it from the locked bitmap before pushing. int frameSize = bmpData.Stride * frame.Height; long durationTicks = (long)(10_000_000.0 / frameRate); // 100ns units var avFrame = new AVFrameData { Data = bmpData.Scan0, Size = frameSize, StartTime = currentFrameIndex * durationTicks, StopTime = (currentFrameIndex + 1) * durationTicks }; pushSource.AddFrame(avFrame); } finally { frame.UnlockBits(bmpData); } // Move to next frame (loop) currentFrameIndex = (currentFrameIndex + 1) % frames.Length; } private int GetStrideRGB24(int width) { return ((width * 24 + 31) / 32) * 4; } public void Cleanup() { // Stop timer if (framePushTimer != null) { framePushTimer.Stop(); framePushTimer.Dispose(); framePushTimer = null; } // Stop playback if (mediaControlSource != null) { mediaControlSource.Stop(); } // Release frames if (frames != null) { foreach (var frame in frames) { frame?.Dispose(); } frames = null; } // Release DirectShow interfaces pushSource = null; FilterGraphTools.RemoveAllFilters(filterGraphSource); if (sourceVideoFilter != null) { Marshal.ReleaseComObject(sourceVideoFilter); sourceVideoFilter = null; } if (sinkVideoFilter != null) { Marshal.ReleaseComObject(sinkVideoFilter); sinkVideoFilter = null; } if (mediaControlSource != null) { Marshal.ReleaseComObject(mediaControlSource); mediaControlSource = null; } if (captureGraphSource != null) { Marshal.ReleaseComObject(captureGraphSource); captureGraphSource = null; } if (filterGraphSource != null) { Marshal.ReleaseComObject(filterGraphSource); filterGraphSource = null; } } } ```

## Example 4: Read From Virtual Camera

This example demonstrates capturing video from a virtual camera device (useful for testing or monitoring what's being sent to the virtual camera).

### C# Implementation

```
using System;
using System.Runtime.InteropServices;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;
using MediaFoundation;
using MediaFoundation.EVR;

public class VirtualCameraCapture
{
    private IFilterGraph2 filterGraph;
    private ICaptureGraphBuilder2 captureGraph;
    private IMediaControl mediaControl;
    private IBaseFilter virtualCameraSource;
    private IBaseFilter videoRenderer;

    public void CaptureFromVirtualCamera(IntPtr videoWindowHandle)
    {
        try
        {
            // Create filter graph
            filterGraph = (IFilterGraph2)new FilterGraph();
            captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
            mediaControl = (IMediaControl)filterGraph;

            int hr = captureGraph.SetFiltergraph(filterGraph);
            DsError.ThrowExceptionForHR(hr);

            // Add Virtual Camera Source filter
            virtualCameraSource = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFVirtualCameraSource,
                "VisioForge Virtual Camera");

            if (virtualCameraSource == null)
            {
                throw new Exception("Unable to create Virtual Camera Source filter");
            }

            // NOTE: IVFVirtualCameraSource exposes only SetCustomVideoSize() and
            // FixResolution(). Licensing lives on the SINK side (IVFVirtualCameraSink::set_license)
            // because that is the filter that publishes content to the virtual camera; the source
            // filter shown here only consumes it.

            // Create Enhanced Video Renderer (EVR)
            Guid CLSID_EVR = new Guid("FA10746C-9B63-4B6C-BC49-FC300EA5F256");
            videoRenderer = FilterGraphTools.AddFilterFromClsid(filterGraph, CLSID_EVR, "EVR");

            // Configure EVR
            var evrConfig = videoRenderer as IEVRFilterConfig;
            evrConfig?.SetNumberOfStreams(1);

            // Set video window
            var getService = videoRenderer as MediaFoundation.IMFGetService;
            if (getService != null)
            {
                getService.GetService(
                    MediaFoundation.MFServices.MR_VIDEO_RENDER_SERVICE,
                    typeof(MediaFoundation.IMFVideoDisplayControl).GUID,
                    out var videoDisplayControlObj);

                var videoDisplayControl = videoDisplayControlObj as MediaFoundation.IMFVideoDisplayControl;
                videoDisplayControl?.SetVideoWindow(videoWindowHandle);
            }

            // Render stream: Virtual Camera Source → EVR
            hr = captureGraph.RenderStream(
                null,
                MediaType.Video,
                virtualCameraSource,
                null,
                videoRenderer);
            DsError.ThrowExceptionForHR(hr);

            // Start playback
            hr = mediaControl.Run();
            DsError.ThrowExceptionForHR(hr);

            Console.WriteLine("Capturing from virtual camera...");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
            Cleanup();
            throw;
        }
    }

    public void Cleanup()
    {
        if (mediaControl != null)
        {
            mediaControl.Stop();
        }

        FilterGraphTools.RemoveAllFilters(filterGraph);

        if (virtualCameraSource != null)
        {
            Marshal.ReleaseComObject(virtualCameraSource);
            virtualCameraSource = null;
        }

        if (videoRenderer != null)
        {
            Marshal.ReleaseComObject(videoRenderer);
            videoRenderer = null;
        }

        if (mediaControl != null)
        {
            Marshal.ReleaseComObject(mediaControl);
            mediaControl = null;
        }

        if (captureGraph != null)
        {
            Marshal.ReleaseComObject(captureGraph);
            captureGraph = null;
        }

        if (filterGraph != null)
        {
            Marshal.ReleaseComObject(filterGraph);
            filterGraph = null;
        }
    }
}
```

---

## Additional Resources

For more detailed information, see: - [Virtual Camera SDK Product Page](https://www.visioforge.com/virtual-camera-sdk) - [End User License Agreement](../../../eula/) - [Sample Code Repository](https://github.com/visioforge/directshow-samples/tree/main/Virtual%20Camera%20SDK)

## Support

- **Technical Support**: https://support.visioforge.com/
- **Discord Community**: https://discord.com/invite/yvXUG56WCH

---END OF PAGE---


## Windows Virtual Camera SDK — DirectShow for Zoom, Teams, OBS
**URL:** https://www.visioforge.com/help/docs/directshow/virtual-camera-sdk/
**Description:** Create virtual webcams recognized by Zoom, Teams, OBS, and browsers. VisioForge DirectShow SDK streams any video source with audio to virtual camera devices.
**Tags:** Virtual Camera SDK, DirectShow, C++, Windows, Streaming, Virtual Camera
**API:** IVFVirtualCameraSink, SinkFilter, IBaseFilter

# DirectShow Virtual Camera SDK

## Overview

Our robust DirectShow-based Virtual Camera SDK enables developers to implement powerful virtual camera functionality in their applications. The SDK provides sink filters that can be utilized as output in Video Capture SDK or Video Edit SDK environments, while the source filters can be employed as video sources for various capture applications.

With this versatile toolkit, you can stream video content from virtually any source directly to a virtual camera device. These virtual devices are fully compatible with popular communication platforms such as `Skype`, `Zoom`, `Microsoft Teams`, web browsers, and numerous other applications that support DirectShow virtual cameras. The SDK also includes comprehensive audio streaming capabilities for complete multimedia solutions.

To help you get started quickly, the SDK package includes a fully-functional sample application that demonstrates how to stream video content from files to virtual camera devices.

Download the SDK from our [product page](https://www.visioforge.com/virtual-camera-sdk) to start integrating virtual camera functionality into your applications today.

---

## Installation

Before using the code samples and integrating the SDK into your application, you must first install the Virtual Camera SDK from the [product page](https://www.visioforge.com/virtual-camera-sdk).

**Installation Steps**:

1. Download the SDK installer from the product page
2. Run the installer with administrative privileges
3. The installer will register the virtual camera driver and all necessary DirectShow filters
4. Sample applications and source code will be available in the installation directory

**Note**: The virtual camera driver and filters must be properly registered on the system before they can be used in your applications. The installer handles this automatically.

---

## Key Features and Capabilities

- **Multiple Source Support**: Stream video to virtual camera from files, network streams, or capture devices
- **Architecture Compatibility**: Full x86/x64 architecture support
- **High-Resolution Support**: Stream video content up to 4K resolution
- **Customization Options**: Define and implement custom camera names
- **SDK Integration**: Seamless integration with other development tools
- **Audio Support**: Complete audio streaming capabilities
- **Professional Applications**: Perfect for teleconferencing, streaming, and professional video applications

## Technical Implementation

### Sample DirectShow Graph Architecture

The diagram below illustrates the standard DirectShow graph implementation when using the Virtual Camera SDK:

### License Registration via Registry

You can register the filter with your valid license key using the Windows registry system.

Configure licensing using the following registry key:

```
HKEY_LOCAL_MACHINE\SOFTWARE\VisioForge\Virtual Camera SDK\License
```

Set your purchased license key as a string value in this registry location.

### Deployment Guidelines

For proper deployment, copy and COM-register the SDK DirectShow filters - these are the files in the `Redist` folder with .ax extension. Registration can be performed using `regsvr32.exe` or through COM registration in your application installer. Please note that administrative privileges are required for successful registration.

### No-Signal Application Configuration

You can configure an application to run automatically when the virtual camera is not connected to any video source.

Configure the no-signal application using this registry key:

```
HKEY_LOCAL_MACHINE\SOFTWARE\VisioForge\Virtual Camera SDK\StartupEXE
```

Set the executable file name as a string value.

### No-Signal Image Configuration

Instead of displaying a black screen when no video source is available, you can configure a custom image to be shown.

Configure the no-signal image using this registry key:

```
HKEY_LOCAL_MACHINE\SOFTWARE\VisioForge\Virtual Camera SDK\BackgroundImage
```

Set the image file path as a string value.

## Interface Reference

### IVFVirtualCameraSink Interface

The `IVFVirtualCameraSink` interface is used to configure the virtual camera sink filter, primarily for license registration.

**Interface GUID**: `{A96631D2-4AC9-4F09-9F34-FF8229087DEB}`

**Inherits From**: `IUnknown`

#### C# Definition

```
using System;
using System.Runtime.InteropServices;

/// <summary>
/// Virtual camera sink interface for license configuration.
/// </summary>
[ComImport]
[System.Security.SuppressUnmanagedCodeSecurity]
[Guid("A96631D2-4AC9-4F09-9F34-FF8229087DEB")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IVFVirtualCameraSink
{
    /// <summary>
    /// Sets the license key for the virtual camera sink filter.
    /// </summary>
    /// <param name="license">License key string ("TRIAL" for trial version)</param>
    /// <returns>HRESULT (0 for success)</returns>
    [PreserveSig]
    int set_license([MarshalAs(UnmanagedType.LPStr)] string license);
}
```

Native C++/Delphi take ANSI; the SDK's bundled C# demo uses LPWStr

The native `IVFVirtualCameraSink::set_license` parameter is `LPCSTR` (ANSI) in C++ and `PAnsiChar` in Delphi. The C# demo wrapper bundled with the SDK declares `[MarshalAs(UnmanagedType.LPWStr)]` — a known marshaling discrepancy in the demo. Pure-ASCII license keys (e.g., `"TRIAL"`, hex-encoded license strings) round-trip cleanly either way; if you need to match the native ABI exactly, use `LPStr` as shown above.

**Usage Example (C#)**:

```
// Add Virtual Camera Sink filter
var sinkFilter = FilterGraphTools.AddFilterFromClsid(
    filterGraph,
    Consts.CLSID_VFVirtualCameraSink,
    "VisioForge Virtual Camera Sink");

// Set license
var sinkIntf = sinkFilter as IVFVirtualCameraSink;
if (sinkIntf != null)
{
    sinkIntf.set_license("YOUR-LICENSE-KEY"); // or "TRIAL" for trial version
}
```

#### C++ Definition

```
#include <unknwn.h>

// {A96631D2-4AC9-4F09-9F34-FF8229087DEB}
DEFINE_GUID(IID_IVFVirtualCameraSink,
    0xa96631d2, 0x4ac9, 0x4f09, 0x9f, 0x34, 0xff, 0x82, 0x29, 0x8, 0x7d, 0xeb);

/// <summary>
/// Virtual camera sink interface for license configuration.
/// </summary>
DECLARE_INTERFACE_(IVFVirtualCameraSink, IUnknown)
{
    /// <summary>
    /// Sets the license key for the virtual camera sink filter.
    /// </summary>
    /// <param name="license">License key ANSI string ("TRIAL" for trial version)</param>
    /// <returns>HRESULT (S_OK for success)</returns>
    STDMETHOD(set_license) (THIS_
        LPCSTR license
        ) PURE;
};
```

**Usage Example (C++)**:

```
IBaseFilter* pSinkFilter = nullptr;
IVFVirtualCameraSink* pSinkIntf = nullptr;

// Create Virtual Camera Sink filter
hr = CoCreateInstance(CLSID_VFVirtualCameraSink, NULL, CLSCTX_INPROC_SERVER,
                     IID_IBaseFilter, (void**)&pSinkFilter);

if (SUCCEEDED(hr))
{
    // Query interface
    hr = pSinkFilter->QueryInterface(IID_IVFVirtualCameraSink, (void**)&pSinkIntf);
    if (SUCCEEDED(hr))
    {
        // Set license — LPCSTR (ANSI), not wide string
        hr = pSinkIntf->set_license("YOUR-LICENSE-KEY"); // or "TRIAL"
        pSinkIntf->Release();
    }
}
```

#### Delphi Definition

```
uses
  ActiveX, ComObj;

const
  IID_IVFVirtualCameraSink: TGUID = '{A96631D2-4AC9-4F09-9F34-FF8229087DEB}';

type
  /// <summary>
  /// Virtual camera sink interface for license configuration.
  /// </summary>
  IVFVirtualCameraSink = interface(IUnknown)
    ['{A96631D2-4AC9-4F09-9F34-FF8229087DEB}']

    /// <summary>
    /// Sets the license key for the virtual camera sink filter.
    /// </summary>
    /// <param name="license">License key ANSI string ('TRIAL' for trial version)</param>
    /// <returns>HRESULT (S_OK for success)</returns>
    function set_license(license: PAnsiChar): HRESULT; stdcall;
  end;
```

**Usage Example (Delphi)**:

```
var
  SinkFilter: IBaseFilter;
  SinkIntf: IVFVirtualCameraSink;
begin
  // Create Virtual Camera Sink filter
  if Succeeded(CoCreateInstance(CLSID_VFVirtualCameraSink, nil,
                                CLSCTX_INPROC_SERVER,
                                IID_IBaseFilter, SinkFilter)) then
  begin
    // Query interface
    if Succeeded(SinkFilter.QueryInterface(IID_IVFVirtualCameraSink, SinkIntf)) then
    begin
      // Set license — PAnsiChar (ANSI string)
      SinkIntf.set_license(PAnsiChar(AnsiString('YOUR-LICENSE-KEY'))); // or AnsiString('TRIAL')
      SinkIntf := nil;
    end;
  end;
end;
```

---

## Third-Party Libraries and Integration

The Virtual Camera SDK contains third-party components that are used in the demo applications. These components are not required for the core SDK functionality.

The Delphi and .NET demonstration applications utilize third-party libraries to simplify DirectShow development. The C++ demo applications are built without external dependencies.

### .NET Integration

.NET applications leverage [DirectShowLib.Net (LGPL)](https://sourceforge.net/projects/directshownet/) to implement DirectShow functionality in managed code environments.

Developers can create console applications, WinForms, or WPF applications using .NET. The included demo applications utilize WinForms for the user interface.

### Delphi Integration

Delphi applications use [DSPack (MPL)](https://code.google.com/archive/p/dspack/) to implement DirectShow functionality. While modern Delphi versions include built-in DirectShow support, DSPack is utilized in the demo applications to maintain compatibility with older Delphi versions.

### C++ Integration

The C++ demo applications do not require third-party libraries and are built using the standard DirectShow SDK (part of Windows SDK).

Developers can utilize MFC, ATL, or other C++ frameworks to build their applications. The included demo applications are built with MFC.

## System Requirements

The SDK is compatible with the following Microsoft Windows operating systems:

- Windows 7, 8, 8.1, 10, and 11
- Windows Server 2008, 2012, 2016, 2019, and 2022

## Version History and Updates

### Version 14.0

- Performance optimizations and enhancements
- Improved Windows 11 compatibility
- Enhanced support for modern web browsers
- Minor updates and bug fixes

### Version 12.0

- Windows 10 support improvements
- Performance enhancements
- 8K resolution support added
- Improved Mozilla Firefox and Microsoft Edge compatibility
- Various minor updates

### Version 11.0

- Critical bug fixes implemented
- Updated Google Chrome compatibility
- Resolved audio clicks issues in various web browsers and applications

### Version 10.0

- High frame rate support added
- Significant performance improvements
- Minor updates and bug fixes

### Version 9.0

- 4K video resolution support added
- Updated support for contemporary web browsers
- Various minor updates and improvements

### Version 8.0

- Added background image functionality for no-signal scenarios
- Implemented application auto-run for no-signal conditions
- Enhanced Skype compatibility

### Version 7.1

- Audio streaming support via virtual audio output and virtual microphone input
- PCM audio format support with customizable sample rates and channel configuration
- Bug fixes and performance improvements
- Additional video resolutions added

### Version 7.0

- Initial release as a standalone product
- Previously included in Video Edit SDK and Video Capture SDK
- Compatible with any DirectShow application

## Additional Resources

- [End User License Agreement](../../eula/)

---END OF PAGE---


## VLC Source DirectShow Filter Integration Code Examples
**URL:** https://www.visioforge.com/help/docs/directshow/vlc-source-filter/examples/
**Description:** Code examples for VLC Source Filter with multi-track audio, subtitles, 360° video, and custom VLC parameters in DirectShow.
**Tags:** DirectShow, C++, Windows, WinForms, Playback, Streaming, Decoding, RTSP, HLS, MP4, MKV, AVI, MOV, C#, VB.NET
**API:** IBaseFilter, IVFRegister

# Code Examples

## Overview

This page provides practical code examples for using the VLC Source Filter in DirectShow applications. The VLC Source Filter supports multi-audio tracks, subtitles, 360° video, and custom VLC command-line options.

---

## Prerequisites

### C++ Projects

```
#include <dshow.h>
#include <streams.h>
#include "ivlcsrc.h"      // Single header from SDK — declares IVlcSrc, IVlcSrc2, IVlcSrc3 + CLSID/IID GUIDs
#pragma comment(lib, "strmiids.lib")
```

### C# Projects

```
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;
using System.Runtime.InteropServices;
using System.Text;
```

**NuGet Packages**: - VisioForge.DirectShowAPI - MediaFoundationCore

---

## Example 1: Basic File Playback

Play a local media file with VLC Source Filter.

### C++ Implementation

```
#include <dshow.h>
#include "ivlcsrc.h"

// CLSID for VLC Source Filter
DEFINE_GUID(CLSID_VFVLCSource,
    0x3fc97748, 0x7cb6, 0x4195, 0x89, 0xde, 0x07, 0x17, 0x58, 0x2a, 0x48, 0x63);

HRESULT PlayVLCFile(LPCWSTR filename, HWND hVideoWindow)
{
    IGraphBuilder* pGraph = NULL;
    IMediaControl* pControl = NULL;
    IBaseFilter* pSourceFilter = NULL;
    IVlcSrc* pVlcSrc = NULL;

    HRESULT hr = S_OK;

    // Create Filter Graph
    hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
                         IID_IGraphBuilder, (void**)&pGraph);
    if (FAILED(hr)) return hr;

    // Create VLC Source Filter
    hr = CoCreateInstance(CLSID_VFVLCSource, NULL, CLSCTX_INPROC_SERVER,
                         IID_IBaseFilter, (void**)&pSourceFilter);
    if (FAILED(hr)) goto cleanup;

    // Add filter to graph
    hr = pGraph->AddFilter(pSourceFilter, L"VLC Source");
    if (FAILED(hr)) goto cleanup;

    // Get VLC interface
    hr = pSourceFilter->QueryInterface(IID_IVlcSrc, (void**)&pVlcSrc);
    if (FAILED(hr)) goto cleanup;

    // Load file
    hr = pVlcSrc->SetFile((WCHAR*)filename);
    if (FAILED(hr)) goto cleanup;

    // Build and render graph
    ICaptureGraphBuilder2* pBuild = NULL;
    hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER,
                         IID_ICaptureGraphBuilder2, (void**)&pBuild);
    if (SUCCEEDED(hr))
    {
        hr = pBuild->SetFiltergraph(pGraph);

        // Render video and audio
        hr = pBuild->RenderStream(NULL, &MEDIATYPE_Video, pSourceFilter, NULL, NULL);
        hr = pBuild->RenderStream(NULL, &MEDIATYPE_Audio, pSourceFilter, NULL, NULL);

        pBuild->Release();
    }

    // Run graph
    hr = pGraph->QueryInterface(IID_IMediaControl, (void**)&pControl);
    if (SUCCEEDED(hr))
    {
        hr = pControl->Run();
    }

cleanup:
    if (pVlcSrc) pVlcSrc->Release();
    if (pControl) pControl->Release();
    if (pSourceFilter) pSourceFilter->Release();
    if (pGraph) pGraph->Release();

    return hr;
}
```

### C# Implementation

```
using System;
using System.Runtime.InteropServices;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;

public class VLCSourceBasicExample
{
    private IFilterGraph2 filterGraph;
    private IMediaControl mediaControl;
    private IVideoWindow videoWindow;
    private IBaseFilter sourceFilter;

    public void PlayFile(string filename, IntPtr videoWindowHandle)
    {
        try
        {
            // Create filter graph
            filterGraph = (IFilterGraph2)new FilterGraph();
            mediaControl = (IMediaControl)filterGraph;
            videoWindow = (IVideoWindow)filterGraph;

            // Create and add VLC Source filter
            sourceFilter = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFVLCSource,
                "VLC Source");

            // Load file using IVlcSrc interface
            var vlcSrc = sourceFilter as IVlcSrc;
            if (vlcSrc != null)
            {
                int hr = vlcSrc.SetFile(filename);
                DsError.ThrowExceptionForHR(hr);
            }

            // Render streams
            ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
            int result = captureGraph.SetFiltergraph(filterGraph);
            DsError.ThrowExceptionForHR(result);

            captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
            captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);

            // Set video window
            videoWindow.put_Owner(videoWindowHandle);
            videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);
            videoWindow.put_Visible(OABool.True);

            // Run graph
            mediaControl.Run();

            Marshal.ReleaseComObject(captureGraph);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

    public void Stop()
    {
        if (mediaControl != null)
        {
            mediaControl.Stop();
        }

        if (videoWindow != null)
        {
            videoWindow.put_Visible(OABool.False);
            videoWindow.put_Owner(IntPtr.Zero);
        }

        FilterGraphTools.RemoveAllFilters(filterGraph);

        if (sourceFilter != null) Marshal.ReleaseComObject(sourceFilter);
        if (videoWindow != null) Marshal.ReleaseComObject(videoWindow);
        if (mediaControl != null) Marshal.ReleaseComObject(mediaControl);
        if (filterGraph != null) Marshal.ReleaseComObject(filterGraph);
    }
}
```

### VB.NET Implementation

```
Imports System.Runtime.InteropServices
Imports VisioForge.DirectShowAPI
Imports VisioForge.DirectShowLib

Public Class VLCSourceBasicExample
    Private filterGraph As IFilterGraph2
    Private mediaControl As IMediaControl
    Private videoWindow As IVideoWindow
    Private sourceFilter As IBaseFilter

    Public Sub PlayFile(filename As String, videoWindowHandle As IntPtr)
        Try
            ' Create filter graph
            filterGraph = DirectCast(New FilterGraph(), IFilterGraph2)
            mediaControl = DirectCast(filterGraph, IMediaControl)
            videoWindow = DirectCast(filterGraph, IVideoWindow)

            ' Create and add VLC Source filter
            sourceFilter = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFVLCSource,
                "VLC Source")

            ' Load file
            Dim vlcSrc = DirectCast(sourceFilter, IVlcSrc)
            If vlcSrc IsNot Nothing Then
                Dim hr As Integer = vlcSrc.SetFile(filename)
                DsError.ThrowExceptionForHR(hr)
            End If

            ' Render streams
            Dim captureGraph As ICaptureGraphBuilder2 = DirectCast(New CaptureGraphBuilder2(), ICaptureGraphBuilder2)
            captureGraph.SetFiltergraph(filterGraph)

            captureGraph.RenderStream(Nothing, MediaType.Video, sourceFilter, Nothing, Nothing)
            captureGraph.RenderStream(Nothing, MediaType.Audio, sourceFilter, Nothing, Nothing)

            ' Set video window
            videoWindow.put_Owner(videoWindowHandle)
            videoWindow.put_WindowStyle(WindowStyle.Child Or WindowStyle.ClipSiblings)
            videoWindow.put_Visible(OABool.True)

            ' Run graph
            mediaControl.Run()

            Marshal.ReleaseComObject(captureGraph)
        Catch ex As Exception
            Console.WriteLine($"Error: {ex.Message}")
        End Try
    End Sub

    Public Sub [Stop]()
        If mediaControl IsNot Nothing Then
            mediaControl.Stop()
        End If

        If videoWindow IsNot Nothing Then
            videoWindow.put_Visible(OABool.False)
            videoWindow.put_Owner(IntPtr.Zero)
        End If

        FilterGraphTools.RemoveAllFilters(filterGraph)

        If sourceFilter IsNot Nothing Then Marshal.ReleaseComObject(sourceFilter)
        If videoWindow IsNot Nothing Then Marshal.ReleaseComObject(videoWindow)
        If mediaControl IsNot Nothing Then Marshal.ReleaseComObject(mediaControl)
        If filterGraph IsNot Nothing Then Marshal.ReleaseComObject(filterGraph)
    End Sub
End Class
```

---

## Example 2: Audio Track Selection

List and select audio tracks from multi-audio files.

### C# Audio Track Management

```
public class VLCAudioTrackExample
{
    private IFilterGraph2 filterGraph;
    private IMediaControl mediaControl;
    private IBaseFilter sourceFilter;
    public void PlayWithAudioTrackSelection(string filename, IntPtr videoWindowHandle)
    {
        filterGraph = (IFilterGraph2)new FilterGraph();
        mediaControl = (IMediaControl)filterGraph;
        // Create VLC Source filter
        sourceFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFVLCSource,
            "VLC Source");
        // Load file
        var vlcSrc = sourceFilter as IVlcSrc;
        if (vlcSrc != null)
        {
            vlcSrc.SetFile(filename);
            // Get audio track count
            int audioCount = 0;
            vlcSrc.GetAudioTracksCount(out audioCount);
            Console.WriteLine($"Total audio tracks: {audioCount}");
            // List all audio tracks
            for (int i = 0; i < audioCount; i++)
            {
                int trackId;
                StringBuilder trackName = new StringBuilder(256);
                vlcSrc.GetAudioTrackInfo(i, out trackId, trackName);
                Console.WriteLine($"Track {i}: ID={trackId}, Name={trackName}");
            }
            // Get currently active track
            int currentTrackId;
            vlcSrc.GetAudioTrack(out currentTrackId);
            Console.WriteLine($"Currently active track ID: {currentTrackId}");
            // Select a specific track (e.g., track index 1)
            if (audioCount > 1)
            {
                int desiredTrackId;
                StringBuilder name = new StringBuilder(256);
                vlcSrc.GetAudioTrackInfo(1, out desiredTrackId, name);
                vlcSrc.SetAudioTrack(desiredTrackId);
                Console.WriteLine($"Switched to track: {name}");
            }
        }
        // Build and run graph
        ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
        captureGraph.SetFiltergraph(filterGraph);
        captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
        captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);
        var videoWindow = (IVideoWindow)filterGraph;
        videoWindow.put_Owner(videoWindowHandle);
        videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);
        mediaControl.Run();
        Marshal.ReleaseComObject(captureGraph);
    }
    // Method to switch audio track during playback
    public void SwitchAudioTrack(int trackIndex)
    {
        var vlcSrc = sourceFilter as IVlcSrc;
        if (vlcSrc != null)
        {
            int trackId;
            StringBuilder trackName = new StringBuilder(256);
            vlcSrc.GetAudioTrackInfo(trackIndex, out trackId, trackName);
            vlcSrc.SetAudioTrack(trackId);
            Console.WriteLine($"Switched to audio track: {trackName}");
        }
    }
}
```

### C++ Audio Track Management

## ``` void ListAndSelectAudioTracks(IVlcSrc* pVlcSrc) { int audioCount = 0; pVlcSrc->GetAudioTracksCount(&audioCount); wprintf(L"Total audio tracks: %d\n", audioCount); // List all tracks for (int i = 0; i < audioCount; i++) { int trackId = 0; WCHAR trackName[256] = {0}; pVlcSrc->GetAudioTrackInfo(i, &trackId, trackName); wprintf(L"Track %d: ID=%d, Name=%s\n", i, trackId, trackName); } // Get current track int currentId = 0; pVlcSrc->GetAudioTrack(&currentId); wprintf(L"Current track ID: %d\n", currentId); // Select track by index (e.g., track 1) if (audioCount > 1) { int trackId = 0; WCHAR name[256] = {0}; pVlcSrc->GetAudioTrackInfo(1, &trackId, name); pVlcSrc->SetAudioTrack(trackId); wprintf(L"Switched to track: %s\n", name); } } ```

## Example 3: Subtitle Management

Select and manage subtitle tracks.

### C# Subtitle Management

```
public class VLCSubtitleExample
{
    private IBaseFilter sourceFilter;

    public void ManageSubtitles(string filename)
    {
        // Assume filter is already created and added to graph
        var vlcSrc = sourceFilter as IVlcSrc;
        if (vlcSrc != null)
        {
            vlcSrc.SetFile(filename);

            // Get subtitle count
            int subtitleCount = 0;
            vlcSrc.GetSubtitlesCount(out subtitleCount);

            Console.WriteLine($"Total subtitle tracks: {subtitleCount}");

            // List all subtitles
            for (int i = 0; i < subtitleCount; i++)
            {
                int subtitleId;
                StringBuilder subtitleName = new StringBuilder(256);
                vlcSrc.GetSubtitleInfo(i, out subtitleId, subtitleName);

                Console.WriteLine($"Subtitle {i}: ID={subtitleId}, Name={subtitleName}");
            }

            // Enable subtitle (e.g., subtitle index 0)
            if (subtitleCount > 0)
            {
                int subtitleId;
                StringBuilder name = new StringBuilder(256);
                vlcSrc.GetSubtitleInfo(0, out subtitleId, name);

                vlcSrc.SetSubtitle(subtitleId);
                Console.WriteLine($"Enabled subtitle: {name}");
            }

            // Disable subtitles (use ID -1)
            // vlcSrc.SetSubtitle(-1);
        }
    }

    // Method to switch subtitles during playback
    public void SwitchSubtitle(int subtitleIndex)
    {
        var vlcSrc = sourceFilter as IVlcSrc;
        if (vlcSrc != null)
        {
            if (subtitleIndex < 0)
            {
                // Disable subtitles
                vlcSrc.SetSubtitle(-1);
                Console.WriteLine("Subtitles disabled");
            }
            else
            {
                int subtitleId;
                StringBuilder name = new StringBuilder(256);
                vlcSrc.GetSubtitleInfo(subtitleIndex, out subtitleId, name);

                vlcSrc.SetSubtitle(subtitleId);
                Console.WriteLine($"Switched to subtitle: {name}");
            }
        }
    }
}
```

### C++ Subtitle Management

```
void ManageSubtitles(IVlcSrc* pVlcSrc)
{
    int subtitleCount = 0;
    pVlcSrc->GetSubtitlesCount(&subtitleCount);

    wprintf(L"Total subtitles: %d\n", subtitleCount);

    // List all subtitles
    for (int i = 0; i < subtitleCount; i++)
    {
        int subtitleId = 0;
        WCHAR subtitleName[256] = {0};
        pVlcSrc->GetSubtitleInfo(i, &subtitleId, subtitleName);

        wprintf(L"Subtitle %d: ID=%d, Name=%s\n", i, subtitleId, subtitleName);
    }

    // Enable first subtitle
    if (subtitleCount > 0)
    {
        int id = 0;
        WCHAR name[256] = {0};
        pVlcSrc->GetSubtitleInfo(0, &id, name);

        pVlcSrc->SetSubtitle(id);
        wprintf(L"Enabled subtitle: %s\n", name);
    }

    // Disable subtitles
    // pVlcSrc->SetSubtitle(-1);
}
```

---

## Example 4: Custom VLC Command-Line Options

Pass custom VLC parameters using IVlcSrc2 interface.

### C# Custom VLC Parameters

```
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using VisioForge.Core.Helpers;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;
public class VLCCustomOptionsExample
{
    public void PlayWithCustomVLCOptions(string filename, IntPtr videoWindowHandle)
    {
        var filterGraph = (IFilterGraph2)new FilterGraph();
        var sourceFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFVLCSource,
            "VLC Source");
        // Set custom VLC command-line options using IVlcSrc2
        var vlcSrc2 = sourceFilter as IVlcSrc2;
        if (vlcSrc2 != null)
        {
            // Create list of VLC command-line parameters
            var parameters = new List<string>();
            parameters.Add("--avcodec-hw=any");          // Enable hardware decoding
            parameters.Add("--network-caching=1000");    // 1 second network cache
            parameters.Add("--live-caching=300");        // 300ms for live streams
            parameters.Add("--file-caching=300");        // 300ms for files
            parameters.Add("--sout-mux-caching=2000");   // Output muxing cache
            parameters.Add("--vout=direct3d11");         // Use Direct3D11 renderer
            parameters.Add("--verbose=2");               // Logging level
            // Convert strings to native UTF-8 IntPtr array
            var array = new IntPtr[parameters.Count];
            for (int i = 0; i < parameters.Count; i++)
            {
                array[i] = StringHelper.NativeUtf8FromString(parameters[i]);
            }
            try
            {
                // Call SetCustomCommandLine with IntPtr array
                int hr = vlcSrc2.SetCustomCommandLine(array, parameters.Count);
                DsError.ThrowExceptionForHR(hr);
            }
            finally
            {
                // Free allocated unmanaged memory
                for (int i = 0; i < array.Length; i++)
                {
                    Marshal.FreeHGlobal(array[i]);
                }
            }
        }
        // Load file using IVlcSrc
        var vlcSrc = sourceFilter as IVlcSrc;
        if (vlcSrc != null)
        {
            vlcSrc.SetFile(filename);
        }
        // Build and run graph
        ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
        captureGraph.SetFiltergraph(filterGraph);
        captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
        captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);
        var videoWindow = (IVideoWindow)filterGraph;
        videoWindow.put_Owner(videoWindowHandle);
        videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);
        var mediaControl = (IMediaControl)filterGraph;
        mediaControl.Run();
        Marshal.ReleaseComObject(captureGraph);
    }
}
```

### Common VLC Options

Here are common VLC parameter combinations. Remember to use the proper marshaling pattern shown above.

```
// Network streaming options
var networkOptions = new List<string>
{
    "--network-caching=3000",      // 3 seconds for network streams
    "--rtsp-tcp",                  // Force TCP for RTSP
    "--http-reconnect"             // Auto-reconnect HTTP streams
};
// Hardware decoding options
var hwDecodeOptions = new List<string>
{
    "--avcodec-hw=any"             // Auto-detect hardware
    // Alternative options:
    // "--avcodec-hw=dxva2"        // Use DXVA2
    // "--avcodec-hw=d3d11va"      // Use D3D11VA
    // "--avcodec-hw=nvdec"        // Use NVIDIA NVDEC
};
// Low latency options
var lowLatencyOptions = new List<string>
{
    "--network-caching=0",
    "--live-caching=0",
    "--file-caching=0",
    "--sout-mux-caching=0",
    "--clock-jitter=0",
    "--drop-late-frames",
    "--skip-frames"
};
// 360° video options
var video360Options = new List<string>
{
    "--video-filter=transform",
    "--transform-type=hflip",
    "--vout-filter=rotate"
};
// Subtitle options
var subtitleOptions = new List<string>
{
    "--sub-autodetect-file",       // Auto-detect subtitle files
    "--sub-language=eng",          // Preferred subtitle language
    "--freetype-fontsize=20"       // Subtitle font size
};
// Audio options
var audioOptions = new List<string>
{
    "--audio-desync=0",            // Audio synchronization
    "--audiotrack-language=eng",   // Preferred audio language
    "--audio-filter=normvol"       // Volume normalization
};
// Complete example with multiple options
var completeOptions = new List<string>
{
    "--avcodec-hw=any",
    "--network-caching=1000",
    "--rtsp-tcp",
    "--sub-autodetect-file",
    "--verbose=1"
};
// Helper method to apply VLC parameters
private void ApplyVLCParameters(IVlcSrc2 vlcSrc2, List<string> parameters)
{
    if (vlcSrc2 == null || parameters == null || parameters.Count == 0)
        return;
    var array = new IntPtr[parameters.Count];
    for (int i = 0; i < parameters.Count; i++)
    {
        array[i] = StringHelper.NativeUtf8FromString(parameters[i]);
    }
    try
    {
        int hr = vlcSrc2.SetCustomCommandLine(array, parameters.Count);
        DsError.ThrowExceptionForHR(hr);
    }
    finally
    {
        for (int i = 0; i < array.Length; i++)
        {
            Marshal.FreeHGlobal(array[i]);
        }
    }
}
```

---

## Example 5: Frame Rate Override

Override source frame rate using IVlcSrc3 interface.

### C# Frame Rate Override

```
public class VLCFrameRateExample
{
    public void PlayWithCustomFrameRate(string filename, double fps, IntPtr videoWindowHandle)
    {
        var filterGraph = (IFilterGraph2)new FilterGraph();

        var sourceFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFVLCSource,
            "VLC Source");

        // Set custom frame rate using IVlcSrc3
        var vlcSrc3 = sourceFilter as IVlcSrc3;
        if (vlcSrc3 != null)
        {
            // Override frame rate (e.g., 30.0, 25.0, 60.0)
            int hr = vlcSrc3.SetDefaultFrameRate(fps);
            DsError.ThrowExceptionForHR(hr);

            Console.WriteLine($"Frame rate set to: {fps} fps");
        }

        // Load file
        var vlcSrc = sourceFilter as IVlcSrc;
        if (vlcSrc != null)
        {
            vlcSrc.SetFile(filename);
        }

        // Build and run graph
        ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
        captureGraph.SetFiltergraph(filterGraph);

        captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
        captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);

        var videoWindow = (IVideoWindow)filterGraph;
        videoWindow.put_Owner(videoWindowHandle);
        videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);

        var mediaControl = (IMediaControl)filterGraph;
        mediaControl.Run();

        Marshal.ReleaseComObject(captureGraph);
    }
}
```

### C++ Frame Rate Override

```
#include "ivlcsrc.h"

void SetCustomFrameRate(IBaseFilter* pFilter, double fps)
{
    IVlcSrc3* pVlcSrc3 = nullptr;
    HRESULT hr = pFilter->QueryInterface(IID_IVlcSrc3, (void**)&pVlcSrc3);

    if (SUCCEEDED(hr))
    {
        hr = pVlcSrc3->SetDefaultFrameRate(fps);
        if (SUCCEEDED(hr))
        {
            wprintf(L"Frame rate set to: %.2f fps\n", fps);
        }

        pVlcSrc3->Release();
    }
}
```

---

## Example 6: Network Streaming (RTSP/HLS)

Stream from network sources.

### C# Network Streaming

## ``` public class VLCNetworkStreamingExample { public void PlayRTSPStream(string rtspUrl, IntPtr videoWindowHandle) { var filterGraph = (IFilterGraph2)new FilterGraph(); var sourceFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFVLCSource, "VLC Source"); // Configure for RTSP streaming var vlcSrc2 = sourceFilter as IVlcSrc2; if (vlcSrc2 != null) { var parameters = new List<string> { "--rtsp-tcp", // Use TCP transport "--network-caching=300", // Low latency (300ms) "--rtsp-frame-buffer-size=500000", // Frame buffer size "--drop-late-frames", // Drop late frames "--skip-frames" // Skip frames if needed }; var array = new IntPtr[parameters.Count]; for (int i = 0; i < parameters.Count; i++) { array[i] = StringHelper.NativeUtf8FromString(parameters[i]); } try { vlcSrc2.SetCustomCommandLine(array, parameters.Count); } finally { for (int i = 0; i < array.Length; i++) { Marshal.FreeHGlobal(array[i]); } } } // Load RTSP stream var vlcSrc = sourceFilter as IVlcSrc; if (vlcSrc != null) { // Example: "rtsp://camera.example.com:554/stream" vlcSrc.SetFile(rtspUrl); } // Build and run graph ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); captureGraph.SetFiltergraph(filterGraph); captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null); captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null); var videoWindow = (IVideoWindow)filterGraph; videoWindow.put_Owner(videoWindowHandle); videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings); var mediaControl = (IMediaControl)filterGraph; mediaControl.Run(); Marshal.ReleaseComObject(captureGraph); } public void PlayHLSStream(string hlsUrl, IntPtr videoWindowHandle) { var filterGraph = (IFilterGraph2)new FilterGraph(); var sourceFilter = FilterGraphTools.AddFilterFromClsid( filterGraph, Consts.CLSID_VFVLCSource, "VLC Source"); // Configure for HLS streaming var vlcSrc2 = sourceFilter as IVlcSrc2; if (vlcSrc2 != null) { var parameters = new List<string> { "--http-reconnect", // Auto-reconnect "--network-caching=3000", // 3 second buffer for HLS "--hls-segment-threads=3", // Parallel segment download "--avcodec-hw=any" // Hardware decoding }; var array = new IntPtr[parameters.Count]; for (int i = 0; i < parameters.Count; i++) { array[i] = StringHelper.NativeUtf8FromString(parameters[i]); } try { vlcSrc2.SetCustomCommandLine(array, parameters.Count); } finally { for (int i = 0; i < array.Length; i++) { Marshal.FreeHGlobal(array[i]); } } } // Load HLS stream var vlcSrc = sourceFilter as IVlcSrc; if (vlcSrc != null) { // Example: "https://example.com/stream/playlist.m3u8" vlcSrc.SetFile(hlsUrl); } // Build and run graph ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); captureGraph.SetFiltergraph(filterGraph); captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null); captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null); var videoWindow = (IVideoWindow)filterGraph; videoWindow.put_Owner(videoWindowHandle); videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings); var mediaControl = (IMediaControl)filterGraph; mediaControl.Run(); Marshal.ReleaseComObject(captureGraph); } } ```

## Example 7: License Activation

Activate purchased license.

### C# License Activation

```
public void PlayWithLicense(string filename, string licenseKey, IntPtr videoWindowHandle)
{
    var filterGraph = (IFilterGraph2)new FilterGraph();

    var sourceFilter = FilterGraphTools.AddFilterFromClsid(
        filterGraph,
        Consts.CLSID_VFVLCSource,
        "VLC Source");

    // Activate license
    var registration = sourceFilter as IVFRegister;
    if (registration != null)
    {
        int hr = registration.SetLicenseKey(licenseKey);
        if (hr != 0)
        {
            throw new Exception("License activation failed");
        }
    }

    // Load and play file
    var vlcSrc = sourceFilter as IVlcSrc;
    if (vlcSrc != null)
    {
        vlcSrc.SetFile(filename);
    }

    ICaptureGraphBuilder2 captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
    captureGraph.SetFiltergraph(filterGraph);

    captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
    captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);

    var videoWindow = (IVideoWindow)filterGraph;
    videoWindow.put_Owner(videoWindowHandle);
    videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);

    var mediaControl = (IMediaControl)filterGraph;
    mediaControl.Run();

    Marshal.ReleaseComObject(captureGraph);
}
```

---

## Example 8: Complete Multi-Track Player

Full-featured media player with all VLC Source features.

### C# Complete Example

```
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;
public class VLCMediaPlayer : IDisposable
{
    private IFilterGraph2 filterGraph;
    private ICaptureGraphBuilder2 captureGraph;
    private IMediaControl mediaControl;
    private IMediaSeeking mediaSeeking;
    private IVideoWindow videoWindow;
    private IMediaEventEx mediaEventEx;
    private IBaseFilter sourceFilter;
    private const int WM_GRAPHNOTIFY = 0x8000 + 1;
    public event EventHandler PlaybackComplete;
    public List<AudioTrackInfo> AudioTracks { get; private set; } = new List<AudioTrackInfo>();
    public List<SubtitleInfo> Subtitles { get; private set; } = new List<SubtitleInfo>();
    public class AudioTrackInfo
    {
        public int Index { get; set; }
        public int Id { get; set; }
        public string Name { get; set; }
    }
    public class SubtitleInfo
    {
        public int Index { get; set; }
        public int Id { get; set; }
        public string Name { get; set; }
    }
    public void Initialize(IntPtr windowHandle, IntPtr notifyHandle)
    {
        filterGraph = (IFilterGraph2)new FilterGraph();
        captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
        mediaControl = (IMediaControl)filterGraph;
        mediaSeeking = (IMediaSeeking)filterGraph;
        videoWindow = (IVideoWindow)filterGraph;
        mediaEventEx = (IMediaEventEx)filterGraph;
        int hr = mediaEventEx.SetNotifyWindow(notifyHandle, WM_GRAPHNOTIFY, IntPtr.Zero);
        DsError.ThrowExceptionForHR(hr);
        hr = captureGraph.SetFiltergraph(filterGraph);
        DsError.ThrowExceptionForHR(hr);
    }
    public void LoadFile(string filename, string licenseKey = null,
                        string vlcOptions = null, double? frameRate = null)
    {
        sourceFilter = FilterGraphTools.AddFilterFromClsid(
            filterGraph,
            Consts.CLSID_VFVLCSource,
            "VLC Source");
        // Register license
        if (!string.IsNullOrEmpty(licenseKey))
        {
            var registration = sourceFilter as IVFRegister;
            registration?.SetLicenseKey(licenseKey);
        }
        // Set custom VLC options
        if (!string.IsNullOrEmpty(vlcOptions))
        {
            var vlcSrc2 = sourceFilter as IVlcSrc2;
            if (vlcSrc2 != null)
            {
                // Parse space-separated options into list
                var parameters = new List<string>(vlcOptions.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries));
                var array = new IntPtr[parameters.Count];
                for (int i = 0; i < parameters.Count; i++)
                {
                    array[i] = StringHelper.NativeUtf8FromString(parameters[i]);
                }
                try
                {
                    vlcSrc2.SetCustomCommandLine(array, parameters.Count);
                }
                finally
                {
                    for (int i = 0; i < array.Length; i++)
                    {
                        Marshal.FreeHGlobal(array[i]);
                    }
                }
            }
        }
        // Set frame rate override
        if (frameRate.HasValue)
        {
            var vlcSrc3 = sourceFilter as IVlcSrc3;
            vlcSrc3?.SetDefaultFrameRate(frameRate.Value);
        }
        // Load file
        var vlcSrc = sourceFilter as IVlcSrc;
        if (vlcSrc != null)
        {
            int hr = vlcSrc.SetFile(filename);
            DsError.ThrowExceptionForHR(hr);
            // Enumerate audio tracks
            LoadAudioTracks(vlcSrc);
            // Enumerate subtitles
            LoadSubtitles(vlcSrc);
        }
        // Build graph
        int result = captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, null);
        result = captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);
    }
    private void LoadAudioTracks(IVlcSrc vlcSrc)
    {
        AudioTracks.Clear();
        int count = 0;
        vlcSrc.GetAudioTracksCount(out count);
        for (int i = 0; i < count; i++)
        {
            int id;
            StringBuilder name = new StringBuilder(256);
            vlcSrc.GetAudioTrackInfo(i, out id, name);
            AudioTracks.Add(new AudioTrackInfo
            {
                Index = i,
                Id = id,
                Name = name.ToString()
            });
        }
    }
    private void LoadSubtitles(IVlcSrc vlcSrc)
    {
        Subtitles.Clear();
        int count = 0;
        vlcSrc.GetSubtitlesCount(out count);
        for (int i = 0; i < count; i++)
        {
            int id;
            StringBuilder name = new StringBuilder(256);
            vlcSrc.GetSubtitleInfo(i, out id, name);
            Subtitles.Add(new SubtitleInfo
            {
                Index = i,
                Id = id,
                Name = name.ToString()
            });
        }
    }
    public void SetVideoWindow(IntPtr handle, int width, int height)
    {
        if (videoWindow != null)
        {
            videoWindow.put_Owner(handle);
            videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);
            videoWindow.SetWindowPosition(0, 0, width, height);
            videoWindow.put_Visible(OABool.True);
        }
    }
    public void Play() => mediaControl?.Run();
    public void Pause() => mediaControl?.Pause();
    public void Stop() => mediaControl?.Stop();
    public void SelectAudioTrack(int trackIndex)
    {
        var vlcSrc = sourceFilter as IVlcSrc;
        if (vlcSrc != null && trackIndex >= 0 && trackIndex < AudioTracks.Count)
        {
            vlcSrc.SetAudioTrack(AudioTracks[trackIndex].Id);
        }
    }
    public void SelectSubtitle(int subtitleIndex)
    {
        var vlcSrc = sourceFilter as IVlcSrc;
        if (vlcSrc != null)
        {
            if (subtitleIndex < 0)
            {
                vlcSrc.SetSubtitle(-1); // Disable
            }
            else if (subtitleIndex < Subtitles.Count)
            {
                vlcSrc.SetSubtitle(Subtitles[subtitleIndex].Id);
            }
        }
    }
    public void Seek(long timeInSeconds)
    {
        if (mediaSeeking != null)
        {
            long seekPos = timeInSeconds * 10000000;
            mediaSeeking.SetPositions(ref seekPos, AMSeekingSeekingFlags.AbsolutePositioning,
                                     IntPtr.Zero, AMSeekingSeekingFlags.NoPositioning);
        }
    }
    public long GetPosition()
    {
        if (mediaSeeking != null)
        {
            mediaSeeking.GetCurrentPosition(out long position);
            return position / 10000000;
        }
        return 0;
    }
    public long GetDuration()
    {
        if (mediaSeeking != null)
        {
            mediaSeeking.GetDuration(out long duration);
            return duration / 10000000;
        }
        return 0;
    }
    public void HandleGraphEvent()
    {
        if (mediaEventEx != null)
        {
            while (mediaEventEx.GetEvent(out EventCode eventCode, out IntPtr param1,
                                          out IntPtr param2, 0) == 0)
            {
                mediaEventEx.FreeEventParams(eventCode, param1, param2);
                if (eventCode == EventCode.Complete)
                {
                    PlaybackComplete?.Invoke(this, EventArgs.Empty);
                }
            }
        }
    }
    public void Dispose()
    {
        if (mediaControl != null)
        {
            mediaControl.Stop();
        }
        if (mediaEventEx != null)
        {
            mediaEventEx.SetNotifyWindow(IntPtr.Zero, 0, IntPtr.Zero);
        }
        if (videoWindow != null)
        {
            videoWindow.put_Visible(OABool.False);
            videoWindow.put_Owner(IntPtr.Zero);
        }
        FilterGraphTools.RemoveAllFilters(filterGraph);
        if (sourceFilter != null) Marshal.ReleaseComObject(sourceFilter);
        if (videoWindow != null) Marshal.ReleaseComObject(videoWindow);
        if (mediaSeeking != null) Marshal.ReleaseComObject(mediaSeeking);
        if (mediaEventEx != null) Marshal.ReleaseComObject(mediaEventEx);
        if (captureGraph != null) Marshal.ReleaseComObject(captureGraph);
        if (mediaControl != null) Marshal.ReleaseComObject(mediaControl);
        if (filterGraph != null) Marshal.ReleaseComObject(filterGraph);
    }
}
```

### Usage Example

## ``` public partial class MainForm : Form { private VLCMediaPlayer player; public MainForm() { InitializeComponent(); player = new VLCMediaPlayer(); } private void btnLoad_Click(object sender, EventArgs e) { OpenFileDialog dlg = new OpenFileDialog(); dlg.Filter = "Video Files|*.mp4;*.mkv;*.avi;*.mov|All Files|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { player.Initialize(panelVideo.Handle, this.Handle); // Custom VLC options for hardware decoding string vlcOptions = "--avcodec-hw=any --network-caching=1000"; player.LoadFile(dlg.FileName, vlcOptions: vlcOptions); player.SetVideoWindow(panelVideo.Handle, panelVideo.Width, panelVideo.Height); // Populate audio track combo box comboAudioTracks.Items.Clear(); foreach (var track in player.AudioTracks) { comboAudioTracks.Items.Add(track.Name); } if (comboAudioTracks.Items.Count > 0) { comboAudioTracks.SelectedIndex = 0; } // Populate subtitle combo box comboSubtitles.Items.Clear(); comboSubtitles.Items.Add("None"); foreach (var subtitle in player.Subtitles) { comboSubtitles.Items.Add(subtitle.Name); } comboSubtitles.SelectedIndex = 0; player.Play(); } } private void comboAudioTracks_SelectedIndexChanged(object sender, EventArgs e) { player.SelectAudioTrack(comboAudioTracks.SelectedIndex); } private void comboSubtitles_SelectedIndexChanged(object sender, EventArgs e) { player.SelectSubtitle(comboSubtitles.SelectedIndex - 1); // -1 because of "None" item } protected override void WndProc(ref Message m) { if (m.Msg == 0x8000 + 1) { player?.HandleGraphEvent(); } base.WndProc(ref m); } private void MainForm_FormClosing(object sender, FormClosingEventArgs e) { player?.Dispose(); } } ```

## Troubleshooting

### Issue: "Class not registered" Error

**Solution**: Ensure VLC Source filter is registered:

```
regsvr32 VisioForge_VLC_Source.ax
```

### Issue: Audio/Subtitle Track Count Returns 0

**Cause**: Tracks not yet available (filter graph not built yet)

**Solution**: Audio and subtitle information is only available after the file is loaded and the graph is built. Call track enumeration methods after `SetFile()` and building the graph.

```
// Load file first
pVlcSrc->SetFile(L"movie.mkv");

// Build filter graph
pGraph->RenderFile(L"movie.mkv", nullptr);

// NOW query tracks
int count = 0;
pVlcSrc->GetAudioTracksCount(&count);
```

### Issue: Custom VLC Options Not Working

**Solution**: Ensure VLC options are set before loading the file, and use the correct marshaling:

```
// Correct order and usage:
var vlcSrc2 = sourceFilter as IVlcSrc2;
if (vlcSrc2 != null)
{
    var parameters = new List<string>
    {
        "--network-caching=1000",
        "--rtsp-tcp"
    };

    var array = new IntPtr[parameters.Count];
    for (int i = 0; i < parameters.Count; i++)
    {
        array[i] = StringHelper.NativeUtf8FromString(parameters[i]);
    }

    try
    {
        vlcSrc2.SetCustomCommandLine(array, parameters.Count);  // 1. Set options first
    }
    finally
    {
        for (int i = 0; i < array.Length; i++)
        {
            Marshal.FreeHGlobal(array[i]);
        }
    }
}

var vlcSrc = sourceFilter as IVlcSrc;
vlcSrc?.SetFile(filename);  // 2. Then load file
// Build and run graph...
```

### Issue: RTSP Stream Has High Latency

**Solution**: Configure VLC for minimal network buffering and use TCP transport:

```
// C++ example
IVlcSrc2* pVlcSrc2 = nullptr;
hr = pFilter->QueryInterface(IID_IVlcSrc2, (void**)&pVlcSrc2);
if (SUCCEEDED(hr))
{
    const char* params[] = {
        "--network-caching=50",
        "--live-caching=50",
        "--rtsp-tcp",
        "--no-audio-time-stretch"
    };

    // Convert to wide strings and then to IntPtr equivalents
    // (In C++, you can pass ANSI/UTF-8 strings directly in some cases,
    // but for consistency with the interface, use proper conversion)

    pVlcSrc2->Release();
}
```

```
// C# example
var vlcSrc2 = sourceFilter as IVlcSrc2;
if (vlcSrc2 != null)
{
    var lowLatencyOptions = new List<string>
    {
        "--network-caching=50",
        "--live-caching=50",
        "--rtsp-tcp",
        "--no-audio-time-stretch"
    };

    var array = new IntPtr[lowLatencyOptions.Count];
    for (int i = 0; i < lowLatencyOptions.Count; i++)
    {
        array[i] = StringHelper.NativeUtf8FromString(lowLatencyOptions[i]);
    }

    try
    {
        vlcSrc2.SetCustomCommandLine(array, lowLatencyOptions.Count);
    }
    finally
    {
        for (int i = 0; i < array.Length; i++)
        {
            Marshal.FreeHGlobal(array[i]);
        }
    }
}
```

### Issue: Hardware Acceleration Not Working

**Solution**: Explicitly specify the hardware decoder to use:

```
// C++ example - Try explicit hardware decoder
IVlcSrc2* pVlcSrc2 = nullptr;
hr = pFilter->QueryInterface(IID_IVlcSrc2, (void**)&pVlcSrc2);
if (SUCCEEDED(hr))
{
    const char* params[] = {
        "--avcodec-hw=d3d11va"  // For Windows 8+
        // or "--avcodec-hw=dxva2" for Windows 7
    };

    // Proper conversion and calling required

    pVlcSrc2->Release();
}
```

```
// C# example
var vlcSrc2 = sourceFilter as IVlcSrc2;
if (vlcSrc2 != null)
{
    var hwOptions = new List<string>
    {
        "--avcodec-hw=dxva2"  // or d3d11va, nvdec, any
    };

    var array = new IntPtr[hwOptions.Count];
    for (int i = 0; i < hwOptions.Count; i++)
    {
        array[i] = StringHelper.NativeUtf8FromString(hwOptions[i]);
    }

    try
    {
        vlcSrc2.SetCustomCommandLine(array, hwOptions.Count);
    }
    finally
    {
        for (int i = 0; i < array.Length; i++)
        {
            Marshal.FreeHGlobal(array[i]);
        }
    }
}
```

---

## See Also

### Documentation

- [Interface Reference](../interface-reference/) - Complete API reference
- [Deployment Guide](../../deployment/) - Filter deployment

### External Resources

- [VLC Command-Line Documentation](https://www.videolan.org/doc/)
- [DirectShow Programming Guide](https://learn.microsoft.com/en-us/windows/win32/DirectShow/directshow)

---END OF PAGE---


## VLC Source DirectShow Filter - 200+ Formats & Streams
**URL:** https://www.visioforge.com/help/docs/directshow/vlc-source-filter/
**Description:** DirectShow source filter powered by libVLC for playing 200+ formats, 4K/8K video, and RTSP/HLS/UDP network streams with hardware decoding. C++, C#, Delphi.
**Tags:** DirectShow, C++, Windows, Streaming, Editing
**API:** IFileSourceFilter, IBaseFilter, IVFRegister

# VLC Source DirectShow Filter

## Overview

The VLC Source DirectShow filter empowers developers to seamlessly integrate advanced media playback capabilities into any DirectShow-based application. This powerful component enables smooth playback of various video files and network streams across multiple formats and protocols.

Our SDK package delivers a complete solution with all necessary VLC player DLLs bundled alongside a flexible DirectShow filter. The package provides both standard file-selection interfaces and extensive options for custom filter configurations to match your specific development requirements.

For complete product details and licensing options, visit the [product page](https://www.visioforge.com/vlc-source-directshow-filter).

---

## Installation

Before using the code samples and integrating the filter into your application, you must first install the VLC Source DirectShow Filter from the [product page](https://www.visioforge.com/vlc-source-directshow-filter).

**Installation Steps**:

1. Download the SDK installer from the product page
2. Run the installer with administrative privileges
3. The installer will register the VLC Source filter and deploy all necessary VLC DLLs
4. Sample applications and source code will be available in the installation directory

**Note**: The filter must be properly registered on the system before it can be used in your applications. The installer handles this automatically.

---

## Technical Specifications

### Supported DirectShow Interfaces

The filter implements these standard DirectShow interfaces for maximum compatibility:

- **IAMStreamSelect** - Comprehensive video and audio stream selection capabilities
- **IAMStreamConfig** - Advanced video and audio configuration settings
- **IFileSourceFilter** - Flexible specification of filename or URL sources
- **IMediaSeeking** - Robust timeline seeking and positioning support

### Key Features

- Hardware-accelerated decoding for optimal performance
- Support for 4K and 8K video playback
- Extensive format compatibility including modern codecs
- Network stream handling (RTSP, HLS, DASH, etc.)
- Subtitle rendering and management
- Multi-language audio track support
- 360° video playback capabilities
- HDR content support

## Implementation Examples

### C++ Integration Example

```
#include <dshow.h>
#include <mfapi.h>
#include <evr.h>
#include "ivlcsrc.h"

// VLC Source Filter CLSID
DEFINE_GUID(CLSID_VlcSource,
    0x3fc97748, 0x7cb6, 0x4195, 0x89, 0xde, 0x07, 0x17, 0x58, 0x2a, 0x48, 0x63);

HRESULT InitializeVLCSource(HWND hVideoWindow)
{
    HRESULT hr = S_OK;
    IFilterGraph2* pGraph = NULL;
    ICaptureGraphBuilder2* pBuild = NULL;
    IMediaControl* pControl = NULL;
    IBaseFilter* pVLCSource = NULL;
    IBaseFilter* pVideoRenderer = NULL;
    IFileSourceFilter* pFileSource = NULL;

    // Initialize COM
    CoInitialize(NULL);

    // Create the filter graph manager
    hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
                         IID_IFilterGraph2, (void**)&pGraph);
    if (FAILED(hr))
        return hr;

    // Create the Capture Graph Builder
    hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER,
                         IID_ICaptureGraphBuilder2, (void**)&pBuild);
    if (FAILED(hr))
        goto cleanup;

    // Set the filter graph to the capture graph builder
    hr = pBuild->SetFiltergraph(pGraph);
    if (FAILED(hr))
        goto cleanup;

    // Create the VLC Source filter
    hr = CoCreateInstance(CLSID_VlcSource, NULL, CLSCTX_INPROC_SERVER,
                         IID_IBaseFilter, (void**)&pVLCSource);
    if (FAILED(hr))
        goto cleanup;

    // Add the filter to the graph
    hr = pGraph->AddFilter(pVLCSource, L"VLC Source");
    if (FAILED(hr))
        goto cleanup;

    // Load the media file using IFileSourceFilter interface
    hr = pVLCSource->QueryInterface(IID_IFileSourceFilter, (void**)&pFileSource);
    if (SUCCEEDED(hr) && pFileSource)
    {
        hr = pFileSource->Load(L"C:\\media\\sample.mp4", NULL);
        pFileSource->Release();
        if (FAILED(hr))
            goto cleanup;
    }

    // Create Enhanced Video Renderer (EVR)
    CLSID CLSID_EVR = { 0xFA10746C, 0x9B63, 0x4B6C,
        { 0xBC, 0x49, 0xFC, 0x30, 0x0E, 0xA5, 0xF2, 0x56 } };
    hr = CoCreateInstance(CLSID_EVR, NULL, CLSCTX_INPROC_SERVER,
                         IID_IBaseFilter, (void**)&pVideoRenderer);
    if (FAILED(hr))
        goto cleanup;

    hr = pGraph->AddFilter(pVideoRenderer, L"EVR");
    if (FAILED(hr))
        goto cleanup;

    // Configure EVR
    IEVRFilterConfig* pConfig = NULL;
    hr = pVideoRenderer->QueryInterface(IID_IEVRFilterConfig, (void**)&pConfig);
    if (SUCCEEDED(hr) && pConfig)
    {
        pConfig->SetNumberOfStreams(1);
        pConfig->Release();
    }

    // Set video window
    IMFGetService* pGetService = NULL;
    hr = pVideoRenderer->QueryInterface(IID_IMFGetService, (void**)&pGetService);
    if (SUCCEEDED(hr) && pGetService)
    {
        IMFVideoDisplayControl* pDisplayControl = NULL;
        hr = pGetService->GetService(MR_VIDEO_RENDER_SERVICE,
                                     IID_IMFVideoDisplayControl,
                                     (void**)&pDisplayControl);
        if (SUCCEEDED(hr) && pDisplayControl)
        {
            pDisplayControl->SetVideoWindow(hVideoWindow);
            pDisplayControl->Release();
        }
        pGetService->Release();
    }

    // Render the streams
    hr = pBuild->RenderStream(NULL, &MEDIATYPE_Video, pVLCSource, NULL, pVideoRenderer);
    if (FAILED(hr))
        goto cleanup;

    hr = pBuild->RenderStream(NULL, &MEDIATYPE_Audio, pVLCSource, NULL, NULL);
    // Audio errors are not critical

    // Get the media control interface for playback control
    hr = pGraph->QueryInterface(IID_IMediaControl, (void**)&pControl);
    if (SUCCEEDED(hr))
    {
        // Start playback
        hr = pControl->Run();
    }

cleanup:
    // Release interfaces
    if (pControl) pControl->Release();
    if (pVideoRenderer) pVideoRenderer->Release();
    if (pVLCSource) pVLCSource->Release();
    if (pBuild) pBuild->Release();
    if (pGraph) pGraph->Release();

    return hr;
}
```

### C# Integration (.NET)

```
using System;
using System.Runtime.InteropServices;
using MediaFoundation;
using MediaFoundation.EVR;
using VisioForge.DirectShowAPI;
using VisioForge.DirectShowLib;

// Initialize the VLC Source filter in C# using DirectShowLib
public class VLCSourcePlayer
{
    private IFilterGraph2 filterGraph;
    private ICaptureGraphBuilder2 captureGraph;
    private IMediaControl mediaControl;
    private IMediaSeeking mediaSeeking;
    private IMediaEventEx mediaEventEx;
    private IBaseFilter sourceFilter;
    private IBaseFilter videoRenderer;

    public void Initialize(string filename, IntPtr videoWindowHandle)
    {
        try
        {
            // Create the filter graph manager
            filterGraph = (IFilterGraph2)new FilterGraph();
            captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
            mediaControl = (IMediaControl)filterGraph;
            mediaSeeking = (IMediaSeeking)filterGraph;
            mediaEventEx = (IMediaEventEx)filterGraph;

            // Attach the filter graph to the capture graph
            int hr = captureGraph.SetFiltergraph(filterGraph);
            DsError.ThrowExceptionForHR(hr);

            // Create the VLC Source filter using the correct CLSID
            sourceFilter = FilterGraphTools.AddFilterFromClsid(
                filterGraph,
                Consts.CLSID_VFVLCSource,
                "VLC Source");

            // Optional: Register purchased version
            // var reg = sourceFilter as IVFRegister;
            // reg?.SetLicenseKey("your-license-key-here");

            // Load the media file or URL using IFileSourceFilter interface
            var sourceFilterIntf = sourceFilter as IFileSourceFilter;
            hr = sourceFilterIntf.Load(filename, null);
            DsError.ThrowExceptionForHR(hr);

            // Create video renderer (EVR - Enhanced Video Renderer)
            Guid CLSID_EVR = new Guid("FA10746C-9B63-4B6C-BC49-FC300EA5F256");
            videoRenderer = FilterGraphTools.AddFilterFromClsid(filterGraph, CLSID_EVR, "EVR");

            // Configure EVR
            var evrConfig = videoRenderer as IEVRFilterConfig;
            evrConfig?.SetNumberOfStreams(1);

            // Set video window for rendering
            var getService = videoRenderer as MediaFoundation.IMFGetService;
            if (getService != null)
            {
                getService.GetService(
                    MediaFoundation.MFServices.MR_VIDEO_RENDER_SERVICE,
                    typeof(MediaFoundation.IMFVideoDisplayControl).GUID,
                    out var videoDisplayControlObj);

                var videoDisplayControl = videoDisplayControlObj as MediaFoundation.IMFVideoDisplayControl;
                videoDisplayControl?.SetVideoWindow(videoWindowHandle);
            }

            // Render the streams
            hr = captureGraph.RenderStream(null, MediaType.Video, sourceFilter, null, videoRenderer);
            DsError.ThrowExceptionForHR(hr);

            hr = captureGraph.RenderStream(null, MediaType.Audio, sourceFilter, null, null);
            // Note: Audio rendering errors are not critical for video-only playback

            // Start playback
            hr = mediaControl.Run();
            DsError.ThrowExceptionForHR(hr);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error initializing VLC Source: {ex.Message}");
            Cleanup();
            throw;
        }
    }

    public void Cleanup()
    {
        // Stop playback
        if (mediaControl != null)
        {
            mediaControl.StopWhenReady();
            mediaControl.Stop();
        }

        // Stop receiving events
        mediaEventEx?.SetNotifyWindow(IntPtr.Zero, 0, IntPtr.Zero);

        // Remove all filters
        FilterGraphTools.RemoveAllFilters(filterGraph);

        // Release DirectShow interfaces
        if (mediaControl != null)
        {
            Marshal.ReleaseComObject(mediaControl);
            mediaControl = null;
        }

        if (mediaSeeking != null)
        {
            Marshal.ReleaseComObject(mediaSeeking);
            mediaSeeking = null;
        }

        if (mediaEventEx != null)
        {
            Marshal.ReleaseComObject(mediaEventEx);
            mediaEventEx = null;
        }

        if (sourceFilter != null)
        {
            Marshal.ReleaseComObject(sourceFilter);
            sourceFilter = null;
        }

        if (videoRenderer != null)
        {
            Marshal.ReleaseComObject(videoRenderer);
            videoRenderer = null;
        }

        if (captureGraph != null)
        {
            Marshal.ReleaseComObject(captureGraph);
            captureGraph = null;
        }

        if (filterGraph != null)
        {
            Marshal.ReleaseComObject(filterGraph);
            filterGraph = null;
        }
    }
}
```

**Key CLSIDs and GUIDs:**

```
// VLC Source Filter CLSID
public static readonly Guid CLSID_VFVLCSource = new Guid("3FC97748-7CB6-4195-89DE-0717582A4863");

// IVlcSrc Interface IID
[Guid("77493EB7-6D00-41C5-9535-7C593824E892")]
public interface IVlcSrc { /* ... */ }

// IVlcSrc2 Interface IID (for custom command-line parameters)
[Guid("CCE122C0-172C-4626-B4B6-42B039E541CB")]
public interface IVlcSrc2 : IVlcSrc { /* ... */ }

// IVlcSrc3 Interface IID (for frame rate override)
[Guid("3DFBED0C-E4A8-401C-93EF-CBBFB65223DD")]
public interface IVlcSrc3 : IVlcSrc2 { /* ... */ }

// IVFRegister Interface IID (for licensing)
[Guid("59E82754-B531-4A8E-A94D-57C75F01DA30")]
public interface IVFRegister { /* ... */ }
```

**Required NuGet Packages:**

- `VisioForge.DirectShowAPI` - DirectShow wrapper library
- `MediaFoundation.Net` - Media Foundation wrapper for EVR renderer

**Audio Track Selection Example:**

```
// Enumerate and select audio tracks
var vlcSrc = sourceFilter as IVlcSrc;
if (vlcSrc != null)
{
    int audioCount = 0;
    vlcSrc.GetAudioTracksCount(out audioCount);

    for (int i = 0; i < audioCount; i++)
    {
        int trackId;
        var trackName = new StringBuilder(256);
        vlcSrc.GetAudioTrackInfo(i, out trackId, trackName);

        Console.WriteLine($"Track {i}: {trackName} (ID: {trackId})");
    }

    // Select specific audio track
    if (audioCount > 1)
    {
        int desiredTrackId;
        var name = new StringBuilder(256);
        vlcSrc.GetAudioTrackInfo(1, out desiredTrackId, name);
        vlcSrc.SetAudioTrack(desiredTrackId);
    }
}
```

**Custom VLC Options Example:**

`IVlcSrc2::SetCustomCommandLine` takes an array of UTF-8 native strings (`char* params[]` in `ivlcsrc.h`), not a managed `string[]`. The C# wrapper marshals the parameters as `IntPtr[]` of unmanaged UTF-8 buffers — allocate with `StringHelper.NativeUtf8FromString()` and free with `Marshal.FreeHGlobal()` after the call. Passing a raw `string[]` would marshal as ANSI and corrupt non-ASCII flags.

```
// Configure VLC for low-latency RTSP streaming
var vlcSrc2 = sourceFilter as IVlcSrc2;
if (vlcSrc2 != null)
{
    var parameters = new[]
    {
        "--network-caching=300",     // Low network buffer
        "--rtsp-tcp",                // Force TCP for RTSP
        "--avcodec-hw=any",          // Enable hardware decoding
        "--live-caching=300"         // Low live stream buffer
    };

    // Convert managed strings to native UTF-8 IntPtr array
    var array = new IntPtr[parameters.Length];
    for (int i = 0; i < parameters.Length; i++)
    {
        array[i] = StringHelper.NativeUtf8FromString(parameters[i]);
    }

    try
    {
        int hr = vlcSrc2.SetCustomCommandLine(array, parameters.Length);
        DsError.ThrowExceptionForHR(hr);
    }
    finally
    {
        // Free unmanaged UTF-8 buffers
        for (int i = 0; i < array.Length; i++)
        {
            Marshal.FreeHGlobal(array[i]);
        }
    }

    // Then load the stream
    var vlcSrc = vlcSrc2 as IVlcSrc;
    vlcSrc?.SetFile("rtsp://192.168.1.100/stream");
}
```

See [examples.md](examples/) for the canonical helper pattern reused across multiple scenarios (Example 4 binary key with custom flags, low-latency variants, etc.).

## Version History

### Version 2026.3.4

- Updated to VLC v3.0.23 core
- Upgraded build toolset to MSVC v143 (Visual Studio 2022)
- Fixed crash on graph teardown during `libvlc_media_player_stop()`
- Replaced Boost dependencies with C++ standard library equivalents

### Version 15.0

- Enhanced playback quality across numerous formats
- Improved subtitle rendering engine
- Updated codec implementations including dav1d, ffmpeg, and libvpx
- Added Super Resolution scaling with nVidia and Intel GPU acceleration

### Version 14.0

- Updated to VLC v3.0.18 core
- Fixed DxVA/D3D11 compatibility issues with HEVC content
- Resolved OpenGL resizing problems for smoother playback

### Version 12.0

- Upgraded to VLC v3.0.16 engine
- Added support for new Fourcc formats (E-AC3 and AV1)
- Fixed stability issues with VP9 streams

### Version 11.1

- Incorporated VLC v3.0.11
- Optimized HLS playlist update mechanism
- Enhanced WebVTT subtitle handling and display

### Version 11.0

- Built on VLC v3.0.10 foundation
- Fixed critical regression issues with HLS streams

### Version 10.4

- Major update to VLC 3.0 architecture
- Enabled hardware decoding by default for 4K and 8K content
- Added 10-bit color depth and HDR support
- Implemented 360-degree video and 3D audio capabilities
- Introduced Blu-Ray Java menu support

### Version 10.0

- Initial release as a standalone DirectShow filter
- For earlier version history, please refer to Video Capture SDK .Net changelog

## Additional Resources

- [End User License Agreement](../../eula/)
- [Code Samples](https://github.com/visioforge/)

---END OF PAGE---


## VLC Source DirectShow Filter Full Interface Reference
**URL:** https://www.visioforge.com/help/docs/directshow/vlc-source-filter/interface-reference/
**Description:** IVlcSrc family interfaces for multi-track audio, subtitle support, and custom VLC command-line options in DirectShow applications.
**Tags:** DirectShow, C++, Windows, IP Camera, RTSP, HLS, MP4, MKV, C#
**API:** IBaseFilter

# VLC Source Filter Interface Reference

## Overview

The VLC Source DirectShow filter exposes three progressive interfaces (`IVlcSrc`, `IVlcSrc2`, `IVlcSrc3`) that provide comprehensive control over media playback, audio/subtitle track selection, and VLC configuration. These interfaces enable developers to leverage VLC's powerful media framework within DirectShow applications.

## Interface Hierarchy

```
IUnknown
  └── IVlcSrc
        └── IVlcSrc2
              └── IVlcSrc3
```

Each interface extends the previous one, adding new capabilities while maintaining backward compatibility.

---

## IVlcSrc Interface

The base interface providing essential file loading and track selection capabilities.

### Interface Definition

- **Interface Name**: `IVlcSrc`
- **GUID**: `{77493EB7-6D00-41C5-9535-7C593824E892}`
- **Inherits From**: `IUnknown`
- **Header File**: `ivlcsrc.h` (C++), `IVlcSrc.cs` (.NET)

### Methods

#### SetFile

Sets the media file or URL to play. **Syntax (C++)**:

```
HRESULT SetFile(WCHAR *file);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetFile([MarshalAs(UnmanagedType.LPWStr)] string file);
```

**Parameters**: - `file`: Wide-character string containing the file path or URL. **Returns**: `S_OK` (0) on success, error code otherwise. **Supported Sources**: - Local files: `C:\Videos\movie.mp4` - HTTP streams: `https://example.com/stream.m3u8` - RTSP streams: `rtsp://example.com/live` - HLS playlists: `https://example.com/playlist.m3u8` - DASH streams: `https://example.com/manifest.mpd` - DVB-T/C/S broadcasts - Network shares: `\\server\share\video.mkv` **Example (C++)**:

```
IVlcSrc* pVlcSrc = nullptr;
pFilter->QueryInterface(IID_IVlcSrc, (void**)&pVlcSrc);
pVlcSrc->SetFile(L"C:\\Videos\\movie.mkv");
pVlcSrc->Release();
```

**Example (C#)**:

```
var vlcSrc = filter as IVlcSrc;
if (vlcSrc != null)
{
    vlcSrc.SetFile(@"C:\Videos\movie.mkv");
}
```

---

### Audio Track Management

#### GetAudioTracksCount

Retrieves the total number of available audio tracks.

**Syntax (C++)**:

```
HRESULT GetAudioTracksCount(int *count);
```

**Syntax (C#)**:

```
[PreserveSig]
int GetAudioTracksCount(out int count);
```

**Parameters**:

- `count`: [out] Receives the number of audio tracks.

**Returns**: `S_OK` (0) on success.

**Usage Notes**:

- Call after the file is loaded and the filter graph is built
- Returns 0 if no audio tracks are available or file not loaded

**Example (C++)**:

```
int audioCount = 0;
pVlcSrc->GetAudioTracksCount(&audioCount);
printf("Audio tracks: %d\n", audioCount);
```

---

#### GetAudioTrackInfo

Retrieves information about a specific audio track. **Syntax (C++)**:

```
HRESULT GetAudioTrackInfo(int number, int *id, WCHAR *name);
```

**Syntax (C#)**:

```
[PreserveSig]
int GetAudioTrackInfo(int number, out int id,
                      [MarshalAs(UnmanagedType.LPWStr)] StringBuilder name);
```

**Parameters**: - `number`: Zero-based track index (0 to count-1). - `id`: [out] Receives the track ID. - `name`: [out] Buffer to receive the track name (must be pre-allocated, minimum 256 characters). **Returns**: `S_OK` (0) on success. **Usage Notes**: - Pre-allocate name buffer with at least 256 wide characters - Track names typically include language and codec information - Track ID is used with SetAudioTrack() **Example (C++)**:

```
int audioCount = 0;
pVlcSrc->GetAudioTracksCount(&audioCount);
for (int i = 0; i < audioCount; i++)
{
    int id = 0;
    WCHAR name[256] = {0};
    pVlcSrc->GetAudioTrackInfo(i, &id, name);
    wprintf(L"Track %d - ID: %d, Name: %s\n", i, id, name);
}
```

**Example (C#)**:

```
int count = 0;
vlcSrc.GetAudioTracksCount(out count);
for (int i = 0; i < count; i++)
{
    int id;
    var name = new StringBuilder(256);
    vlcSrc.GetAudioTrackInfo(i, out id, name);
    Console.WriteLine($"Track {i} - ID: {id}, Name: {name}");
}
```

---

#### GetAudioTrack

Retrieves the ID of the currently active audio track.

**Syntax (C++)**:

```
HRESULT GetAudioTrack(int *id);
```

**Syntax (C#)**:

```
[PreserveSig]
int GetAudioTrack(out int id);
```

**Parameters**:

- `id`: [out] Receives the current audio track ID.

**Returns**: `S_OK` (0) on success.

**Example (C++)**:

```
int currentTrack = 0;
pVlcSrc->GetAudioTrack(&currentTrack);
printf("Current audio track ID: %d\n", currentTrack);
```

---

#### SetAudioTrack

Sets the active audio track by ID. **Syntax (C++)**:

```
HRESULT SetAudioTrack(int id);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetAudioTrack(int id);
```

**Parameters**: - `id`: The track ID to activate (obtained from GetAudioTrackInfo). **Returns**: `S_OK` (0) on success, error code if track ID is invalid. **Usage Notes**: - Can be called during playback to switch tracks dynamically - Use -1 to disable all audio tracks - Track switching may cause brief audio interruption **Example (C++)**:

```
// Switch to second audio track
int trackId = 0;
pVlcSrc->GetAudioTrackInfo(1, &trackId, nullptr);
pVlcSrc->SetAudioTrack(trackId);
```

**Example (C#)**:

```
// Switch to first audio track
int trackId;
var name = new StringBuilder(256);
vlcSrc.GetAudioTrackInfo(0, out trackId, name);
vlcSrc.SetAudioTrack(trackId);
```

---

### Subtitle Track Management

#### GetSubtitlesCount

Retrieves the total number of available subtitle tracks.

**Syntax (C++)**:

```
HRESULT GetSubtitlesCount(int *count);
```

**Syntax (C#)**:

```
[PreserveSig]
int GetSubtitlesCount(out int count);
```

**Parameters**:

- `count`: [out] Receives the number of subtitle tracks.

**Returns**: `S_OK` (0) on success.

**Example (C++)**:

```
int subtitleCount = 0;
pVlcSrc->GetSubtitlesCount(&subtitleCount);
printf("Subtitle tracks: %d\n", subtitleCount);
```

---

#### GetSubtitleInfo

Retrieves information about a specific subtitle track. **Syntax (C++)**:

```
HRESULT GetSubtitleInfo(int number, int *id, WCHAR *name);
```

**Syntax (C#)**:

```
[PreserveSig]
int GetSubtitleInfo(int number, out int id,
                    [MarshalAs(UnmanagedType.LPWStr)] StringBuilder name);
```

**Parameters**: - `number`: Zero-based track index (0 to count-1). - `id`: [out] Receives the subtitle track ID. - `name`: [out] Buffer to receive the subtitle track name (minimum 256 characters). **Returns**: `S_OK` (0) on success. **Example (C++)**:

```
int subCount = 0;
pVlcSrc->GetSubtitlesCount(&subCount);
for (int i = 0; i < subCount; i++)
{
    int id = 0;
    WCHAR name[256] = {0};
    pVlcSrc->GetSubtitleInfo(i, &id, name);
    wprintf(L"Subtitle %d - ID: %d, Name: %s\n", i, id, name);
}
```

---

#### GetSubtitle

Retrieves the ID of the currently active subtitle track.

**Syntax (C++)**:

```
HRESULT GetSubtitle(int *id);
```

**Syntax (C#)**:

```
[PreserveSig]
int GetSubtitle(out int id);
```

**Parameters**:

- `id`: [out] Receives the current subtitle track ID.

**Returns**: `S_OK` (0) on success.

---

#### SetSubtitle

Sets the active subtitle track by ID. **Syntax (C++)**:

```
HRESULT SetSubtitle(int id);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetSubtitle(int id);
```

**Parameters**: - `id`: The subtitle track ID to activate. **Returns**: `S_OK` (0) on success. **Usage Notes**: - Use -1 to disable subtitles - Subtitle rendering is performed by VLC's internal renderer - Can be switched during playback **Example (C++)**:

```
// Enable first subtitle track
int subtitleId = 0;
pVlcSrc->GetSubtitleInfo(0, &subtitleId, nullptr);
pVlcSrc->SetSubtitle(subtitleId);
// Disable subtitles
pVlcSrc->SetSubtitle(-1);
```

---

## IVlcSrc2 Interface

Extends `IVlcSrc` with custom VLC command-line parameter support.

### Interface Definition

- **Interface Name**: `IVlcSrc2`
- **GUID**: `{CCE122C0-172C-4626-B4B6-42B039E541CB}`
- **Inherits From**: `IVlcSrc`
- **Header File**: `ivlcsrc.h` (C++), `IVlcSrc.cs` (.NET)

### Methods

#### SetCustomCommandLine

Sets custom VLC command-line parameters.

**Syntax (C++)**:

```
HRESULT SetCustomCommandLine(char* params[], int length);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetCustomCommandLine([In][Out][MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPStr)] IntPtr[] params_,
                         int size);
```

**Parameters**:

- `params_`: Array of IntPtr pointers to UTF-8 encoded strings containing VLC command-line parameters.
- `size`: Number of parameters in the array.

**Returns**: `S_OK` (0) on success.

**Usage Notes**:

- Must be called **before** loading the media file with SetFile()
- Parameters must be converted to native UTF-8 IntPtr using StringHelper.NativeUtf8FromString()
- Memory allocated for IntPtr parameters must be freed after the call using Marshal.FreeHGlobal()
- Parameters are passed directly to libVLC initialization
- Invalid parameters are ignored with warnings in VLC log
- Use standard VLC command-line syntax (see VLC documentation)

**Common VLC Parameters**:

| Parameter | Description | Example Value |
| --- | --- | --- |
| `--network-caching` | Network caching in ms | `1000` |
| `--file-caching` | File caching in ms | `300` |
| `--live-caching` | Live stream caching in ms | `300` |
| `--avcodec-hw` | Hardware acceleration | `any`, `dxva2`, `d3d11va` |
| `--verbose` | Logging verbosity | `2` |
| `--rtsp-tcp` | Force RTSP over TCP | (flag, no value) |
| `--no-audio` | Disable audio | (flag, no value) |
| `--sout-mux-caching` | Output muxer caching | `1000` |

**Example (C++)**:

```
IVlcSrc2* pVlcSrc2 = nullptr;
pFilter->QueryInterface(IID_IVlcSrc2, (void**)&pVlcSrc2);

// Configure for low-latency RTSP
char* params[] = {
    "--network-caching=300",
    "--rtsp-tcp",
    "--avcodec-hw=d3d11va",
    "--verbose=2"
};

pVlcSrc2->SetCustomCommandLine(params, 4);
pVlcSrc2->SetFile(L"rtsp://192.168.1.100/stream");

pVlcSrc2->Release();
```

**Example (C#)**:

```
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using VisioForge.Core.Helpers;

var vlcSrc2 = filter as IVlcSrc2;
if (vlcSrc2 != null)
{
    // Enable hardware acceleration and adjust caching
    var parameters = new List<string>
    {
        "--avcodec-hw=any",
        "--network-caching=1000",
        "--file-caching=300"
    };

    // Convert strings to native UTF-8 IntPtr array
    var array = new IntPtr[parameters.Count];
    for (int i = 0; i < parameters.Count; i++)
    {
        array[i] = StringHelper.NativeUtf8FromString(parameters[i]);
    }

    try
    {
        vlcSrc2.SetCustomCommandLine(array, parameters.Count);
        vlcSrc2.SetFile(@"C:\Videos\movie.mkv");
    }
    finally
    {
        // Free allocated unmanaged memory
        for (int i = 0; i < array.Length; i++)
        {
            Marshal.FreeHGlobal(array[i]);
        }
    }
}
```

**Example (Delphi)**:

libVLC parses the command line as **UTF-8**, not the system ANSI codepage. `PAnsiChar` literals are ASCII-safe but corrupt non-ASCII characters; encode each parameter to UTF-8 explicitly via `UTF8Encode` (or store an `AnsiString` with `CP_UTF8`). For a pure-ASCII parameter set, `PAnsiChar` literals happen to round-trip cleanly, but the snippet below uses the safe pattern.

```
var
  VlcSrc2: IVlcSrc2;
  P0, P1, P2: AnsiString;
  Params: array[0..2] of PAnsiChar;
begin
  if Succeeded(Filter.QueryInterface(IID_IVlcSrc2, VlcSrc2)) then
  begin
    P0 := UTF8Encode('--network-caching=500');
    P1 := UTF8Encode('--rtsp-tcp');
    P2 := UTF8Encode('--avcodec-hw=dxva2');
    Params[0] := PAnsiChar(P0);
    Params[1] := PAnsiChar(P1);
    Params[2] := PAnsiChar(P2);

    VlcSrc2.SetCustomCommandLine(@Params, 3);
    VlcSrc2.SetFile('rtsp://example.com/stream');
  end;
end;
```

---

## IVlcSrc3 Interface

Extends `IVlcSrc2` with frame rate override capability.

### Interface Definition

- **Interface Name**: `IVlcSrc3`
- **GUID**: `{3DFBED0C-E4A8-401C-93EF-CBBFB65223DD}`
- **Inherits From**: `IVlcSrc2`
- **Header File**: `ivlcsrc.h` (C++), `IVlcSrc.cs` (.NET)

### Methods

#### SetDefaultFrameRate

Sets a default frame rate for media without frame rate information. **Syntax (C++)**:

```
HRESULT SetDefaultFrameRate(double frameRate);
```

**Syntax (C#)**:

```
[PreserveSig]
int SetDefaultFrameRate(double frameRate);
```

**Parameters**: - `frameRate`: Frame rate in frames per second (e.g., 29.97, 30.0, 25.0, 60.0). **Returns**: `S_OK` (0) on success. **Usage Notes**: - Must be called **before** loading the media file - Used when source media doesn't specify frame rate - Particularly useful for network streams without timing information - Common values: 23.976, 24.0, 25.0, 29.97, 30.0, 50.0, 59.94, 60.0 **Example (C++)**:

```
IVlcSrc3* pVlcSrc3 = nullptr;
pFilter->QueryInterface(IID_IVlcSrc3, (void**)&pVlcSrc3);
// Set default frame rate for MJPEG IP camera stream
pVlcSrc3->SetDefaultFrameRate(30.0);
pVlcSrc3->SetFile(L"http://192.168.1.50/video.mjpg");
pVlcSrc3->Release();
```

**Example (C#)**:

```
var vlcSrc3 = filter as IVlcSrc3;
if (vlcSrc3 != null)
{
    // Set PAL frame rate for DV stream
    vlcSrc3.SetDefaultFrameRate(25.0);
    vlcSrc3.SetFile(@"dv://0");
}
```

---

## Complete Usage Examples

### Example 1: Multi-Language Movie Playback (C++)

```
#include <dshow.h>
#include "ivlcsrc.h"

void PlayMovieWithAudioSelection(IBaseFilter* pVlcFilter)
{
    HRESULT hr;
    IVlcSrc* pVlcSrc = nullptr;

    hr = pVlcFilter->QueryInterface(IID_IVlcSrc, (void**)&pVlcSrc);
    if (FAILED(hr))
        return;

    // Load movie
    pVlcSrc->SetFile(L"C:\\Movies\\multilang_movie.mkv");

    // Build and run the graph here...
    // (IGraphBuilder::RenderFile, IMediaControl::Run, etc.)

    // Enumerate audio tracks
    int audioCount = 0;
    pVlcSrc->GetAudioTracksCount(&audioCount);

    wprintf(L"Available audio tracks:\n");
    for (int i = 0; i < audioCount; i++)
    {
        int id = 0;
        WCHAR name[256] = {0};
        pVlcSrc->GetAudioTrackInfo(i, &id, name);
        wprintf(L"  [%d] %s (ID: %d)\n", i, name, id);
    }

    // Select English audio track (assuming it's track 1)
    int englishTrackId = 0;
    pVlcSrc->GetAudioTrackInfo(1, &englishTrackId, nullptr);
    pVlcSrc->SetAudioTrack(englishTrackId);

    // Enable subtitles
    int subCount = 0;
    pVlcSrc->GetSubtitlesCount(&subCount);
    if (subCount > 0)
    {
        int subId = 0;
        pVlcSrc->GetSubtitleInfo(0, &subId, nullptr);
        pVlcSrc->SetSubtitle(subId);
    }

    pVlcSrc->Release();
}
```

### Example 2: Low-Latency RTSP Stream (C#)

```
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
using DirectShowLib;
using VisioForge.Core.Helpers;
using VisioForge.DirectShowAPI;

public class VLCRTSPPlayer
{
    public void SetupLowLatencyRTSP(IBaseFilter vlcFilter)
    {
        // Get IVlcSrc3 interface (highest version)
        var vlcSrc3 = vlcFilter as IVlcSrc3;
        if (vlcSrc3 == null)
            throw new NotSupportedException("IVlcSrc3 not available");

        // Configure VLC for minimal latency
        var parameters = new List<string>
        {
            "--network-caching=50",       // Minimal network buffer
            "--live-caching=50",          // Minimal live buffer
            "--rtsp-tcp",                 // Use TCP transport
            "--no-audio-time-stretch",    // Disable audio stretching
            "--avcodec-hw=d3d11va",      // Hardware decoding
            "--verbose=0"                 // Reduce logging
        };

        // Convert to IntPtr array
        var array = new IntPtr[parameters.Count];
        for (int i = 0; i < parameters.Count; i++)
        {
            array[i] = StringHelper.NativeUtf8FromString(parameters[i]);
        }

        try
        {
            int hr = vlcSrc3.SetCustomCommandLine(array, parameters.Count);
            DsError.ThrowExceptionForHR(hr);

            // Set frame rate for IP camera
            hr = vlcSrc3.SetDefaultFrameRate(25.0);
            DsError.ThrowExceptionForHR(hr);

            // Load RTSP stream
            hr = vlcSrc3.SetFile("rtsp://admin:password@192.168.1.100:554/stream1");
            DsError.ThrowExceptionForHR(hr);
        }
        finally
        {
            // Free allocated memory
            for (int i = 0; i < array.Length; i++)
            {
                Marshal.FreeHGlobal(array[i]);
            }
        }

        // Build filter graph and start playback...
    }
}
```

### Example 3: Subtitle Track Switching UI (Delphi)

```
unit VLCSubtitles;

interface

uses
  Winapi.Windows, System.Classes, Vcl.Controls, Vcl.StdCtrls,
  DSPack, ivlcsrc;

type
  TSubtitleForm = class(TForm)
    ComboBoxSubtitles: TComboBox;
    procedure FormCreate(Sender: TObject);
    procedure ComboBoxSubtitlesChange(Sender: TObject);
  private
    FVlcSrc: IVlcSrc;
    FSubtitleIDs: TArray<Integer>;
    procedure LoadSubtitleTracks;
  public
    procedure SetVLCFilter(Filter: IBaseFilter);
  end;

implementation

procedure TSubtitleForm.SetVLCFilter(Filter: IBaseFilter);
begin
  if Succeeded(Filter.QueryInterface(IID_IVlcSrc, FVlcSrc)) then
  begin
    LoadSubtitleTracks;
  end;
end;

procedure TSubtitleForm.LoadSubtitleTracks;
var
  Count, I, ID: Integer;
  Name: array[0..255] of WideChar;
begin
  ComboBoxSubtitles.Clear;
  ComboBoxSubtitles.Items.Add('Disabled');

  if FVlcSrc.GetSubtitlesCount(Count) = S_OK then
  begin
    SetLength(FSubtitleIDs, Count + 1);
    FSubtitleIDs[0] := -1; // Disabled

    for I := 0 to Count - 1 do
    begin
      if FVlcSrc.GetSubtitleInfo(I, ID, Name) = S_OK then
      begin
        FSubtitleIDs[I + 1] := ID;
        ComboBoxSubtitles.Items.Add(Name);
      end;
    end;
  end;

  ComboBoxSubtitles.ItemIndex := 0;
end;

procedure TSubtitleForm.ComboBoxSubtitlesChange(Sender: TObject);
var
  Index: Integer;
begin
  Index := ComboBoxSubtitles.ItemIndex;
  if (Index >= 0) and (Index < Length(FSubtitleIDs)) then
  begin
    FVlcSrc.SetSubtitle(FSubtitleIDs[Index]);
  end;
end;

end.
```

## Best Practices

### Track Management

1. **Always enumerate tracks after building the filter graph** - Track information is not available until the source is loaded
2. **Handle files with no audio/subtitles gracefully** - Check count before accessing tracks
3. **Pre-allocate name buffers with 256 characters** - Prevents buffer overruns
4. **Cache track IDs** - Don't repeatedly call GetAudioTrackInfo/GetSubtitleInfo

### VLC Configuration

1. **Use IVlcSrc3 when available** - Provides full feature set
2. **Set custom parameters before loading file** - Parameters only apply at initialization
3. **Test VLC parameters independently** - Use VLC command-line to verify parameters work
4. **Use appropriate caching values**:
5. Local files: 300ms
6. Network streams: 1000-3000ms
7. Low-latency streams: 50-300ms

### Hardware Acceleration

1. **Enable hardware decoding for H.264/H.265**:

```
"--avcodec-hw=any"  // Auto-detect best method
```

1. **Platform-specific options**:
2. Windows: `d3d11va`, `dxva2`
3. All platforms: `any` (auto-detect)

### Performance

1. **Minimize network caching for live streams** - Reduces latency
2. **Use RTSP over TCP when UDP fails** - More reliable through firewalls
3. **Enable verbose logging for debugging only** - Reduces performance overhead

## Related Interfaces

- **IFileSourceFilter** - Alternative standard DirectShow interface for loading files
- **IAMStreamSelect** - DirectShow standard for stream selection (also supported by VLC filter)
- **IMediaSeeking** - Seek control in media
- **IBasicVideo** - Video window control

## See Also

- [VLC Source Filter Overview](../)
- [VLC Command-Line Documentation](https://www.videolan.org/doc/)
- [Code Examples](../examples/)

---END OF PAGE---


## Agent Skills for VisioForge .NET SDKs — AI coding agents
**URL:** https://www.visioforge.com/help/docs/dotnet/agent-skills/
**Description:** Per-platform skills for AI coding agents (Claude Code, Cursor, Copilot, Codex, Gemini CLI) covering NuGet, licence setup, and deployment caveats.

# Agent Skills for VisioForge .NET SDKs

VisioForge publishes per-platform **Agent Skills** at `https://www.visioforge.com/.well-known/agent-skills/index.json` per the [Agent Skills Discovery RFC v0.2.0](https://github.com/cloudflare/agent-skills-discovery-rfc).

## What is this?

A **Skill** is a small, self-contained package of procedural knowledge an AI coding agent can load on demand: the NuGet packages to add, the license registration code, the project-file caveats, and the deployment failure modes a developer hits in practice. Skills are loaded automatically by skills-aware agents — no installation step on your side.

When a developer prompts an agent (Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Gemini CLI, OpenCode, Goose, Junie, …) with something like *"add VisioForge video capture to this WPF app"*, the agent inspects the discovery index, finds the matching skill, downloads the archive, and follows the bundled instructions. The result is a setup that uses the *current* package versions and avoids the deployment gotchas the docs flag.

## Discovery surface

The well-known endpoints and HTML/HTTP signals are emitted by the marketing site at `www.visioforge.com` (the host that serves `/.well-known/agent-skills/`); the help site you're reading this on (`help.visioforge.com`) doesn't currently inject the discovery `<link>` or `Link:` header. Agents discovering us from a help-site page should follow the inline link to `https://www.visioforge.com/.well-known/agent-skills/index.json` directly.

| Endpoint (served by `www.visioforge.com`) | Purpose |
| --- | --- |
| `/.well-known/agent-skills/index.json` | Index of every published skill with name, description, archive URL, and SHA-256 digest. |
| `/.well-known/agent-skills/<skill-name>.zip` | Archive containing `SKILL.md` + bundled `references/` (sample `.csproj`, init code). |
| `<link rel="agent-skills">` in every `www.visioforge.com` page `<head>` | HTML signal pointing at the index. |
| `Link: <…>; rel="agent-skills"` HTTP header on `www.visioforge.com` | Same signal for non-HTML responses (Markdown, etc.). |

Skills are **discoverable from any page of `www.visioforge.com`** — agents don't need to know the well-known URL up front.

## Available skills

42 skills cover every (SDK, platform) intersection that has a working sample in [github.com/visioforge/.Net-SDK-s-samples](https://github.com/visioforge/.Net-SDK-s-samples). The authoritative list — including each skill's archive URL and SHA-256 digest — lives in the discovery index at `https://www.visioforge.com/.well-known/agent-skills/index.json`. The catalog below is auto-generated from the same source so it cannot drift.

Naming convention: `<sdk-family>-<host>` where `<host>` is the per-platform UI shell or hosting model.

### Video Capture SDK .NET

| Skill | Description | Archive |
| --- | --- | --- |
| `video-capture-sdk-net-console` | Integrate VisioForge Video Capture SDK .NET into a .NET console application (no UI). Covers the single NuGet package, project setup, license registration, headless capture/recording, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when capturing or recording from webcam, IP camera, or screen on Windows from a service, scheduled task, or batch script — for an interactive UI use video-capture-sdk-net-{wpf,winforms} instead. | [video-capture-sdk-net-console.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-net-console.zip) |
| `video-capture-sdk-net-winforms` | Integrate VisioForge Video Capture SDK .NET into a Windows Forms application. Covers the single NuGet package, project setup, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when adding webcam, IP camera, screen, or DV capture to a WinForms app on Windows. | [video-capture-sdk-net-winforms.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-net-winforms.zip) |
| `video-capture-sdk-net-winui` | Integrate VisioForge Video Capture SDK .NET into a WinUI 3 (Windows App SDK) application. Covers the WinUI-specific VideoView control, the single NuGet package, project setup, license registration, MSIX packaging quirks, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when adding webcam, IP camera, screen, or DV capture to a WinUI 3 app — for WPF use video-capture-sdk-net-wpf, for WinForms use video-capture-sdk-net-winforms. | [video-capture-sdk-net-winui.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-net-winui.zip) |
| `video-capture-sdk-net-wpf` | Integrate VisioForge Video Capture SDK .NET into a Windows WPF application. Covers the single NuGet package, project setup, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when adding webcam, IP camera, screen, or DV capture to a WPF app on Windows. | [video-capture-sdk-net-wpf.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-net-wpf.zip) |

### Video Capture SDK X

| Skill | Description | Archive |
| --- | --- | --- |
| `video-capture-sdk-x-android` | Integrate VisioForge Video Capture SDK X (cross-platform edition) into a native .NET for Android application. Covers the Android-specific VideoView control, the cross-platform NuGet package, AndroidDependency project reference, runtime camera/audio permissions, license registration, and the most common Android pitfalls (CAMERA permission denied, RECORD\_AUDIO permission denied, AAB vs APK packaging, ABI filters, trial-period expiry / unlicensed build). Use for native .NET for Android (NOT MAUI / Xamarin) capture apps — for cross-OS MAUI use video-capture-sdk-x-maui. | [video-capture-sdk-x-android.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-x-android.zip) |
| `video-capture-sdk-x-avalonia` | Integrate VisioForge Video Capture SDK X (cross-platform edition) into an Avalonia UI application. Covers the Avalonia-specific VideoView control, multi-target NuGet packages (per-OS native dependencies), license registration, and the most common cross-platform pitfalls (missing native libs, file path conventions, X11/Wayland on Linux, trial-period expiry / unlicensed build). Use when building capture apps that must run on Windows, Linux, and macOS from one codebase — for native .NET for Android/iOS/macOS use video-capture-sdk-x-{android,ios,macos}, for MAUI use video-capture-sdk-x-maui. | [video-capture-sdk-x-avalonia.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-x-avalonia.zip) |
| `video-capture-sdk-x-ios` | Integrate VisioForge Video Capture SDK X (cross-platform edition) into a native .NET for iOS application. Covers the iOS-specific VideoView control, the cross-platform NuGet package, Info.plist NSCameraUsageDescription / NSMicrophoneUsageDescription requirements, license registration, and the most common iOS pitfalls (Info.plist missing usage descriptions, no camera in simulator, AOT JIT-only ExecutionEngineException, App Store reviewer rejecting missing privacy strings, trial-period expiry / unlicensed build). Use for native .NET for iOS (NOT MAUI / Xamarin) capture apps — for cross-OS MAUI use video-capture-sdk-x-maui. | [video-capture-sdk-x-ios.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-x-ios.zip) |
| `video-capture-sdk-x-macos` | Integrate VisioForge Video Capture SDK X (cross-platform edition) into a native .NET for macOS application. Covers the macOS-specific VideoView control, the cross-platform NuGet package, Info.plist NSCameraUsageDescription / NSMicrophoneUsageDescription, code signing entitlements, license registration, and the most common macOS pitfalls (missing Info.plist usage descriptions, hardened runtime + missing entitlements, Apple Silicon vs Intel native libs, trial-period expiry / unlicensed build). Use for native .NET for macOS (NOT MAUI / MacCatalyst) capture apps — for cross-OS MAUI use video-capture-sdk-x-maui. | [video-capture-sdk-x-macos.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-x-macos.zip) |
| `video-capture-sdk-x-maui` | Integrate VisioForge Video Capture SDK X (cross-platform edition) into a .NET MAUI cross-platform app (Windows, Android, iOS, macOS). Covers the MAUI-specific VideoView control, multi-target NuGet packages (per-OS native dependencies), license registration, and the most common cross-platform pitfalls (camera permissions, missing native libs, AOT JIT-only ExecutionEngineException, trial-period expiry / unlicensed build). Use when building capture apps that must run on multiple OSes from one MAUI codebase — for graph-based pipelines use media-blocks-sdk-net-maui. | [video-capture-sdk-x-maui.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-x-maui.zip) |
| `video-capture-sdk-x-uno` | Integrate VisioForge Video Capture SDK X (cross-platform edition) into an Uno Platform application. Covers the Uno-specific VideoView control, multi-target NuGet packages (per-OS native dependencies), license registration, and the most common cross-platform pitfalls (camera permissions per OS, WebAssembly limitations, missing native libs, trial-period expiry / unlicensed build). Use for Uno cross-OS apps (Windows, Android, iOS, macOS, WebAssembly) — for MAUI use video-capture-sdk-x-maui, for Avalonia use video-capture-sdk-x-avalonia. | [video-capture-sdk-x-uno.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-x-uno.zip) |
| `video-capture-sdk-x-winforms` | Integrate VisioForge Video Capture SDK X (cross-platform edition) into a Windows Forms application. Covers the cross-platform NuGet package layout, project setup, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when you want capture/recording on WinForms with an API that ports cleanly to MAUI, Avalonia, Uno, Android, iOS, macOS — for Windows-only with the legacy DirectShow stack, use video-capture-sdk-net-winforms instead. | [video-capture-sdk-x-winforms.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-x-winforms.zip) |
| `video-capture-sdk-x-winui` | Integrate VisioForge Video Capture SDK X (cross-platform edition) into a WinUI 3 (Windows App SDK) application. Covers the WinUI-specific VideoView control, the cross-platform NuGet package layout, project setup, license registration, MSIX packaging quirks, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when you want capture/recording on WinUI 3 with an API that ports to MAUI, Avalonia, Uno — for the legacy DirectShow stack, use video-capture-sdk-net-winui. | [video-capture-sdk-x-winui.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-x-winui.zip) |
| `video-capture-sdk-x-wpf` | Integrate VisioForge Video Capture SDK X (cross-platform edition) into a Windows WPF application. Covers the cross-platform NuGet package layout, project setup, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when you want capture/recording on WPF with an API that ports cleanly to MAUI, Avalonia, Uno, Android, iOS, macOS — for Windows-only with the legacy DirectShow stack, use video-capture-sdk-net-wpf instead. | [video-capture-sdk-x-wpf.zip](https://www.visioforge.com/.well-known/agent-skills/video-capture-sdk-x-wpf.zip) |

### Media Player SDK .NET

| Skill | Description | Archive |
| --- | --- | --- |
| `media-player-sdk-net-winforms` | Integrate VisioForge Media Player SDK .NET (file/stream playback) into a Windows Forms application. Covers the single NuGet package, project setup, license registration, supported input formats, and the most common playback pitfalls (DLL not found, missing codecs, unsupported format, trial-period expiry / unlicensed build). Use when adding video/audio file or network-stream playback to a WinForms app on Windows — for capture use video-capture-sdk-net-winforms, for editing use video-edit-sdk-net-winforms. | [media-player-sdk-net-winforms.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-net-winforms.zip) |
| `media-player-sdk-net-winui` | Integrate VisioForge Media Player SDK .NET (file/stream playback) into a WinUI 3 (Windows App SDK) application. Covers the WinUI-specific VideoView control, the single NuGet package, project setup, license registration, MSIX packaging quirks, supported input formats, and the most common playback pitfalls (DLL not found, missing codecs, unsupported format, trial-period expiry / unlicensed build). Use for WinUI 3 playback — for WPF use media-player-sdk-net-wpf, for WinForms use media-player-sdk-net-winforms. | [media-player-sdk-net-winui.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-net-winui.zip) |
| `media-player-sdk-net-wpf` | Integrate VisioForge Media Player SDK .NET (file/stream playback) into a Windows WPF application. Covers the single NuGet package, project setup, license registration, supported input formats, and the most common playback pitfalls (DLL not found, missing codecs, unsupported format, trial-period expiry / unlicensed build). Use when adding video/audio file or network-stream playback to a WPF app on Windows — for capture from a camera use video-capture-sdk-net-wpf, for editing use video-edit-sdk-net-wpf. | [media-player-sdk-net-wpf.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-net-wpf.zip) |

### Media Player SDK X

| Skill | Description | Archive |
| --- | --- | --- |
| `media-player-sdk-x-android` | Integrate VisioForge Media Player SDK X (cross-platform edition) into a native .NET for Android application. Covers the Android-specific VideoView control, the cross-platform NuGet package, AndroidDependency project reference, license registration, and the most common Android pitfalls (missing INTERNET permission for streaming, AAB vs APK packaging, ABI filters, hardware decoder support, trial-period expiry / unlicensed build). Use for native .NET for Android playback apps — for cross-OS MAUI use media-player-sdk-x-maui. | [media-player-sdk-x-android.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-x-android.zip) |
| `media-player-sdk-x-avalonia` | Integrate VisioForge Media Player SDK X (cross-platform edition) into an Avalonia UI application. Covers the Avalonia-specific VideoView control, multi-target NuGet packages (per-OS native dependencies), license registration, supported input formats, and the most common cross-platform pitfalls (missing native libs, X11/Wayland on Linux, ALSA/PulseAudio audio, trial-period expiry / unlicensed build). Use when building playback apps that must run on Windows, Linux, and macOS from one codebase — for native iOS/Android/macOS use media-player-sdk-x-{android,ios,macos}, for MAUI use media-player-sdk-x-maui. | [media-player-sdk-x-avalonia.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-x-avalonia.zip) |
| `media-player-sdk-x-ios` | Integrate VisioForge Media Player SDK X (cross-platform edition) into a native .NET for iOS application. Covers the iOS-specific VideoView control, the cross-platform NuGet package, Info.plist usage descriptions, license registration, AOT JIT-only ExecutionEngineException, and the most common iOS pitfalls (App Transport Security for HTTP streams, format support, trial-period expiry / unlicensed build). Use for native .NET for iOS playback apps — for cross-OS MAUI use media-player-sdk-x-maui. | [media-player-sdk-x-ios.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-x-ios.zip) |
| `media-player-sdk-x-macos` | Integrate VisioForge Media Player SDK X (cross-platform edition) into a native .NET for macOS application. Covers the macOS-specific VideoView control, the cross-platform NuGet package, Info.plist usage descriptions, code signing entitlements, license registration, and the most common macOS pitfalls (hardened runtime, network entitlements for streaming, Apple Silicon vs Intel native libs, trial-period expiry / unlicensed build). Use for native .NET for macOS playback apps — for cross-OS MAUI use media-player-sdk-x-maui. | [media-player-sdk-x-macos.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-x-macos.zip) |
| `media-player-sdk-x-maui` | Integrate VisioForge Media Player SDK X (cross-platform edition) into a .NET MAUI cross-platform app (Windows, Android, iOS, macOS). Covers the MAUI-specific VideoView control, multi-target NuGet packages (per-OS native dependencies), license registration, supported input formats, and the most common cross-platform pitfalls (network permissions per OS, missing native libs, AOT JIT-only ExecutionEngineException, trial-period expiry / unlicensed build). Use when building playback apps that must run on multiple OSes from one MAUI codebase. | [media-player-sdk-x-maui.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-x-maui.zip) |
| `media-player-sdk-x-uno` | Integrate VisioForge Media Player SDK X (cross-platform edition) into an Uno Platform application. Covers the Uno-specific VideoView control, multi-target NuGet packages (per-OS native dependencies), license registration, supported input formats, and the most common cross-platform pitfalls (network access per OS, WebAssembly limitations, missing native libs, trial-period expiry / unlicensed build). Use for Uno cross-OS apps — for MAUI use media-player-sdk-x-maui, for Avalonia use media-player-sdk-x-avalonia. | [media-player-sdk-x-uno.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-x-uno.zip) |
| `media-player-sdk-x-winforms` | Integrate VisioForge Media Player SDK X (cross-platform edition) into a Windows Forms application. Covers the cross-platform NuGet package layout, project setup, license registration, supported input formats, and the most common playback pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when you want playback on WinForms with an API that ports cleanly to MAUI, Avalonia, Uno — for the legacy DirectShow stack use media-player-sdk-net-winforms. | [media-player-sdk-x-winforms.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-x-winforms.zip) |
| `media-player-sdk-x-winui` | Integrate VisioForge Media Player SDK X (cross-platform edition) into a WinUI 3 (Windows App SDK) application. Covers the WinUI-specific VideoView control, the cross-platform NuGet package layout, project setup, license registration, MSIX packaging quirks, supported input formats, and the most common playback pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use for WinUI 3 with the X-family API — for the legacy DirectShow stack use media-player-sdk-net-winui. | [media-player-sdk-x-winui.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-x-winui.zip) |
| `media-player-sdk-x-wpf` | Integrate VisioForge Media Player SDK X (cross-platform edition) into a Windows WPF application. Covers the cross-platform NuGet package layout, project setup, license registration, supported input formats, and the most common playback pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when you want playback on WPF with an API that ports cleanly to MAUI, Avalonia, Uno, Android, iOS, macOS — for Windows-only with the legacy DirectShow stack, use media-player-sdk-net-wpf. | [media-player-sdk-x-wpf.zip](https://www.visioforge.com/.well-known/agent-skills/media-player-sdk-x-wpf.zip) |

### Video Edit SDK .NET

| Skill | Description | Archive |
| --- | --- | --- |
| `video-edit-sdk-net-console` | Integrate VisioForge Video Edit SDK .NET (non-linear editor) into a .NET console application for batch processing — cut, trim, merge, transcode, apply effects to existing video files headlessly. Covers the timeline model, the single NuGet package, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use for scripts, scheduled jobs, CI pipelines that process video files — for an interactive editor use video-edit-sdk-net-wpf or video-edit-sdk-net-winforms. | [video-edit-sdk-net-console.zip](https://www.visioforge.com/.well-known/agent-skills/video-edit-sdk-net-console.zip) |
| `video-edit-sdk-net-winforms` | Integrate VisioForge Video Edit SDK .NET (non-linear editor) into a Windows Forms application. Covers the timeline model, the single NuGet package, project setup, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when adding cut/trim/merge/transcode/effects to existing video files on a WinForms app — for live capture from a camera, use video-capture-sdk-net-winforms instead. | [video-edit-sdk-net-winforms.zip](https://www.visioforge.com/.well-known/agent-skills/video-edit-sdk-net-winforms.zip) |
| `video-edit-sdk-net-wpf` | Integrate VisioForge Video Edit SDK .NET (non-linear editor) into a Windows WPF application. Covers the timeline model, the single NuGet package, project setup, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when adding cut/trim/merge/transcode/effects to existing video files on a WPF app — for live capture from a camera, use video-capture-sdk-net-wpf instead. | [video-edit-sdk-net-wpf.zip](https://www.visioforge.com/.well-known/agent-skills/video-edit-sdk-net-wpf.zip) |

### Video Edit SDK X

| Skill | Description | Archive |
| --- | --- | --- |
| `video-edit-sdk-x-avalonia` | Integrate VisioForge Video Edit SDK X (cross-platform editor edition) into an Avalonia UI application. Covers the timeline model, multi-target NuGet packages (per-OS native dependencies), license registration, and the most common cross-platform pitfalls (missing native libs, file path conventions, trial-period expiry / unlicensed build). Use when building a non-linear editor that must run on Windows, Linux, and macOS from one codebase — for WPF / WinForms hosts use video-edit-sdk-x-{wpf,winforms}, for headless batch use video-edit-sdk-x-console. | [video-edit-sdk-x-avalonia.zip](https://www.visioforge.com/.well-known/agent-skills/video-edit-sdk-x-avalonia.zip) |
| `video-edit-sdk-x-console` | Integrate VisioForge Video Edit SDK X (cross-platform editor edition) into a .NET console application for batch processing — cut, trim, merge, transcode, apply effects to existing video files headlessly. Covers the timeline model, the cross-platform NuGet package layout, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use for scripts, scheduled jobs, CI pipelines that process video files with the X-family API — for an interactive editor use video-edit-sdk-x-wpf or video-edit-sdk-x-winforms. | [video-edit-sdk-x-console.zip](https://www.visioforge.com/.well-known/agent-skills/video-edit-sdk-x-console.zip) |
| `video-edit-sdk-x-maui` | Integrate VisioForge Video Edit SDK X (cross-platform edition) into a .NET MAUI app (Windows, Android, iOS, Mac Catalyst). Covers the VideoEditCoreX timeline API, the MAUI VideoView control, multi-target NuGet packages (per-OS native dependencies), SDK initialization, license registration, and the most common cross-platform pitfalls (missing InitSDKAsync, media-picker paths that are not filesystem paths, a bare MP4Output that silently encodes in software on iOS, Mac Catalyst and Windows, AOT JIT-only ExecutionEngineException, trial-period expiry). Use when joining, trimming, overlaying or rendering video from one MAUI codebase — for capture use video-capture-sdk-x-maui, for playback use media-player-sdk-x-maui. | [video-edit-sdk-x-maui.zip](https://www.visioforge.com/.well-known/agent-skills/video-edit-sdk-x-maui.zip) |
| `video-edit-sdk-x-winforms` | Integrate VisioForge Video Edit SDK X (cross-platform editor edition) into a Windows Forms application. Covers the timeline model, the cross-platform NuGet package layout, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when you want non-linear editing on WinForms with an API that ports cleanly to Avalonia, Console, WPF — for Windows-only with the legacy DirectShow stack, use video-edit-sdk-net-winforms instead. | [video-edit-sdk-x-winforms.zip](https://www.visioforge.com/.well-known/agent-skills/video-edit-sdk-x-winforms.zip) |
| `video-edit-sdk-x-wpf` | Integrate VisioForge Video Edit SDK X (cross-platform editor edition) into a Windows WPF application. Covers the timeline model, the cross-platform NuGet package layout, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when you want non-linear editing on WPF with an API that ports cleanly to Avalonia, Console, WinForms — for Windows-only with the legacy DirectShow stack, use video-edit-sdk-net-wpf instead. | [video-edit-sdk-x-wpf.zip](https://www.visioforge.com/.well-known/agent-skills/video-edit-sdk-x-wpf.zip) |

### Media Blocks SDK .NET

| Skill | Description | Archive |
| --- | --- | --- |
| `media-blocks-sdk-net-android` | Integrate VisioForge Media Blocks SDK into a native .NET for Android application. Covers the graph-based pipeline model on Android, the cross-platform NuGet package, AndroidDependency project reference, runtime camera/audio permissions, license registration, and the most common Android pitfalls (CAMERA permission denied, RECORD\_AUDIO permission denied, AAB packaging ABI filters, hardware encoder support, trial-period expiry / unlicensed build). Use for native .NET for Android pipelines (capture, transcode, stream, record) — for cross-OS MAUI use media-blocks-sdk-net-maui. | [media-blocks-sdk-net-android.zip](https://www.visioforge.com/.well-known/agent-skills/media-blocks-sdk-net-android.zip) |
| `media-blocks-sdk-net-avalonia` | Integrate VisioForge Media Blocks SDK into an Avalonia UI application. Covers the graph-based pipeline model (MediaBlocksPipeline, source/sink/transform blocks), multi-target NuGet packages (per-OS native dependencies), license registration, and the most common cross-platform pitfalls (missing native libs, file path conventions, X11/Wayland on Linux, ALSA/PulseAudio audio, trial-period expiry / unlicensed build). Use when building custom media pipelines (capture, transcode, mix, stream, record) on Windows, Linux, and macOS — for native iOS/Android/macOS use media-blocks-sdk-net-{android,ios,macos}, for MAUI use media-blocks-sdk-net-maui. | [media-blocks-sdk-net-avalonia.zip](https://www.visioforge.com/.well-known/agent-skills/media-blocks-sdk-net-avalonia.zip) |
| `media-blocks-sdk-net-blazor` | Integrate VisioForge Media Blocks SDK into a Blazor Server application. Covers the graph-based pipeline model running server-side (one pipeline per logical scenario, owned by a singleton DI service), the single .NET wrapper plus per-OS native redist NuGet packages, license registration, the strict no-Blazor-WebAssembly constraint, and the most common Blazor pitfalls (DI lifetime mismatches, Razor circuit disposal vs pipeline disposal, capture-device permissions on the server host, server-side codec licensing, trial-period expiry / unlicensed build). Use for browser-based UIs that drive a server-side media pipeline (RTSP server, file recording, transcoding, broadcasting) — for a desktop UI use media-blocks-sdk-net-{wpf,winforms}. | [media-blocks-sdk-net-blazor.zip](https://www.visioforge.com/.well-known/agent-skills/media-blocks-sdk-net-blazor.zip) |
| `media-blocks-sdk-net-console` | Integrate VisioForge Media Blocks SDK into a .NET console application for batch processing — build custom pipelines (transcode, mux, stream, record) without UI. Covers the graph-based pipeline model, the single NuGet package, license registration, headless block wiring, and the most common deployment pitfalls (DLL not found, missing codecs, no preview block, trial-period expiry / unlicensed build). Use for scripts, scheduled jobs, CI pipelines that need full pipeline control — for an interactive UI use media-blocks-sdk-net-{wpf,winforms}. | [media-blocks-sdk-net-console.zip](https://www.visioforge.com/.well-known/agent-skills/media-blocks-sdk-net-console.zip) |
| `media-blocks-sdk-net-ios` | Integrate VisioForge Media Blocks SDK into a native .NET for iOS application. Covers the graph-based pipeline model on iOS, the cross-platform NuGet package, Info.plist NSCameraUsageDescription / NSMicrophoneUsageDescription requirements, license registration, AOT JIT-only ExecutionEngineException, and the most common iOS pitfalls (missing usage descriptions, no camera in simulator, App Store reviewer rejecting missing privacy strings, trial-period expiry / unlicensed build). Use for native .NET for iOS pipelines (capture, transcode, stream, record) — for cross-OS MAUI use media-blocks-sdk-net-maui. | [media-blocks-sdk-net-ios.zip](https://www.visioforge.com/.well-known/agent-skills/media-blocks-sdk-net-ios.zip) |
| `media-blocks-sdk-net-macos` | Integrate VisioForge Media Blocks SDK into a native .NET for macOS application. Covers the graph-based pipeline model on macOS, the cross-platform NuGet package, Info.plist NSCameraUsageDescription / NSMicrophoneUsageDescription, code signing entitlements, license registration, and the most common macOS pitfalls (missing usage descriptions, hardened runtime + missing entitlements, Apple Silicon vs Intel native libs, trial-period expiry / unlicensed build). Use for native .NET for macOS pipelines (capture, transcode, stream, record) — for cross-OS MAUI use media-blocks-sdk-net-maui. | [media-blocks-sdk-net-macos.zip](https://www.visioforge.com/.well-known/agent-skills/media-blocks-sdk-net-macos.zip) |
| `media-blocks-sdk-net-maui` | Integrate VisioForge Media Blocks SDK .NET into a .NET MAUI cross-platform app (Windows, Android, iOS, macOS). Covers the graph-based pipeline model, multi-target NuGet packages (per-OS native dependencies), license registration, and the most common cross-platform pitfalls (camera permissions, missing native libs, trial-period expiry / unlicensed build). Use when building custom media pipelines (capture, transcode, stream, record) that must run on multiple OSes from one MAUI codebase. | [media-blocks-sdk-net-maui.zip](https://www.visioforge.com/.well-known/agent-skills/media-blocks-sdk-net-maui.zip) |
| `media-blocks-sdk-net-uno` | Integrate VisioForge Media Blocks SDK into an Uno Platform application. Covers the graph-based pipeline model, multi-target NuGet packages (per-OS native dependencies), license registration, and the most common cross-platform pitfalls (camera permissions per OS, WebAssembly limitations, missing native libs, trial-period expiry / unlicensed build). Use for Uno cross-OS pipelines (Windows, Android, iOS, macOS) — for MAUI use media-blocks-sdk-net-maui, for Avalonia use media-blocks-sdk-net-avalonia. | [media-blocks-sdk-net-uno.zip](https://www.visioforge.com/.well-known/agent-skills/media-blocks-sdk-net-uno.zip) |
| `media-blocks-sdk-net-winforms` | Integrate VisioForge Media Blocks SDK .NET into a Windows Forms application. Covers the graph-based pipeline model (MediaBlocksPipeline, source/sink/transform blocks), the single NuGet package, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when building custom media pipelines (capture, transcode, mix, stream, record) on a WinForms app — for simpler webcam-only capture, use video-capture-sdk-net-winforms instead. | [media-blocks-sdk-net-winforms.zip](https://www.visioforge.com/.well-known/agent-skills/media-blocks-sdk-net-winforms.zip) |
| `media-blocks-sdk-net-wpf` | Integrate VisioForge Media Blocks SDK .NET into a Windows WPF application. Covers the graph-based pipeline model (MediaBlocksPipeline, source/sink/transform blocks), the single NuGet package, license registration, and the most common deployment pitfalls (DLL not found, missing codecs, trial-period expiry / unlicensed build). Use when building custom media pipelines (capture, transcode, mix, stream, record) on a WPF app — for simpler webcam-only capture, use video-capture-sdk-net-wpf instead. | [media-blocks-sdk-net-wpf.zip](https://www.visioforge.com/.well-known/agent-skills/media-blocks-sdk-net-wpf.zip) |

## How agents pick up a skill

1. Agent crawls a page on `www.visioforge.com`, sees `<link rel="agent-skills" href="/.well-known/agent-skills/index.json">` (or the same URL in the `Link` HTTP header for Markdown responses). Agents arriving via `help.visioforge.com` should follow the inline `https://www.visioforge.com/.well-known/agent-skills/index.json` link directly — the help site doesn't emit those discovery signals.
2. Agent fetches the index, reads the `skills[]` array, picks the entries whose `description` matches the user's task.
3. Agent downloads the matching `.zip`, verifies the `sha256:` digest, unpacks `SKILL.md` and `references/`, and follows the procedural instructions.

## Reading a skill yourself

A skill archive is a plain zip. Unpack it and you'll find:

- `SKILL.md` — frontmatter (`name`, `description`) followed by procedural prose: when to use the skill, NuGet packages, project setup, license registration, common pitfalls.
- `references/Sample.csproj` — minimal, working csproj for the skill's target host (WPF, WinForms, MAUI, Console, …) — each per-platform skill ships a csproj specific to that host (e.g. the WPF skill csproj sets `Microsoft.NET.Sdk.WindowsDesktop` + `<UseWPF>true</UseWPF>`).
- `references/<init-source>.cs` — the initialization pattern from a real official sample. WPF skills also bundle the matching `.xaml`, `App.xaml(.cs)`, and any required resources so `dotnet build` succeeds against the bundle as-is.

## Maintenance

Skills track the current public NuGet release. The version pinned in each `SKILL.md` and `references/Sample.csproj` matches the version in the official samples on [github.com/visioforge/.Net-SDK-s-samples](https://github.com/visioforge/.Net-SDK-s-samples). When a major SDK version ships, every skill is updated and the discovery index sha256 digests are recomputed during the visioforge.com build.

## Related discovery surfaces

VisioForge already exposes three other AI-agent surfaces — Agent Skills is the fourth and complements them:

| Surface | Shape | Best for |
| --- | --- | --- |
| `mcp.visioforge.com/mcp` (via `/.well-known/mcp.json` + `/.well-known/mcp-server-card`) | Live MCP server with 14 read-only doc tools | Querying the SDK API surface, looking up media blocks, fetching code examples |
| `/llms.txt`, `/llms-full.txt` | LLM-friendly docs index | Bulk ingestion of the docs corpus |
| `<meta name="x-webmcp-tools">` + WebMCP runtime | 10 in-page tools registered via `navigator.modelContext.provideContext()` | Agent acting in the user's current browser tab (locale switch, page outline, copy code, …) |
| **`/.well-known/agent-skills/index.json`** | **Per-(SDK, platform) procedural skill archives** | **Bootstrapping a new project that uses one of our SDKs** |

---END OF PAGE---


## ABUS IP Camera RTSP URLs and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/abus/
**Description:** ABUS TVIP, CASA, and Digi-Lan camera RTSP URL patterns for C# .NET. Stream and record with VisioForge Video Capture SDK cross-platform integration.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MP4, H.264, MJPEG, C#

# How to Connect to ABUS IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**ABUS** (August Bremicker Soehne KG) is a German security company headquartered in Wetter, Germany. Founded in 1924, ABUS is one of Europe's largest security product manufacturers, known for locks, alarm systems, and video surveillance. The **TVIP** series of IP cameras is widely deployed across Europe, particularly in Germany, Austria, and the Benelux countries.

**Key facts:**

- **Product lines:** TVIP (IP cameras), CASA (consumer), TV (legacy analog IP), Digi-Lan (older IP)
- **TVIP model numbering:** TVIP1xxxx (consumer), TVIP2xxxx (2MP), TVIP4xxxx (4MP), TVIP5xxxx (5MP), TVIP6xxxx/7xxxx (special)
- **Protocol support:** RTSP, ONVIF, HTTP/CGI, MJPEG
- **Default RTSP port:** 554
- **Default credentials:** admin / admin (some models: root / pass)
- **ONVIF support:** Yes (TVIP2xxxx and newer)
- **Video codecs:** H.264 (TVIP2xxxx and newer), MJPEG (older models)

ABUS TVIP Model Numbering

The TVIP model number indicates the resolution tier: **1xxxx** = basic/consumer, **2xxxx** = 2MP (1080p), **4xxxx** = 4MP, **5xxxx** = 5MP, **6xxxx/7xxxx** = special models. This helps identify which URL formats and codecs a camera supports.

## RTSP URL Patterns

### Primary URL Formats

ABUS cameras support multiple RTSP URL formats depending on the model generation:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/video.mp4
```

| URL Pattern | Description |
| --- | --- |
| `rtsp://IP:554/video.mp4` | MP4 stream (recommended for H.264 models) |
| `rtsp://IP:554/live.sdp` | Live SDP stream (consumer and legacy models) |
| `rtsp://IP:554/video.h264` | Direct H.264 stream |
| `rtsp://IP:554/VideoInput/CHANNEL/h264/1` | VideoInput format (4MP models) |

### TVIP1xxxx Series (Consumer)

| Model | Main Stream URL | Notes |
| --- | --- | --- |
| TVIP10000 | `rtsp://IP:554/live.sdp` | MJPEG-only |
| TVIP10500 | `rtsp://IP:554/live.sdp` | MJPEG-only |
| TVIP10550 | `rtsp://IP:554/live.sdp` | MJPEG-only |
| TVIP11000 | `rtsp://IP:554/live.sdp` | MJPEG/H.264 |

MJPEG-Only Models

Some older TVIP1xxxx models (TVIP10000, TVIP10500, TVIP10550) support only MJPEG encoding with no H.264. Use the MJPEG HTTP stream URLs listed in the Snapshot and MJPEG section below for these models.

### TVIP2xxxx Series (2MP)

| Model | Main Stream URL | Alternative URL |
| --- | --- | --- |
| TVIP20000 | `rtsp://IP:554/video.mp4` | - |
| TVIP20550 | `rtsp://IP:554/video.mp4` | - |
| TVIP21550 | `rtsp://IP:554/video.mp4` | `rtsp://IP:554/live.sdp` |
| TVIP22500 | `rtsp://IP:554/video.h264` | - |

### TVIP4xxxx Series (4MP)

| Model | Main Stream URL | Alternative URL |
| --- | --- | --- |
| TVIP41500 | `rtsp://IP:554/video.mp4` | `rtsp://IP:554/VideoInput/1/h264/1` |
| TVIP41550 | `rtsp://IP:554/video.mp4` | `rtsp://IP:554/VideoInput/1/h264/1` |

### TVIP5xxxx Series (5MP)

| Model | Main Stream URL |
| --- | --- |
| TVIP51550 | `rtsp://IP:554/video.mp4` |

### TVIP6xxxx / TVIP7xxxx Series (Special)

| Model | Main Stream URL |
| --- | --- |
| TVIP61500 | `rtsp://IP:554/video.mp4` |
| TVIP71550 | `rtsp://IP:554/video.mp4` |

### CASA Series (Consumer)

| Model | Main Stream URL |
| --- | --- |
| CASA20550 | `rtsp://IP:554/live.sdp` |

### Legacy TV / Digi-Lan Series

| Model | Main Stream URL |
| --- | --- |
| Digi-Lan TV7220 | `rtsp://IP:554/live.sdp` |
| TV7240-LAN | `rtsp://IP:554/live.sdp` |
| TV32500 | `rtsp://IP:554/video.mp4` |

Which URL Format to Try First

For ABUS cameras, try `video.mp4` first for H.264 streaming, then `live.sdp` as a fallback. For older TVIP1xxxx models, `live.sdp` is typically the only RTSP option. The `VideoInput` format is specific to TVIP4xxxx models.

## Connecting with VisioForge SDK

Use your ABUS camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// ABUS TVIP41550, main stream
var uri = new Uri("rtsp://192.168.1.90:554/video.mp4");
var username = "admin";
var password = "admin";
```

For models using the `VideoInput` format, use:

```
// ABUS TVIP41500, VideoInput format
var uri = new Uri("rtsp://192.168.1.90:554/VideoInput/1/h264/1");
```

## Snapshot and MJPEG URLs

### JPEG Snapshots

| Type | URL Pattern | Supported Models |
| --- | --- | --- |
| Standard snapshot | `http://IP/jpg/image.jpg` | TVIP10500, TVIP10550, TVIP11000, TVIP20000, TVIP21550, TVIP51550 |
| High-res snapshot | `http://IP/jpg/image.jpg?size=3` | TVIP10001, TVIP21050, TVIP71550 |
| CGI viewer | `http://IP/cgi-bin/viewer/video.jpg?channel=CH&resolution=WxH` | CASA20550, TVIP41550, TVIP51550 |
| Simple CGI snapshot | `http://IP/cgi-bin/video.jpg` | Digi-Lan, TV models |
| Alternative CGI | `http://IP/cgi-bin/jpg/image` | TVIP20050 |
| Profile image | `http://IP/cgi-bin/view/image?pro_CHANNEL` | TVIP20000, TVIP21500 |
| JPEG pull | `http://IP/jpeg/pull` | TVIP62000 |

### MJPEG Streams

| Type | URL Pattern | Supported Models |
| --- | --- | --- |
| Standard MJPEG | `http://IP/video.mjpg` | TVIP10000, TVIP11000, TVIP21500, TVIP21550, TVIP51550, TVIP71501 |
| MJPEG with params | `http://IP/video.mjpg?q=30&fps=33&id=0.5` | TVIP31550, TVIP21501, TVIP51550, TVIP71550 |

MJPEG Parameters

The `q` parameter controls JPEG quality (1-100), `fps` sets the frame rate, and `id` is a session identifier. Adjust these values based on your bandwidth and quality requirements.

## Troubleshooting

### Multiple URL formats work on the same camera

Many ABUS cameras respond to several different RTSP and HTTP URL formats. This is by design. For the best results:

1. Try `rtsp://IP:554/video.mp4` first for H.264 streaming
2. Fall back to `rtsp://IP:554/live.sdp` if `video.mp4` does not work
3. Use `http://IP/video.mjpg` for MJPEG streaming as a last resort

### Older TVIP1xxxx models have no H.264

Some first-generation TVIP1xxxx cameras (TVIP10000, TVIP10500, TVIP10550) only support MJPEG encoding. These cameras will not respond to `video.mp4` or `video.h264` RTSP URLs. Use the MJPEG HTTP stream (`http://IP/video.mjpg`) or the `live.sdp` RTSP URL instead.

### Default credentials vary by model

Most ABUS cameras use `admin` / `admin` as default credentials. However, some models default to `root` / `pass`. If authentication fails with one set, try the other. Check the camera's documentation for the specific default credentials.

### TVIP model number decoding

If you are unsure which URL format to use, the TVIP model number provides guidance:

- **TVIP1xxxx:** Start with `live.sdp`, may be MJPEG-only
- **TVIP2xxxx:** Start with `video.mp4`, most support H.264
- **TVIP4xxxx:** Start with `video.mp4`, also try `VideoInput/1/h264/1`
- **TVIP5xxxx+:** Start with `video.mp4`

### Snapshot resolution parameter

For the `jpg/image.jpg?size=N` URL, the `size` parameter controls resolution:

- `size=1` = Lowest resolution
- `size=2` = Medium resolution
- `size=3` = Highest resolution

## FAQ

**What is the default RTSP URL for ABUS cameras?**

For most current ABUS cameras (TVIP2xxxx and newer), the default URL is `rtsp://admin:admin@CAMERA_IP:554/video.mp4`. For older consumer models (TVIP1xxxx), try `rtsp://admin:admin@CAMERA_IP:554/live.sdp` instead.

**Do ABUS cameras support ONVIF?**

Yes. ABUS cameras from the TVIP2xxxx generation onward support ONVIF, which provides standardized camera discovery and streaming. Older TVIP1xxxx models may not support ONVIF.

**Can I use MJPEG streaming with ABUS cameras?**

Yes. Most ABUS cameras support MJPEG streaming via `http://CAMERA_IP/video.mjpg`. This is particularly useful for older TVIP1xxxx models that do not support H.264 encoding. MJPEG uses more bandwidth than H.264 but is compatible with a wider range of software.

**What do the ABUS TVIP model numbers mean?**

The five-digit number after "TVIP" indicates the camera's resolution tier: 1xxxx = basic/consumer, 2xxxx = 2MP (1080p), 4xxxx = 4MP, 5xxxx = 5MP, and 6xxxx/7xxxx = special models. Higher numbers generally indicate newer hardware with broader protocol and codec support.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [INSTAR Connection Guide](../instar/) — German consumer / smart home cameras
- [ONVIF IP Camera Integration](../../videocapture/video-sources/ip-cameras/onvif/) — ABUS ONVIF device setup
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## ACTi IP Camera RTSP URL and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/acti/
**Description:** ACTi A, B, D, E series and legacy ACM/KCM/TCM camera RTSP URL patterns for C# .NET. Integrate with VisioForge Video Capture SDK code samples.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, IP Camera, RTSP, ONVIF, H.264, H.265, MJPEG, C#

# How to Connect to ACTi IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**ACTi Corporation** is a Taiwanese manufacturer of IP surveillance cameras and video management solutions. Headquartered in Taipei, Taiwan, ACTi targets professional and enterprise markets with a wide range of fixed, dome, bullet, and PTZ cameras. ACTi is known for its current A/B/D/E series cameras and legacy ACM, KCM, and TCM product lines.

**Key facts:**

- **Product lines:** A-series (box), B-series (bullet/zoom), D-series (dome), E-series (hemispheric dome), KCM (legacy dome), ACM (legacy box/dome), TCM (legacy box)
- **Protocol support:** RTSP, ONVIF (current A/B/D/E series), HTTP/CGI
- **Default RTSP port:** 7070 (most models), 554 (some legacy models)
- **Default credentials:** Admin / 123456 (current models), admin / admin (legacy)
- **ONVIF support:** Yes (current A/B/D/E series)
- **Video codecs:** H.264, H.265 (E-series), MJPEG

Non-standard port

ACTi cameras use **port 7070** by default for RTSP, not the standard port 554. This is the most common connection issue when integrating ACTi cameras.

## RTSP URL Patterns

### Current Models (A/B/D/E Series)

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Main stream | `rtsp://IP:7070//stream1` | Primary stream (note double slash) |
| Root stream | `rtsp://IP:7070/` | Fallback |
| H.264 direct | `rtsp://IP:7070/h264` | Explicit codec selection |
| ONVIF stream | `rtsp://IP:7070//onvif-stream1` | ONVIF variant |

Double slash before stream1

ACTi cameras use a **double forward slash** before `stream1` in their RTSP URLs: `rtsp://IP:7070//stream1`. This is intentional and required for most current models.

### Model-Specific URLs

| Model Series | RTSP URL | Type | Notes |
| --- | --- | --- | --- |
| D11, D21, D31, D32 | `rtsp://IP:7070//stream1` | Dome | Current |
| D42, D51, D52, D55, D72 | `rtsp://IP:7070//stream1` | Dome | Current |
| E12, E32, E33, E43, E46 | `rtsp://IP:7070//stream1` | Hemispheric | Current, H.265 capable |
| E51, E52, E63, E65, E73 | `rtsp://IP:7070//stream1` | Hemispheric | Current, H.265 capable |
| E82, E84, E96 | `rtsp://IP:7070//stream1` | Hemispheric | Current, H.265 capable |
| B53, B87, B95 | `rtsp://IP:7070//stream1` | Bullet/Zoom | Current |
| A-series (box) | `rtsp://IP:7070//stream1` | Box | Current |

### Legacy Models

Legacy ACTi cameras may use port 554 or 7070 depending on the model and firmware version:

| Model Series | RTSP URL | Type | Notes |
| --- | --- | --- | --- |
| ACM-1011 | `rtsp://IP:554/` or `rtsp://IP:7070/` | Box | Legacy |
| ACM-3401 | `rtsp://IP:554/` or `rtsp://IP:7070/` | Dome | Legacy |
| ACM-5601 | `rtsp://IP:554/` or `rtsp://IP:7070/` | Box | Legacy |
| ACM-7411 | `rtsp://IP:554/` or `rtsp://IP:7070/` | Dome | Legacy |
| KCM-3311 | `rtsp://IP:7070/` | Dome | Legacy |
| KCM-5611 | `rtsp://IP:7070/` | Dome | Legacy |
| KCM-7211 | `rtsp://IP:7070/` | Dome | Legacy |
| TCM-1231 | `rtsp://IP:7070/` | Box | Legacy |
| TCM-3511 | `rtsp://IP:7070/` | Box | Legacy |
| TCM-5111 | `rtsp://IP:7070/` | Box | Legacy |
| TCM-5311 | `rtsp://IP:7070/` | Box | Legacy |

## Connecting with VisioForge SDK

Use your ACTi camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// ACTi D/E series camera, main stream -- note port 7070, not 554!
var uri = new Uri("rtsp://192.168.1.50:7070//stream1");
var username = "Admin";
var password = "123456";
```

For legacy ACM models that use port 554, change the port accordingly. For a simpler root stream, use `rtsp://IP:7070/` as the URL.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| CGI Snapshot | `http://IP/cgi-bin/encoder?USER=USERNAME&PWD=PASSWORD&SNAPSHOT` | Authenticated snapshot |
| HTTP Streaming | `http://IP/cgi-bin/cmd/system?GET_STREAM&USER=USERNAME&PWD=PASSWORD` | Continuous stream |
| JPEG Image | `http://IP/jpg/image.jpg` | Direct JPEG |
| JPEG (alt) | `http://IP/now.jpg` | Alternative snapshot path |

## Troubleshooting

### Port 7070, not 554

The most common ACTi connection issue is using the standard port 554. ACTi cameras default to **port 7070** for RTSP. If your connection times out or is refused, verify you are using the correct port.

- Correct: `rtsp://IP:7070//stream1`
- Likely incorrect: `rtsp://IP:554//stream1` (unless using a legacy ACM model)

### Double slash before stream1

ACTi current-generation cameras use a **double forward slash** before `stream1`:

- Correct: `rtsp://IP:7070//stream1`
- May not work: `rtsp://IP:7070/stream1`

### Default credentials differ by generation

- **Current models (A/B/D/E series):** Username `Admin` (capital A), password `123456`
- **Legacy models (ACM/KCM/TCM):** Username `admin` (lowercase), password `admin`

Always change default credentials before deploying cameras on a production network.

### Legacy ACM models and port 554

Some older ACM-series cameras (ACM-1011, ACM-3401, ACM-5601, ACM-7411) may use port 554 instead of 7070. If port 7070 fails on a legacy model, try port 554 with the root URL `rtsp://IP:554/`.

### ONVIF availability

ONVIF is only supported on current-generation cameras (A, B, D, and E series). Legacy ACM, KCM, and TCM cameras do not support ONVIF. For legacy models, use direct RTSP or HTTP URLs.

## FAQ

**What is the default RTSP URL for ACTi cameras?**

For current ACTi cameras (A/B/D/E series), use `rtsp://Admin:123456@CAMERA_IP:7070//stream1`. Note the non-standard port 7070 and double slash before `stream1`. For legacy models, try `rtsp://admin:admin@CAMERA_IP:7070/` or `rtsp://admin:admin@CAMERA_IP:554/`.

**Why does ACTi use port 7070 instead of 554?**

ACTi chose port 7070 as their default RTSP port. This can be changed in the camera's web interface, but the factory default is 7070 for most models. Some legacy ACM-series cameras default to port 554.

**Does ACTi support H.265?**

Current E-series cameras (hemispheric dome models) support H.265 encoding. Other current series (A, B, D) primarily use H.264. Legacy models (ACM, KCM, TCM) support H.264 and MJPEG only.

**What is the difference between ACTi product series?**

ACTi organizes cameras by letter: **A** = box cameras, **B** = bullet and zoom cameras, **D** = dome cameras, **E** = hemispheric dome cameras. Legacy product lines include ACM (box/dome), KCM (dome), and TCM (box).

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Vivotek Connection Guide](../vivotek/) — Taiwanese enterprise cameras
- [GeoVision Connection Guide](../geovision/) — Taiwanese professional cameras
- [ONVIF IP Camera Integration](../../videocapture/video-sources/ip-cameras/onvif/) — ACTi ONVIF device setup
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Amcrest IP Camera RTSP URL Format and C# .NET Setup
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/amcrest/
**Description:** Amcrest IP2M, IP4M, IP5M, IP8M, and NVR RTSP URL patterns for C# .NET. Stream and record using VisioForge SDK with ONVIF auto-discovery support.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MJPEG, C#

# How to Connect to Amcrest IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Amcrest** (Amcrest Technologies LLC) is an American consumer security camera brand based in Houston, Texas. Amcrest cameras are manufactured by **Dahua Technology** and use Dahua firmware and protocols. This means Amcrest cameras share identical RTSP URL patterns, web interfaces, and API endpoints with Dahua cameras. Amcrest has become one of the best-selling IP camera brands on Amazon in North America.

**Key facts:**

- **Product lines:** IP2M (1080p), IP4M (4MP), IP5M (5MP), IP8M (4K/8MP), ASH (smart home), NV (NVRs)
- **Protocol support:** RTSP, ONVIF, HTTP/CGI, Amcrest Cloud, RTMP
- **Default RTSP port:** 554
- **Default credentials:** admin / admin (must be changed on first login with newer firmware)
- **ONVIF support:** Yes (all current models)
- **Video codecs:** H.264 (all models), H.265 (IP4M and newer)
- **OEM base:** Dahua (identical RTSP URL format)

Amcrest = Dahua

Amcrest cameras use Dahua firmware and the exact same RTSP URL format as Dahua cameras. If you're familiar with Dahua integration, Amcrest works identically. See our [Dahua connection guide](../dahua/) for additional details.

## RTSP URL Patterns

### Standard URL Format

Amcrest uses the Dahua `cam/realmonitor` URL pattern:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/cam/realmonitor?channel=1&subtype=0
```

| Parameter | Value | Description |
| --- | --- | --- |
| `channel` | 1, 2, 3... | Camera channel (1 for standalone cameras) |
| `subtype` | 0 | Main stream (highest resolution) |
| `subtype` | 1 | Sub stream (lower resolution, less bandwidth) |
| `subtype` | 2 | Third stream (if supported, mobile-optimized) |

### Camera Models

| Model | Resolution | Main Stream URL | Audio |
| --- | --- | --- | --- |
| IP2M-841 (1080p bullet) | 1920x1080 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| IP2M-844 (1080p dome) | 1920x1080 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| IP4M-1051 (4MP bullet) | 2688x1520 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| IP5M-T1179E (5MP turret) | 2592x1944 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| IP8M-2493E (4K bullet) | 3840x2160 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| IP8M-T2599E (4K turret) | 3840x2160 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| ASH-41 (pan/tilt) | 2560x1440 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| ASH-42 (indoor) | 1920x1080 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |

### NVR Channel URLs

For Amcrest NVRs (NV4108E, NV4216E, NV5216E, etc.):

| Channel | Main Stream | Sub Stream |
| --- | --- | --- |
| Camera 1 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` |
| Camera 2 | `rtsp://IP:554/cam/realmonitor?channel=2&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=2&subtype=1` |
| Camera N | `rtsp://IP:554/cam/realmonitor?channel=N&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=N&subtype=1` |

### Alternative URL Formats

Some older Amcrest models or firmware versions support these alternative URLs:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Standard (recommended) |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0&unicast=true` | Force unicast |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0&proto=Onvif` | ONVIF-compatible |

## Connecting with VisioForge SDK

Use your Amcrest camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Amcrest IP4M-1051, main stream
var uri = new Uri("rtsp://192.168.1.90:554/cam/realmonitor?channel=1&subtype=0");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `subtype=1` instead of `subtype=0`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/snapshot.cgi?channel=1` | Requires basic auth |
| JPEG Snapshot (legacy) | `http://IP/cgi-bin/snapshot.cgi?loginuse=USER&loginpas=PASS` | URL-based auth |
| MJPEG Stream | `http://IP/cgi-bin/mjpg/video.cgi?channel=1&subtype=1` | Continuous MJPEG |
| Current image | `http://IP/onvif-http/snapshot?channel=1` | ONVIF HTTP snapshot |

## Troubleshooting

### "401 Unauthorized" error

Amcrest cameras with newer firmware require the password to be changed from the default on first login. If you haven't set up the camera via the web interface or Amcrest app yet:

1. Access the camera at `http://CAMERA_IP` in a browser
2. Complete the initial setup wizard
3. Set a strong password
4. Use those credentials in your RTSP URL

### Port 554 vs custom port

Some Amcrest firmware versions allow changing the RTSP port. Check the port setting at:

- Web interface: **Setup > Network > Port > RTSP Port**
- Default is 554

### Stream type confusion

- `subtype=0` = Main stream (full resolution, higher bandwidth)
- `subtype=1` = Sub stream (reduced resolution, lower bandwidth)
- `subtype=2` = Third stream (if available, typically for mobile)

### Amcrest SmartHome (ASH) cameras

The ASH series cameras (like ASH-41, ASH-42) use the same RTSP URL format but some models require enabling RTSP in the Amcrest Smart Home app first.

## FAQ

**Are Amcrest and Dahua cameras the same?**

Amcrest cameras are manufactured by Dahua and use Dahua firmware. The RTSP URL format (`cam/realmonitor?channel=1&subtype=0`) is identical. Any code written for Dahua cameras works with Amcrest and vice versa. The main differences are branding, warranty, and North American support.

**What is the default RTSP URL for Amcrest cameras?**

The URL is `rtsp://admin:password@CAMERA_IP:554/cam/realmonitor?channel=1&subtype=0` for the main stream. Replace `channel=1` with the appropriate channel for NVR setups and `subtype=0` with `subtype=1` for the sub stream.

**Do Amcrest cameras support ONVIF?**

Yes. All current Amcrest cameras support ONVIF Profile S and Profile T. ONVIF is enabled by default on most models.

**Can I use Amcrest cameras without the Amcrest cloud?**

Yes. RTSP, ONVIF, and the web interface all work locally without any cloud dependency. The Amcrest cloud service is optional and only needed for remote viewing through Amcrest's apps.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Dahua Connection Guide](../dahua/) — Same URL format (OEM base)
- [Lorex Connection Guide](../lorex/) — Also uses Dahua URL format
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Annke Camera RTSP URL Patterns with C# .NET Examples
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/annke/
**Description:** Annke C500, C800, CZ400, NC400 and NVR RTSP URL patterns for C# .NET. Integrate with VisioForge Video Capture SDK for streaming and recording.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Decoding, IP Camera, RTSP, ONVIF, H.265, MJPEG, C#

# How to Connect to Annke IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Annke** (Annke Innovation Co., Ltd.) is a consumer and prosumer security camera brand based in Hong Kong, primarily selling through Amazon and direct-to-consumer channels. Annke cameras are manufactured using **Hikvision** OEM hardware, and most models use Hikvision-compatible firmware and RTSP URL patterns. Annke offers competitive pricing on PoE cameras, NVRs, and complete surveillance kits.

**Key facts:**

- **Product lines:** C-series (IP cameras), CZ-series (PTZ), NC-series (NVRs), I-series (turret/dome)
- **Protocol support:** RTSP, ONVIF Profile S, HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** admin / (set during initial setup; some models: admin / admin)
- **ONVIF support:** Yes (all current models)
- **Video codecs:** H.264, H.265 (4MP and above)
- **OEM base:** Hikvision (most models use Hikvision-compatible firmware)

Annke Uses Hikvision Firmware

Most Annke cameras use Hikvision OEM firmware. The RTSP URL format (`/Streaming/Channels/`) is identical to Hikvision. See our [Hikvision connection guide](../hikvision/) for additional details and troubleshooting.

## RTSP URL Patterns

### Standard URL Format

Annke cameras use the Hikvision `Streaming/Channels` URL pattern:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/Streaming/Channels/[CHANNEL_ID]
```

| Channel ID | Stream | Description |
| --- | --- | --- |
| 101 | Main stream | Full resolution |
| 102 | Sub stream | Lower resolution |
| 103 | Third stream | Mobile-optimized (if supported) |

### Camera Models

| Model | Resolution | Main Stream URL | Audio |
| --- | --- | --- | --- |
| C500 (5MP bullet) | 2592x1944 | `rtsp://IP:554/Streaming/Channels/101` | Yes |
| C800 (4K bullet) | 3840x2160 | `rtsp://IP:554/Streaming/Channels/101` | Yes |
| C1200 (12MP bullet) | 4000x3000 | `rtsp://IP:554/Streaming/Channels/101` | Yes |
| CZ400 (4MP PTZ) | 2560x1440 | `rtsp://IP:554/Streaming/Channels/101` | Yes |
| I91BN (4K turret) | 3840x2160 | `rtsp://IP:554/Streaming/Channels/101` | Yes |
| I91BM (4K dome) | 3840x2160 | `rtsp://IP:554/Streaming/Channels/101` | Yes |
| NC400 (4ch NVR) | N/A | See NVR section | N/A |
| N48PAW (8ch PoE NVR) | N/A | See NVR section | N/A |

### NVR Channel URLs

For Annke NVRs (NC400, N48PAW, N46PCK, etc.):

| Channel | Main Stream | Sub Stream |
| --- | --- | --- |
| Camera 1 | `rtsp://IP:554/Streaming/Channels/101` | `rtsp://IP:554/Streaming/Channels/102` |
| Camera 2 | `rtsp://IP:554/Streaming/Channels/201` | `rtsp://IP:554/Streaming/Channels/202` |
| Camera N | `rtsp://IP:554/Streaming/Channels/N01` | `rtsp://IP:554/Streaming/Channels/N02` |

### Alternative URL Formats

Some Annke models (especially non-Hikvision OEM variants) use different URL patterns:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/Streaming/Channels/101` | Hikvision-style (most models) |
| `rtsp://IP:554/h264/ch1/main/av_stream` | Older Hikvision firmware |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Dahua-style (some older models) |

## Connecting with VisioForge SDK

Use your Annke camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Annke C800 (4K bullet), main stream
var uri = new Uri("rtsp://192.168.1.90:554/Streaming/Channels/101");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `/Streaming/Channels/102` instead.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/ISAPI/Streaming/channels/101/picture` | Requires digest auth |
| MJPEG Stream | `http://IP/ISAPI/Streaming/channels/102/httpPreview` | Sub stream as MJPEG |
| Legacy Snapshot | `http://IP/Streaming/channels/1/picture` | Older firmware |

## Troubleshooting

### Camera requires activation

Annke cameras with newer firmware require initial activation (password setup) before RTSP access works. Use the camera's web interface at `http://CAMERA_IP` or Annke's SADP-compatible discovery tool.

### Hikvision URL format not working

Some Annke models use different OEM firmware. If `/Streaming/Channels/101` does not work, try:

1. `/h264/ch1/main/av_stream` (older Hikvision firmware)
2. `/cam/realmonitor?channel=1&subtype=0` (Dahua-style)
3. Use ONVIF discovery to automatically retrieve the correct stream URL

### H.265 stream issues

Annke 4K cameras (C800, I91BN) default to H.265 encoding. If playback fails, switch the camera to H.264 in the web interface or install the HEVC decoder redistributable.

## FAQ

**What is the default RTSP URL for Annke cameras?**

Most Annke cameras use `rtsp://admin:password@CAMERA_IP:554/Streaming/Channels/101` for the main stream. Use channel `102` for the sub stream. This is the same format as Hikvision cameras.

**Are Annke cameras Hikvision OEMs?**

Most Annke cameras use Hikvision OEM hardware and firmware. The RTSP URL format, web interface, and API are typically identical to Hikvision. Some Annke models may use different OEM bases.

**Do Annke cameras support ONVIF?**

Yes. All current Annke cameras support ONVIF Profile S, providing standardized discovery and stream access.

**Can I mix Annke cameras with Hikvision NVRs?**

Yes. Since Annke cameras use Hikvision-compatible protocols, they work natively with Hikvision NVRs and vice versa. You can also mix Annke cameras into any ONVIF-compatible NVR or VMS.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Hikvision Connection Guide](../hikvision/) — Same URL format (OEM base)
- [LTS Connection Guide](../lts/) — Another Hikvision OEM
- [Dahua Connection Guide](../dahua/) — Alternative OEM ecosystem
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Connect Aqara Camera in C# .NET — Token-Based RTSP Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/aqara/
**Description:** Connect Aqara cameras in C# / .NET via RTSP. Token-based URLs for G2H, G3, E1, and G4 Doorbell. Aqara Home app setup and code samples included.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, C#
**API:** RTSPSourceSettings

# How to Connect to Aqara Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Aqara** is a Chinese smart home brand (by Lumi United Technology) that produces Zigbee/Thread-based smart home devices and cameras. Aqara cameras are unique in the market because they double as smart home hubs (Zigbee gateway) while also functioning as security cameras. Aqara primarily integrates with Apple HomeKit and supports RTSP for local streaming.

**Key facts:**

- **Product lines:** Camera Hub G2H/G3 (hub + camera), E1 (camera-only), G4 (doorbell)
- **Protocol support:** RTSP, Apple HomeKit Secure Video, Zigbee 3.0 (hub function)
- **Default RTSP port:** 554
- **Default credentials:** None — RTSP URL includes token
- **ONVIF support:** No
- **Video codecs:** H.264
- **Unique feature:** Cameras serve as Zigbee smart home hubs

RTSP Must Be Enabled in Aqara Home App

Aqara cameras have RTSP support but it must be enabled through the **Aqara Home** app. The app generates a unique RTSP URL with an authentication token. RTSP access works independently of HomeKit Secure Video.

## Enabling RTSP on Aqara Cameras

1. Open the **Aqara Home** app on your phone
2. Select your camera device
3. Go to **Camera Settings** (gear icon)
4. Find **RTSP** or **Network streaming**
5. Enable RTSP
6. The app will display the full RTSP URL with authentication token
7. Copy this URL for use in your application

## RTSP URL Patterns

### Standard URL Format

Aqara cameras use a token-based RTSP URL:

```
rtsp://[IP]:554/live/ch00_1?token=[AUTH_TOKEN]
```

The authentication token is generated by the Aqara Home app and is unique per camera.

### Camera Models

| Model | Type | RTSP Support | Resolution | Hub Function |
| --- | --- | --- | --- | --- |
| Camera Hub G2H Pro | Hub + camera | Yes | 1920x1080 | Zigbee 3.0 |
| Camera Hub G3 | Hub + camera | Yes | 2304x1296 (2K) | Zigbee 3.0 |
| Camera E1 | Camera only | Yes | 1920x1080 | No |
| G4 Video Doorbell | Doorbell | Limited | 1600x1200 | No |

### URL Variations

| URL Pattern | Description |
| --- | --- |
| `rtsp://IP:554/live/ch00_1?token=TOKEN` | Main stream (recommended) |
| `rtsp://IP:554/live/ch00_0?token=TOKEN` | Sub stream (lower resolution) |

## Connecting with VisioForge SDK

Use your Aqara camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Aqara Camera Hub G3, main stream (token from Aqara Home app)
var uri = new Uri("rtsp://192.168.1.90:554/live/ch00_1?token=YOUR_TOKEN_HERE");
var username = ""; // auth is in the token
var password = "";
```

Token-Based Authentication

Aqara cameras do not use username/password authentication for RTSP. Instead, the authentication token is embedded in the URL. Leave the username and password fields empty in `RTSPSourceSettings.CreateAsync()` and include the token in the URI.

## Troubleshooting

### RTSP URL not working

1. Verify RTSP is enabled in the Aqara Home app
2. Check that the token in the URL matches what the app displays
3. Ensure the camera and your application are on the same network
4. Try regenerating the RTSP URL in the app (Settings > RTSP > regenerate)

### Token expires or changes

The RTSP token may change after:

- Camera firmware updates
- Aqara Home app re-pairing
- Disabling and re-enabling RTSP

If your stream stops working, check the Aqara Home app for an updated URL.

### No ONVIF support

Aqara cameras do not support ONVIF. You cannot use ONVIF discovery to find Aqara cameras. The RTSP URL must be obtained from the Aqara Home app.

### Limited to H.264

Aqara cameras encode in H.264 only. There is no H.265 option. This ensures broad compatibility but uses more bandwidth than H.265 at equivalent quality.

## FAQ

**What is the default RTSP URL for Aqara cameras?**

Aqara cameras use `rtsp://CAMERA_IP:554/live/ch00_1?token=AUTH_TOKEN` where the token is generated by the Aqara Home app. There are no default credentials -- authentication is handled via the URL token.

**Can I use Aqara cameras with HomeKit and RTSP simultaneously?**

Yes. HomeKit Secure Video and RTSP can run at the same time. Enabling RTSP does not disable HomeKit functionality. However, running both streams may slightly reduce camera performance.

**Do Aqara cameras work as Zigbee hubs while streaming RTSP?**

Yes. The Camera Hub G2H and G3 models serve as both Zigbee 3.0 gateways and cameras simultaneously. Enabling RTSP does not affect the hub functionality.

**Do Aqara cameras support ONVIF?**

No. Aqara cameras only support RTSP (with token auth) and HomeKit Secure Video. ONVIF discovery is not available.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [EZVIZ Connection Guide](../ezviz/) — Another smart home camera brand
- [TP-Link Connection Guide](../tp-link/) — Consumer cameras with RTSP
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## How to Connect to Arecont Vision IP Camera in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/arecont/
**Description:** Arecont Vision RTSP URL patterns for C# .NET. Integrate AV Series, MegaDome, and SurroundVideo panoramic cameras using VisioForge Video Capture SDK.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Arecont Vision IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Arecont Vision** (now part of Costar Group) is an American IP camera company originally founded in 2003 and based in Glendale, California. Arecont Vision was a pioneer of megapixel IP cameras and is known for high-resolution models (up to 20MP) and multi-sensor panoramic cameras. The company was acquired by **Costar Group** in 2019, which continues to support and manufacture Arecont Vision products.

**Key facts:**

- **Product lines:** AV Series (megapixel fixed), MegaDome, MegaBall, SurroundVideo (multi-sensor panoramic), MicroDome
- **Protocol support:** RTSP, ONVIF (newer models), PSIA, HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** Varies by model (many ship with no default password)
- **ONVIF support:** Yes (newer models), PSIA support on most models
- **Video codecs:** H.264, MJPEG (older models MJPEG only)

Arecont Vision and Costar Group

Arecont Vision was acquired by Costar Group in 2019. Existing Arecont cameras continue to use the same RTSP and PSIA URL formats. Newer Costar-branded models may use updated firmware but maintain backward-compatible URL patterns.

## RTSP URL Patterns

### Standard URL Formats

Arecont Vision cameras support multiple RTSP URL patterns depending on the model generation and configured protocol:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/h264.sdp
```

| URL Pattern | Protocol | Description |
| --- | --- | --- |
| `rtsp://IP:554/h264.sdp` | H.264 | Standard H.264 stream (most current models) |
| `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264` | PSIA | PSIA-based H.264 stream |
| `rtsp://IP:554/cam1/mpeg4` | MPEG-4 | Legacy MPEG-4 stream (older models) |

### H.264 Stream with ROI Parameters

Arecont cameras support optional Region of Interest (ROI) parameters for customizing the stream output:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/h264.sdp?res=half&x0=0&y0=0&x1=1600&y1=1200&quality=15&doublescan=0
```

| Parameter | Values | Description |
| --- | --- | --- |
| `res` | `full`, `half` | Stream resolution (full or half of sensor resolution) |
| `x0`, `y0` | 0 - max | Top-left corner of the region of interest |
| `x1`, `y1` | 0 - max | Bottom-right corner of the region of interest |
| `quality` | 1 - 21 | JPEG/H.264 quality factor (lower = higher quality) |
| `doublescan` | 0, 1 | Enable double-scan mode for improved image quality |

ROI Parameters Are Optional

The ROI parameters (`res`, `x0`, `y0`, `x1`, `y1`, `quality`, `doublescan`) are optional and can be omitted entirely for full-frame streaming. Use `rtsp://IP:554/h264.sdp` without parameters for the simplest connection.

### Camera Models

| Model Series | Resolution | Main Stream URL | Codec |
| --- | --- | --- | --- |
| AV Series (generic megapixel) | Varies | `rtsp://IP:554/h264.sdp` | H.264 |
| AV2100 (2MP) | 1600x1200 | `rtsp://IP:554/cam1/mpeg4` | MPEG-4 |
| AV5115/AV5125 | 2592x1944 | `rtsp://IP:554/h264.sdp` | H.264 |
| AV8185DN (8MP multi-sensor) | 6400x1200 | `rtsp://IP:554/h264.sdp` | H.264 |
| AV10005/AV10115 (10MP) | 3648x2752 | `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264` | H.264 |
| AV20185 (20MP multi-sensor) | 10240x1536 | `rtsp://IP:554/h264.sdp` | H.264 |
| MegaDome Series | Varies | `rtsp://IP:554/h264.sdp` | H.264 |
| MegaBall Series | Varies | `rtsp://IP:554/h264.sdp` | H.264 |
| MicroDome Series | Varies | `rtsp://IP:554/h264.sdp` | H.264 |

### PSIA Streaming URLs

Models that support the PSIA protocol can use the following URL format:

| Channel | URL |
| --- | --- |
| Channel 0 (default) | `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264` |
| Channel 1 | `rtsp://IP:554/PSIA/Streaming/channels/1?videoCodecType=H.264` |

## Connecting with VisioForge SDK

Use your Arecont Vision camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Arecont Vision AV Series, H.264 main stream
var uri = new Uri("rtsp://192.168.1.90:554/h264.sdp");
var username = "admin";
var password = "YourPassword";
```

For PSIA-based streaming, use the PSIA URL instead:

```
// Arecont Vision via PSIA protocol
var uri = new Uri("rtsp://192.168.1.90:554/PSIA/Streaming/channels/0?videoCodecType=H.264");
```

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/img.jpg` | Most models, requires basic auth |
| JPEG Snapshot (alt) | `http://IP/Jpeg/CamImg.jpg` | Alternative snapshot URL |
| Configurable Snapshot | `http://IP/image?res=half&x0=0&y0=0&x1=1600&y1=1200&quality=15&doublescan=0` | Snapshot with ROI parameters |
| MJPEG Stream | `http://IP/mjpeg?res=full&x0=0&y0=0&x1=100%&y1=100%&quality=12&doublescan=0` | Continuous MJPEG stream |

### Multi-Sensor (SurroundVideo) Snapshot URLs

For SurroundVideo and other multi-sensor cameras, each sensor has its own snapshot URL:

| Sensor | URL Pattern | Notes |
| --- | --- | --- |
| Channel 1 | `http://IP/image1?res=half&x1=0&y1=0` | First sensor |
| Channel 2 | `http://IP/image2?res=half&x1=0&y1=0` | Second sensor |
| Channel 3 | `http://IP/image3?res=half&x1=0&y1=0` | Third sensor |
| Channel 4 | `http://IP/image4?res=half&x1=0&y1=0` | Fourth sensor |

## Troubleshooting

### ROI parameters causing issues

Arecont cameras have unique Region of Interest parameters (`res`, `x0`, `y0`, `x1`, `y1`, `quality`, `doublescan`) embedded in their URLs. If you encounter connection problems:

1. Remove all ROI parameters and use the bare URL: `rtsp://IP:554/h264.sdp`
2. Verify the camera resolution supports the requested ROI coordinates
3. Use `res=full` for full-resolution streaming or `res=half` for reduced bandwidth

### MJPEG-only on older models

Some older Arecont models (AV1300, AV2100, AV3100) only support MJPEG encoding and do not have H.264 capability. For these cameras:

- Use the MPEG-4 RTSP URL: `rtsp://IP:554/cam1/mpeg4`
- Or use the HTTP MJPEG stream: `http://IP/mjpeg`

### PSIA vs direct RTSP

Arecont cameras support both direct RTSP and PSIA-based RTSP URLs. If one format does not work:

- Try the alternative format (switch between `h264.sdp` and `PSIA/Streaming/channels/0`)
- Verify the camera firmware version supports the chosen protocol
- Check that PSIA is enabled in the camera's web interface

### Connection timeout

Arecont cameras may take longer to establish an RTSP session than other brands, especially for high-resolution (10MP+) models:

- Increase your connection timeout to at least 10 seconds
- For multi-sensor models, connect to individual channels rather than the composite stream for lower latency

## FAQ

**What RTSP URL format does Arecont Vision use?**

The primary RTSP URL is `rtsp://IP:554/h264.sdp` for H.264 streaming. PSIA-based streaming uses `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264`. Older models may use `rtsp://IP:554/cam1/mpeg4` for MPEG-4 streams.

**Are Arecont Vision cameras still supported after the Costar acquisition?**

Yes. Costar Group acquired Arecont Vision in 2019 and continues to manufacture and support Arecont Vision camera products. Existing cameras remain fully functional, and firmware updates are available through Costar's support channels.

**How do I connect to a multi-sensor SurroundVideo camera?**

SurroundVideo cameras expose individual sensor channels through numbered URLs. For snapshots, use `http://IP/image1`, `http://IP/image2`, etc. For RTSP, use the standard H.264 URL with the full panoramic composite, or PSIA channel-based URLs for individual sensors.

**Do Arecont Vision cameras support ONVIF?**

Newer Arecont Vision models support ONVIF Profile S. Older models rely on the PSIA protocol instead. Check your camera's specifications or web interface to confirm ONVIF availability.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [GeoVision Connection Guide](../geovision/) — Professional surveillance cameras
- [ONVIF Capture with Postprocessing](../../mediablocks/Guides/onvif-capture-with-postprocessing/) — Arecont ONVIF capture pipeline
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## How to Connect to Arlo Camera in C# .NET - RTSP Workarounds
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/arlo/
**Description:** Arlo camera RTSP limitations in C# .NET. No native RTSP support. Workaround options and alternative camera recommendations for developers.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Webcam, IP Camera, RTSP, ONVIF, C#
**API:** MediaBlocksPipeline, SystemVideoSourceBlock, VideoRendererBlock

# How to Connect to Arlo Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Arlo Technologies** is an American smart home security company headquartered in Carlsbad, California. Originally a Netgear brand, Arlo became independent in 2018. Arlo is one of the best-selling wireless security camera brands in North America and Europe, known for battery-powered outdoor cameras, doorbells, and floodlight cameras.

**Key facts:**

- **Product lines:** Pro (flagship), Ultra (4K), Essential (value), Go (cellular), Floodlight, Doorbell
- **Architecture:** Cloud-first with optional local storage (Arlo SmartHub/Base Station)
- **RTSP support:** No (removed from SmartHub in 2021)
- **ONVIF support:** No
- **Video codecs:** H.264, H.265 (select models)
- **Cloud dependency:** High — all features require Arlo Secure subscription
- **Power:** Battery, solar, or wired depending on model

No RTSP Support

Arlo cameras do **not** support RTSP. Arlo previously offered RTSP access through the SmartHub (VMB4540/VMB5000) for select camera models, but this feature was **removed** in a 2021 firmware update. There is currently no way to access Arlo camera streams via RTSP.

## RTSP History on Arlo

Arlo had a brief period of RTSP support:

| Period | Status | Details |
| --- | --- | --- |
| Before 2019 | No RTSP | Cloud-only access |
| 2019-2021 | RTSP available (beta) | Via SmartHub for Ultra/Pro 3/Pro 4 only |
| 2021-present | RTSP removed | Firmware update removed RTSP functionality |

The RTSP feature was available on the **Arlo SmartHub (VMB5000)** for: - Arlo Ultra (VMC5040) - Arlo Pro 3 (VMC4040P) - Arlo Pro 4 (VMC4050P)

It was never available for Arlo Essential, Go, or Doorbell models.

## Why No Direct Integration

Arlo's architecture prevents direct SDK integration:

1. **Cloud-mandatory streaming:** All video routes through Arlo's cloud servers
2. **No local network access:** Cameras communicate with the SmartHub/base station using proprietary protocols
3. **No open ports:** Neither cameras nor base stations expose RTSP or HTTP video endpoints
4. **Subscription dependency:** Video access requires an active Arlo Secure plan

## Possible Workarounds

### Option 1: Arlo API (Unofficial)

Community-developed libraries exist that interface with Arlo's cloud API to:

- Retrieve snapshot images
- Download recorded clips
- Trigger camera actions

These are unofficial and may break with Arlo service updates. They do not provide real-time RTSP streams.

### Option 2: HDMI Output from SmartHub

The Arlo SmartHub (VMB5000) has an HDMI output that displays a live camera grid. You can capture this with an HDMI capture card:

```
// Capture HDMI output from Arlo SmartHub via USB capture card
var pipeline = new MediaBlocksPipeline();

var captureDevice = new SystemVideoSourceBlock(captureDeviceSettings);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(captureDevice.Output, videoRenderer.Input);
await pipeline.StartAsync();
```

This provides a composite view of all cameras, not individual streams.

## Recommended Alternatives

For developers needing direct RTSP camera integration, these consumer cameras provide native RTSP support:

| Alternative | Type | RTSP | Battery Option | Guide |
| --- | --- | --- | --- | --- |
| Reolink Argus 3 | Battery outdoor | Yes | Yes | [Connection Guide](../reolink/) |
| Amcrest | Wired outdoor | Yes | No | [Connection Guide](../amcrest/) |
| EZVIZ | Indoor/outdoor | Yes (enable required) | Limited | [Connection Guide](../ezviz/) |
| TP-Link Tapo | Indoor/outdoor | Yes | No | [Connection Guide](../tp-link/) |
| Eufy Security | Wired/battery | Yes (some models) | Yes | [Connection Guide](../eufy/) |

## FAQ

**Do Arlo cameras support RTSP?**

No. Arlo cameras do not currently support RTSP. A brief RTSP beta was available on the SmartHub (2019-2021) for select models, but it was removed in a firmware update. There is no current way to access Arlo streams via RTSP.

**Can I use VisioForge SDK with Arlo cameras?**

Not directly. Arlo cameras have no RTSP, ONVIF, or local streaming endpoints. The only integration option is capturing the HDMI output from the SmartHub using a capture card. For direct SDK integration, use cameras with native RTSP support.

**Will Arlo bring back RTSP?**

There has been no official announcement from Arlo about restoring RTSP support. Arlo's business model is subscription-based, and local streaming conflicts with this approach.

**What battery cameras support RTSP?**

For battery-powered cameras with RTSP support, consider [Reolink](../reolink/) (Argus series) or [Eufy Security](../eufy/) (select models). Most battery cameras from other brands are also cloud-only.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Reolink Connection Guide](../reolink/) — Consumer alternative with RTSP
- [Eufy Security Connection Guide](../eufy/) — Consumer with partial RTSP
- [Wyze Connection Guide](../wyze/) — Another cloud-first brand with limited RTSP
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Avigilon IP Camera RTSP URL Patterns and C# .NET Setup
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/avigilon/
**Description:** Avigilon H5A, H5M, H5 Pro, H5SL, and Unity NVR RTSP URL patterns for C# .NET. Enterprise camera integration with VisioForge SDK code samples.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Decoding, IP Camera, RTSP, ONVIF, H.265, MJPEG, C#

# How to Connect to Avigilon IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Avigilon** (Avigilon Corporation) is an enterprise security camera manufacturer originally based in Vancouver, Canada. Founded in 2004, Avigilon was acquired by **Motorola Solutions** in 2018 for approximately $1 billion. The company is known for high-resolution cameras (up to 61MP), AI-powered video analytics including Unusual Motion Detection (UMD) and Appearance Search, and proprietary HDSM (High Definition Stream Management) technology. Avigilon cameras are widely deployed in enterprise, government, and critical infrastructure environments.

**Key facts:**

- **Product lines:** H5A (bullet/dome), H5M (mini dome), H5 Pro (multi-sensor), H5SL (value line), Unity (NVRs)
- **Previous lines:** HD Pro, HD Multisensor, HD Micro Dome, HD PTZ
- **Protocol support:** RTSP, ONVIF (Profile S, Profile T), HTTP
- **Default RTSP port:** 554
- **Default credentials:** admin / admin (must be changed on initial setup)
- **ONVIF support:** Yes (Profile S, Profile T)
- **Video codecs:** H.264, H.265, HDSM SmartCodec (H.265-based)
- **Known for:** AI analytics (Unusual Motion Detection, Appearance Search), HDSM SmartCodec

Avigilon is now part of Motorola Solutions

Avigilon is now part of Motorola Solutions. The Avigilon camera line continues under the Motorola Solutions Video Security & Access Control division. See also our [Pelco guide](../pelco/) for another Motorola Solutions camera brand.

## RTSP URL Patterns

### Standard URL Format

Avigilon cameras use the `defaultPrimary` / `defaultSecondary` URL pattern with a unicast stream type parameter:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/defaultPrimary?streamType=u
```

| Parameter | Value | Description |
| --- | --- | --- |
| `defaultPrimary` | Primary stream | Main stream (highest resolution) |
| `defaultSecondary` | Secondary stream | Sub stream (lower resolution, less bandwidth) |
| `streamType` | `u` | Unicast stream delivery |

### Camera Models

| Model Series | Type | Main Stream URL | Notes |
| --- | --- | --- | --- |
| H5A Bullet | Fixed bullet | `rtsp://IP:554/defaultPrimary?streamType=u` | AI-enabled, up to 8MP |
| H5A Dome | Fixed dome | `rtsp://IP:554/defaultPrimary?streamType=u` | AI-enabled, up to 8MP |
| H5M Mini Dome | Mini dome | `rtsp://IP:554/defaultPrimary?streamType=u` | Compact form factor |
| H5 Pro Multi-sensor | Multi-sensor | `rtsp://IP:554/defaultPrimary0?streamType=u` | See multi-sensor note below |
| H5SL Bullet | Value bullet | `rtsp://IP:554/defaultPrimary?streamType=u` | Cost-effective line |
| H5SL Dome | Value dome | `rtsp://IP:554/defaultPrimary?streamType=u` | Cost-effective line |
| HD Pro | Legacy high-res | `rtsp://IP:554/defaultPrimary?streamType=u` | Up to 61MP |

### Multi-Sensor Camera URLs

For Avigilon H5 Pro and other multi-sensor cameras, each sensor head has its own stream index:

| Sensor | Main Stream | Sub Stream |
| --- | --- | --- |
| Sensor 1 | `rtsp://IP:554/defaultPrimary0?streamType=u` | `rtsp://IP:554/defaultSecondary0?streamType=u` |
| Sensor 2 | `rtsp://IP:554/defaultPrimary1?streamType=u` | `rtsp://IP:554/defaultSecondary1?streamType=u` |
| Sensor 3 | `rtsp://IP:554/defaultPrimary2?streamType=u` | `rtsp://IP:554/defaultSecondary2?streamType=u` |
| Sensor 4 | `rtsp://IP:554/defaultPrimary3?streamType=u` | `rtsp://IP:554/defaultSecondary3?streamType=u` |

### Alternative URL Formats

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/defaultPrimary?streamType=u` | Standard primary (recommended) |
| `rtsp://IP:554/defaultSecondary?streamType=u` | Secondary / sub stream |
| `rtsp://IP:554/defaultPrimary0?streamType=u` | Primary stream alternate (also used for multi-sensor sensor 1) |

## Connecting with VisioForge SDK

Use your Avigilon camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Avigilon H5A dome, primary stream (unicast)
var uri = new Uri("rtsp://192.168.1.100:554/defaultPrimary?streamType=u");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `defaultSecondary` instead of `defaultPrimary`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/snapshot.jpg` | Requires basic auth |

## Troubleshooting

### "401 Unauthorized" error

Avigilon cameras require the default password to be changed during initial setup. If you have not configured the camera yet:

1. Access the camera at `http://CAMERA_IP` in a browser
2. Complete the initial setup wizard and set a strong password
3. Use those credentials in your RTSP URL

### HDSM SmartCodec streams

Avigilon's HDSM SmartCodec is based on H.265. Ensure your decoder supports H.265 when connecting to cameras configured to use HDSM SmartCodec. If you experience decoding issues, try switching the camera to standard H.264 encoding in the camera's web interface.

### Stream type parameter

The `streamType=u` parameter requests unicast delivery. If you omit this parameter, the camera may default to multicast, which can cause issues on networks not configured for multicast routing.

### Multi-sensor cameras show only one view

For multi-sensor models (H5 Pro), each sensor is accessed as a separate stream. Use `defaultPrimary0`, `defaultPrimary1`, etc. to access individual sensor heads. See the multi-sensor URL table above.

## FAQ

**What is the default RTSP URL for Avigilon cameras?**

The URL is `rtsp://admin:password@CAMERA_IP:554/defaultPrimary?streamType=u` for the primary stream. Use `defaultSecondary` instead of `defaultPrimary` for the lower-resolution sub stream.

**Do Avigilon cameras support ONVIF?**

Yes. Avigilon cameras support ONVIF Profile S and Profile T. ONVIF can be enabled through the camera's web interface or Avigilon Control Center (ACC) software.

**What is HDSM SmartCodec?**

HDSM (High Definition Stream Management) SmartCodec is Avigilon's proprietary compression technology built on H.265. It reduces bandwidth and storage requirements by intelligently encoding different regions of the image at different quality levels while maintaining detail in areas of interest. Streams encoded with HDSM SmartCodec are compatible with standard H.265 decoders.

**Can I use Avigilon cameras without Avigilon Control Center?**

Yes. While Avigilon Control Center (ACC) is the recommended VMS, the cameras expose standard RTSP streams and support ONVIF, allowing integration with any RTSP-compatible application including VisioForge SDKs.

**How do I access individual sensors on multi-sensor cameras?**

Each sensor head on a multi-sensor camera (such as the H5 Pro) has its own stream URL. Use `defaultPrimary0` for sensor 1, `defaultPrimary1` for sensor 2, and so on. Each sensor can also have a secondary stream accessed via `defaultSecondary0`, `defaultSecondary1`, etc.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Pelco Connection Guide](../pelco/) — Also Motorola Solutions, enterprise cameras
- [ONVIF Capture with Postprocessing](../../mediablocks/Guides/onvif-capture-with-postprocessing/) — Avigilon ONVIF capture pipeline
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## AVTech IP Camera RTSP URL and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/avtech/
**Description:** AVTech IP camera integration guide for C# .NET with RTSP URL patterns, DVR/NVR channel URLs, and code samples for AVM, AVN, AVC, and AVI models.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, AVI, H.264, MJPEG, C#

# How to Connect to AVTech IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**AVTech** (AVTech Corporation) is a Taiwanese surveillance equipment manufacturer based in Taipei, Taiwan, founded in 1996. AVTech is one of the largest DVR/NVR manufacturers globally, with a strong presence in Asia-Pacific, Middle East, and Latin American markets. The company produces a wide range of IP cameras, DVRs, NVRs, and the EagleEyes mobile viewing platform. AVTech is known for offering cost-effective surveillance solutions with broad model compatibility.

**Key facts:**

- **Product lines:** AVM (IP cameras), AVN (network cameras), AVC (DVRs), AVI (specialty cameras), EagleEyes (mobile app)
- **Protocol support:** RTSP, ONVIF (newer models), HTTP/CGI, MJPEG
- **Default RTSP port:** 554 (some models use port 88)
- **Default credentials:** admin / admin
- **ONVIF support:** Yes (newer models)
- **Video codecs:** H.264, MPEG-4, MJPEG
- **Guest access:** Many models allow unauthenticated JPEG snapshots via guest CGI

Some AVTech models use port 88

Some newer AVTech models use port 88 instead of 554 for RTSP. If port 554 doesn't work, try port 88 with the URL pattern `rtsp://IP:88//live/h264_ulaw/VGA`.

Guest access security

Many AVTech cameras expose a guest CGI endpoint (`/cgi-bin/guest/Video.cgi`) that allows unauthenticated snapshot access. Ensure your camera's guest access settings are configured securely.

## RTSP URL Patterns

### Standard URL Format

AVTech cameras use the `/live/` path-based URL pattern:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/live/h264
```

| Parameter | Value | Description |
| --- | --- | --- |
| `/live/h264` | H.264 stream | Main H.264 video stream |
| `/live/mpeg4` | MPEG-4 stream | Legacy MPEG-4 video stream |
| `/live/h264/ch[N]` | Channel N | Channel-specific stream for DVRs/NVRs |

### Camera Models

| Model | Type | Main Stream URL | Notes |
| --- | --- | --- | --- |
| AVM217 | IP camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVM328 | IP dome | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVM357 | IP dome | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVM457 | IP camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVM459 | IP camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVM552 | IP camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVM561 | IP dome | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVM571 | IP camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVN211 | Network camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVN252 | Network camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVN257 | Network camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVN304 | Network camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVN314 | Network camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVN362 | Network camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVN801 | Network camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVN812 | Network camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVN813 | Network camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVI201 | IP camera | `rtsp://IP:554/live/h264` | H.264 main stream |
| AVI203 | IP camera | `rtsp://IP:554/live/h264` | H.264 main stream |

### DVR/NVR Channel URLs

For AVTech DVRs and NVRs (AVC series and others):

| Channel | Main Stream (H.264) | Main Stream (MPEG-4) |
| --- | --- | --- |
| Channel 1 | `rtsp://IP:554/live/h264/ch1` | `rtsp://IP:554/live/mpeg4/ch1` |
| Channel 2 | `rtsp://IP:554/live/h264/ch2` | `rtsp://IP:554/live/mpeg4/ch2` |
| Channel 3 | `rtsp://IP:554/live/h264/ch3` | `rtsp://IP:554/live/mpeg4/ch3` |
| Channel N | `rtsp://IP:554/live/h264/chN` | `rtsp://IP:554/live/mpeg4/chN` |

### Alternative URL Formats

Some AVTech models, particularly newer ones, use port 88 and different path formats:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/live/h264` | Standard H.264 (recommended) |
| `rtsp://IP:554/live/mpeg4` | MPEG-4 stream |
| `rtsp://IP//live/h264` | Without explicit port (some models) |
| `rtsp://IP:88//live/h264_ulaw/VGA` | Port 88, with audio, VGA resolution |
| `rtsp://IP:88//live/video_audio/profile1` | Port 88 with profile selection |

## Connecting with VisioForge SDK

Use your AVTech camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// AVTech AVM552, H.264 main stream
var uri = new Uri("rtsp://192.168.1.80:554/live/h264");
var username = "admin";
var password = "YourPassword";
```

For MPEG-4 stream access, use `/live/mpeg4` instead of `/live/h264`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot (guest) | `http://IP/cgi-bin/guest/Video.cgi?media=JPEG` | No authentication required (if guest access enabled) |
| JPEG Snapshot (channel) | `http://IP/cgi-bin/guest/Video.cgi?media=JPEG&channel=CHANNEL` | Channel-specific snapshot |
| MJPEG Live Stream | `http://IP/live/mjpeg` | Continuous MJPEG stream |

## Troubleshooting

### "401 Unauthorized" error

If you receive an authentication error:

1. Verify your credentials - default is admin / admin
2. Access the camera at `http://CAMERA_IP` in a browser to confirm login works
3. Ensure RTSP is enabled in the camera's network settings
4. Try including credentials in the URL: `rtsp://admin:password@IP:554/live/h264`

### Port 554 vs port 88

Some newer AVTech models use port 88 instead of the standard RTSP port 554. If you cannot connect on port 554:

1. Try port 88: `rtsp://IP:88//live/h264_ulaw/VGA`
2. Note the double slash (`//`) in some port 88 URL patterns
3. Check the camera's web interface under network settings for the configured RTSP port

### MPEG-4 vs H.264

Older AVTech models may only support MPEG-4. If the H.264 stream URL does not work:

- Try `rtsp://IP:554/live/mpeg4` instead
- Check the camera's encoding settings in the web interface
- Newer models support H.264; older models may be MPEG-4 only

### Double slash in URL

Some AVTech URL patterns include a double slash (`//`) after the IP or port. This is intentional and required by certain firmware versions. If a single-slash URL does not work, try the double-slash variant.

### EagleEyes mobile app

The EagleEyes app is AVTech's mobile viewing platform. RTSP access works independently of EagleEyes and does not require the app to be configured.

## FAQ

**What is the default RTSP URL for AVTech cameras?**

The URL is `rtsp://admin:password@CAMERA_IP:554/live/h264` for the main H.264 stream. For DVRs/NVRs, append the channel number: `rtsp://IP:554/live/h264/ch1` for channel 1.

**Do AVTech cameras support ONVIF?**

Newer AVTech models support ONVIF. Older models may not have ONVIF support and rely on proprietary protocols and RTSP for integration.

**What is the difference between AVM and AVN series?**

The AVM series are IP cameras designed for direct network connection, while the AVN series are network cameras that may include additional features such as built-in Wi-Fi or audio. Both series use the same RTSP URL format.

**Can I access AVTech snapshots without authentication?**

Many AVTech cameras have a guest CGI endpoint (`/cgi-bin/guest/Video.cgi?media=JPEG`) that allows unauthenticated JPEG snapshot access. This is a security concern if your camera is network-accessible. Check your camera's guest access settings and disable guest access if not needed.

**Why do some AVTech URLs use port 88?**

Some newer AVTech firmware versions default to port 88 for RTSP instead of the standard port 554. If you cannot connect on port 554, try port 88. The port setting can typically be verified and changed in the camera's web interface under network configuration.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [LILIN Connection Guide](../lilin/) — Taiwanese industrial cameras
- [BrickCom Connection Guide](../brickcom/) — Taiwanese industrial cameras
- [ONVIF IP Camera Integration](../../videocapture/video-sources/ip-cameras/onvif/) — AVTech ONVIF device discovery
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Axis IP Camera RTSP URL Format and C# .NET Integration
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/axis/
**Description:** Connect to Axis Communications cameras in C# .NET with RTSP URL patterns, VAPIX API, and code samples for M, P, Q, and F series models.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, IP Camera, RTSP, ONVIF, H.264, H.265, MJPEG, C#

# How to Connect to Axis IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Axis Communications** is a Swedish manufacturer widely regarded as the pioneer of network cameras, having created the world's first IP camera in 1996. Headquartered in Lund, Sweden and now a subsidiary of Canon, Axis produces premium IP cameras, encoders, and network audio products primarily for the professional and enterprise surveillance market.

**Key facts:**

- **Product lines:** M-series (compact/mini), P-series (fixed), Q-series (professional), F-series (modular), V-series (vandal-resistant), PTZ cameras
- **Protocol support:** ONVIF Profile S/G/T, RTSP, VAPIX (Axis proprietary HTTP API), HTTP/MJPEG
- **Default RTSP port:** 554
- **Default credentials:** root / (set during initial setup; older firmware: root / pass)
- **ONVIF support:** Full -- Axis was a founding member of ONVIF
- **Video codecs:** H.264, H.265 (newer models), MJPEG
- **Unique features:** VAPIX HTTP API for comprehensive camera control, ACAP (Axis Camera Application Platform)

## RTSP URL Patterns

Axis cameras use the `axis-media/media.amp` RTSP path with optional parameters for resolution and codec control.

### URL Format

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:[PORT]/axis-media/media.amp
```

### Primary RTSP URLs

| Model Series | RTSP URL | Codec | Audio |
| --- | --- | --- | --- |
| All modern models | `rtsp://IP:554/axis-media/media.amp` | H.264 (default) | Possible |
| All modern models | `rtsp://IP:554/axis-media/media.amp?videocodec=h264` | H.264 (explicit) | Possible |
| All modern models | `rtsp://IP:554/axis-media/media.amp?videocodec=h265` | H.265 | Possible |
| ONVIF profile | `rtsp://IP:554/onvif-media/media.amp` | H.264 | Yes |
| Legacy models | `rtsp://IP:554/mpeg4/media.amp` | MPEG-4 | Possible |

### Stream Profile Selection

Axis cameras support named stream profiles that can be selected via URL parameter:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/axis-media/media.amp?streamprofile=Quality` | High quality profile |
| `rtsp://IP:554/axis-media/media.amp?streamprofile=Balanced` | Balanced profile |
| `rtsp://IP:554/axis-media/media.amp?streamprofile=Bandwidth` | Low bandwidth profile |
| `rtsp://IP:554/axis-media/media.amp?resolution=1920x1080` | Explicit resolution |
| `rtsp://IP:554/axis-media/media.amp?resolution=640x480` | Lower resolution |
| `rtsp://IP:554/axis-media/media.amp?fps=15` | Frame rate limit |

### Multi-Channel Models (Encoders, Multi-Sensor)

For multi-channel devices like video encoders (M7001, P7214) and multi-sensor cameras:

| Device | RTSP URL | Channel |
| --- | --- | --- |
| Channel 1 | `rtsp://IP:554/axis-media/media.amp?camera=1` | 1 |
| Channel 2 | `rtsp://IP:554/axis-media/media.amp?camera=2` | 2 |
| Channel 3 | `rtsp://IP:554/axis-media/media.amp?camera=3` | 3 |
| Channel 4 | `rtsp://IP:554/axis-media/media.amp?camera=4` | 4 |

### Legacy URL Formats

Older Axis cameras (200-series, early 1000-series) may require these formats:

| URL Pattern | Models | Notes |
| --- | --- | --- |
| `rtsp://IP:554/mpeg4/media.amp` | 200, 205, 206, 207 | MPEG-4 stream |
| `http://IP/axis-cgi/mjpg/video.cgi` | All models | MJPEG over HTTP |
| `http://IP/mjpg/video.mjpg` | 200-series | Direct MJPEG stream |
| `http://IP/axis-cgi/mjpg/video.cgi?camera=1` | Multi-channel | Specific channel |
| `http://IP/axis-cgi/mjpg/video.cgi?resolution=640x480` | All models | Resolution-specific |

## Connecting with VisioForge SDK

Use your Axis camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Axis camera, H.264 main stream
var uri = new Uri("rtsp://192.168.1.50:554/axis-media/media.amp");
var username = "root";
var password = "YourPassword";
```

For sub-stream access, add `?resolution=640x480` parameter.

### ONVIF Discovery

Axis was a founding member of ONVIF and has industry-leading ONVIF compliance. See the [ONVIF integration guide](../../mediablocks/Sources/) for discovery code examples.

## Snapshot and MJPEG URLs (VAPIX API)

Axis cameras provide the VAPIX HTTP API, which is more feature-rich than most other brands:

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/axis-cgi/jpg/image.cgi` | Current frame |
| Snapshot (sized) | `http://IP/axis-cgi/jpg/image.cgi?resolution=1920x1080` | Specific resolution |
| Snapshot (with overlay) | `http://IP/axis-cgi/jpg/image.cgi?date=1&clock=1` | Date/time overlay |
| Snapshot (camera select) | `http://IP/axis-cgi/jpg/image.cgi?camera=1` | Multi-channel device |
| Simple snapshot | `http://IP/jpg/image.jpg` | Basic JPEG capture |
| Sized snapshot | `http://IP/jpg/image.jpg?size=3` | Predefined size (1-5) |
| MJPEG stream | `http://IP/axis-cgi/mjpg/video.cgi` | Continuous MJPEG |
| MJPEG (resolution) | `http://IP/axis-cgi/mjpg/video.cgi?resolution=640x480` | Sized MJPEG |
| MJPEG (direct) | `http://IP/mjpg/video.mjpg` | Direct MJPEG (legacy) |

## Troubleshooting

### Audio "Possible" vs "Yes"

Axis marks audio support as "Possible" on many RTSP streams because audio availability depends on the camera model having a built-in microphone or external audio input. The RTSP URL is the same whether audio is present or not -- the SDK will automatically detect and use audio if available.

### "401 Unauthorized" errors

- Axis cameras default to digest authentication for RTSP
- Ensure you're using the correct credentials (default username is `root`, not `admin`)
- On newer firmware, password must meet complexity requirements (minimum 8 characters)

### MPEG-4 stream not available on newer models

Modern Axis cameras (firmware 5.x+) have dropped MPEG-4 support. Use `/axis-media/media.amp` (H.264) instead of `/mpeg4/media.amp`.

### Resolution not matching expected output

Axis cameras negotiate resolution dynamically. To force a specific resolution, add the `resolution` parameter: `rtsp://IP:554/axis-media/media.amp?resolution=1920x1080`

### Multi-channel encoder connections

When connecting to an Axis encoder (M7001, P7214, etc.), you must specify the camera/channel parameter. Without it, you get channel 1 by default.

## FAQ

**What is the default RTSP URL for Axis cameras?**

The standard URL is `rtsp://root:password@CAMERA_IP:554/axis-media/media.amp`. This works for virtually all modern Axis cameras (M, P, Q, F, V series). The default username is `root` (not `admin` like most other brands).

**How do I switch between H.264 and H.265 on Axis cameras?**

Add the `videocodec` parameter to the RTSP URL: `rtsp://IP:554/axis-media/media.amp?videocodec=h265` for H.265, or `videocodec=h264` for H.264. Note that H.265 is only available on newer Axis models with Artpec-7 or newer chipsets.

**Can I control stream quality via the RTSP URL?**

Yes. Axis supports several URL parameters: `resolution` (e.g., `1920x1080`), `fps` (frame rate), `compression` (0-100), and `streamprofile` (named profiles configured in the camera). Example: `rtsp://IP:554/axis-media/media.amp?resolution=1280x720&fps=15`.

**Why does Axis use "root" as the default username instead of "admin"?**

Axis cameras run embedded Linux, and following Unix conventions, the administrative user is named `root`. This is different from most other camera brands that use `admin`.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Bosch Connection Guide](../bosch/) — Enterprise surveillance peer
- [Hanwha Vision Connection Guide](../hanwha/) — Enterprise surveillance peer
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Basler IP Camera RTSP URL Connection Guide for C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/basler/
**Description:** Connect to Basler BIP2 IP cameras in C# .NET with RTSP URL patterns and code samples. Includes notes on machine vision vs IP security camera protocols.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, USB3 Vision / GigE, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Basler IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Basler** (Basler AG) is a German camera manufacturer headquartered in Ahrensburg, Germany, founded in 1988. Basler is a world leader in industrial machine vision cameras and also produces IP security cameras under the **BIP2** product line. While Basler's machine vision cameras use specialized industrial protocols, the BIP2 series provides standard RTSP and ONVIF connectivity for security and surveillance applications.

**Key facts:**

- **Product lines:** ace (machine vision), dart (compact), boost (high-speed), BIP2 (IP security)
- **Protocol support:** RTSP, ONVIF, HTTP/CGI (BIP2 series); GigE Vision, USB3 Vision (machine vision)
- **Default RTSP port:** 554
- **Default credentials:** admin / admin
- **ONVIF support:** Yes (BIP2 series)
- **Video codecs:** H.264, MPEG-4, MJPEG
- **Primary use:** Industrial vision, factory automation, quality inspection, IP surveillance

Machine Vision Cameras Use Different Protocols

Basler's ace, dart, and boost machine vision cameras use GigE Vision or USB3 Vision protocols, not RTSP. These require Basler's Pylon SDK or a GenICam-compatible framework. The RTSP URLs on this page apply to Basler's BIP2 IP security camera line.

## RTSP URL Patterns

### Standard URL Format

Basler BIP2 IP cameras use simple path-based RTSP URLs:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/h264
```

| Stream | URL Pattern | Description |
| --- | --- | --- |
| H.264 main stream | `rtsp://IP:554/h264` | Primary stream, best quality |
| MPEG-4 stream | `rtsp://IP:554/mpeg4` | Legacy MPEG-4 encoded stream |
| JPEG over RTSP | `rtsp://IP:554/jpeg` | JPEG frames over RTSP |

### Camera Models

| Model | Type | Main Stream URL | Codec |
| --- | --- | --- | --- |
| BIP2-1280c (720p) | IP bullet | `rtsp://IP:554/h264` | H.264 |
| BIP2-1300c (1.3MP) | IP bullet | `rtsp://IP:554/h264` | H.264 |
| BIP2-1920c (1080p) | IP bullet | `rtsp://IP:554/h264` | H.264 |
| BIP2-1300c-dn | IP day/night | `rtsp://IP:554/h264` | H.264 |
| BIP2-1920c-dn | IP day/night | `rtsp://IP:554/h264` | H.264 |

### Alternative URL Formats

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/h264` | H.264 stream (recommended) |
| `rtsp://IP:554/mpeg4` | MPEG-4 stream (legacy) |
| `rtsp://IP:554/jpeg` | JPEG over RTSP |

## Connecting with VisioForge SDK

Use your Basler camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Basler BIP2, H.264 main stream
var uri = new Uri("rtsp://192.168.1.90:554/h264");
var username = "admin";
var password = "admin";
```

For MPEG-4 streams, replace `/h264` with `/mpeg4` in the URL.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| MJPEG Stream | `http://IP/cgi-bin/mjpeg` | Continuous MJPEG stream |
| JPEG Snapshot | `http://IP/cgi-bin/jpeg?stream=0` | Snapshot from channel 0 |
| JPEG Snapshot (channel) | `http://IP/cgi-bin/jpeg?stream=CHANNEL` | Snapshot from specific channel |

## Troubleshooting

### Machine vision camera not connecting via RTSP

Basler's ace, dart, and boost cameras do not support RTSP. These cameras use GigE Vision (Ethernet) or USB3 Vision (USB) protocols and require Basler's Pylon SDK or a GenICam-compatible library. Only the BIP2 IP camera series supports RTSP streaming.

### "401 Unauthorized" error

Basler BIP2 cameras ship with default credentials `admin` / `admin`. If the credentials have been changed:

1. Access the camera web interface at `http://CAMERA_IP`
2. Log in and verify or reset the credentials
3. Use the updated credentials in your RTSP URL

### No video output on MPEG-4 stream

Some newer Basler BIP2 firmware versions may default to H.264 only. If the MPEG-4 stream returns no data:

1. Open the camera web interface
2. Navigate to video stream settings
3. Ensure MPEG-4 encoding is enabled
4. Alternatively, use the `/h264` stream path instead

### ONVIF discovery not finding the camera

ONVIF is supported on BIP2 series cameras only. Ensure:

- The camera firmware is up to date
- ONVIF is enabled in the camera's network settings
- The camera and discovery client are on the same subnet

## FAQ

**What is the default RTSP URL for Basler cameras?**

For Basler BIP2 IP cameras, the default URL is `rtsp://admin:admin@CAMERA_IP:554/h264` for the H.264 main stream. Replace the credentials if they have been changed from the defaults.

**Can I use VisioForge SDK with Basler machine vision cameras?**

The RTSP-based connection described on this page applies to Basler BIP2 IP security cameras only. Basler's machine vision cameras (ace, dart, boost) use GigE Vision or USB3 Vision protocols and require Basler's Pylon SDK or a GenICam-compatible framework for direct integration.

**Do Basler cameras support ONVIF?**

Yes, but only the BIP2 IP security camera series supports ONVIF. Basler's machine vision cameras use industrial protocols (GigE Vision, USB3 Vision) instead.

**What codecs do Basler IP cameras support?**

Basler BIP2 cameras support H.264, MPEG-4, and MJPEG. H.264 is recommended for the best balance of quality and bandwidth efficiency.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Mobotix Connection Guide](../mobotix/) — German industrial cameras
- [FLIR Connection Guide](../flir/) — Industrial and thermal imaging
- [Building Camera Applications with Media Blocks](../../mediablocks/GettingStarted/camera/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Bosch IP Camera RTSP URL Patterns and C# .NET Setup
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/bosch/
**Description:** Bosch Dinion, Flexidome, Autodome, and VIP encoder RTSP URL patterns for C# .NET. Integrate with VisioForge SDK for enterprise surveillance apps.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, IP Camera, RTSP, ONVIF, H.264, H.265, MJPEG, C#

# How to Connect to Bosch IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Bosch Security and Safety Systems** (a division of Robert Bosch GmbH) is a German manufacturer of professional and enterprise video surveillance equipment. Headquartered in Grasbrunn near Munich, Bosch produces IP cameras, encoders, recording solutions, and video analytics primarily for critical infrastructure, transportation, and enterprise security markets.

**Key facts:**

- **Product lines:** Dinion (bullet/box), Flexidome (dome), Autodome (PTZ), MIC (ruggedized), NBN/NDN/NTC (legacy network), NWC (compact), VideoJet/VIP (encoders)
- **Protocol support:** RTSP, ONVIF (Profile S/G/T), HTTP/CGI, Bosch VMS (BVMS), iSCSI direct recording
- **Default RTSP port:** 554
- **Default credentials:** Varies by model and firmware version; many require setup via Bosch Configuration Manager
- **ONVIF support:** Yes (all current IP cameras)
- **Video codecs:** H.264, H.265, MJPEG
- **Unique feature:** RTSP tunnel mode for firewall traversal

## RTSP URL Patterns

Bosch cameras use several URL patterns depending on the model generation. The most common are the `/rtsp_tunnel` and `/video` paths.

### Current Models (Bosch CPP series firmware)

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Video stream 1 | `rtsp://IP:554/video?inst=1` | Main stream |
| Video stream 2 | `rtsp://IP:554/video?inst=2` | Sub stream |
| RTSP tunnel | `rtsp://IP:554//rtsp_tunnel` | Firewall-friendly (note double slash) |
| H.264 direct | `rtsp://IP:554/h264` | Direct H.264 stream |

RTSP tunnel mode

The `//rtsp_tunnel` URL (with double slash) is Bosch's proprietary RTSP tunneling mode that works better through firewalls and NAT. It encapsulates RTP data within the RTSP TCP connection. Use the standard `/video` URL for most integrations.

### Model-Specific URLs

| Model Series | RTSP URL | Codec | Notes |
| --- | --- | --- | --- |
| Dinion IP 4000/5000/7000/8000 | `rtsp://IP:554/video?inst=1` | H.264/H.265 | Current |
| Flexidome IP 4000/5000/7000/8000 | `rtsp://IP:554/video?inst=1` | H.264/H.265 | Current |
| Autodome IP 4000/5000/7000 | `rtsp://IP:554/video?inst=1` | H.264/H.265 | Current PTZ |
| MIC IP fusion/starlight/ultra | `rtsp://IP:554/video?inst=1` | H.264/H.265 | Ruggedized |
| NDC-225-PI | `rtsp://IP:554//rtsp_tunnel` | H.264 | Legacy |
| NDC-255-P | `rtsp://IP:554//rtsp_tunnel` | H.264 | Legacy |
| NDC-265-P | `rtsp://IP:554/h264` | H.264 | Legacy |
| NDN-832v | `rtsp://IP:554//rtsp_tunnel` | H.264 | Legacy dome |
| NTC-255-PI | `rtsp://IP:554/video` | H.264 | Legacy thermal |
| NTC-265-PI | `rtsp://IP:554/h264` | H.264 | Legacy thermal |
| NTI-50022-V3 | `rtsp://IP:554/h264` | H.264 | IP bullet |
| NWC-0455-20P | `rtsp://IP:554/h264` | H.264 | Compact |

### Encoder URLs

Bosch video encoders (VideoJet, VIP series) allow connecting analog cameras to IP networks:

| Encoder | RTSP URL | Notes |
| --- | --- | --- |
| VideoJet 10 | `rtsp://IP:554/video?inst=1` | Single channel |
| VIP X1 | `rtsp://IP:554//rtsp_tunnel` | Single channel |
| VIP X1600 | `rtsp://IP:554/video?inst=1` | Multi-channel |
| VIP X2 | `rtsp://IP:554/video?inst=1` | Dual channel |

### DVR RTSP URLs

| DVR Model | RTSP URL | Notes |
| --- | --- | --- |
| DVR 440/480/600 | `rtsp://IP:554/rtsp_tunnel` | Single slash |
| DVR 440/480/600 | `rtsp://IP:554/video` | Alternative |
| DVR (channel) | `rtsp://IP:554/cgi-bin/rtspStream/CHANNEL` | Channel-specific |
| DVR (SDP) | `rtsp://IP:554/user=USER&password=PASS&channel=1&stream=0.sdp?` | SDP-based |

## Connecting with VisioForge SDK

Use your Bosch camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Bosch Dinion/Flexidome, main stream
var uri = new Uri("rtsp://192.168.1.60:554/video?inst=1");
var username = "service";
var password = "YourPassword";
```

For sub-stream access, use `?inst=2` instead of `?inst=1`. For legacy Bosch models, use the RTSP tunnel URL `//rtsp_tunnel` (note the double slash).

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/snap.jpg` | Basic snapshot |
| Snapshot (sized) | `http://IP/snap.jpg?JpegSize=XL` | XL, M sizes available |
| Snapshot (channel) | `http://IP/snap.jpg?JpegCam=CHANNEL` | Multi-channel encoders |
| Snapshot (auth) | `http://IP/snap.jpg?usr=USER&pwd=PASS` | URL-based auth |
| MJPEG Stream | `http://IP/img/mjpeg.jpg` | Continuous MJPEG |
| Image | `http://IP/img.jpg` | Single frame |
| Image (alt) | `http://IP/image.jpg` | Alternative path |

## Troubleshooting

### Double slash in rtsp\_tunnel URL

The `//rtsp_tunnel` URL (with double slash before `rtsp_tunnel`) is intentional for legacy Bosch cameras. This is not a typo:

- Correct: `rtsp://IP:554//rtsp_tunnel`
- Incorrect: `rtsp://IP:554/rtsp_tunnel` (may work on some models but not all)

### Bosch Configuration Manager required

Many Bosch cameras require initial setup through the **Bosch Configuration Manager** desktop application before RTSP access works. The camera may not respond to RTSP connections until initial configuration is complete.

### Default username varies

- **Current models:** `service` user with password set during setup
- **Legacy models:** May use `admin`, `user`, or `service` depending on firmware
- Check the Bosch Configuration Manager or camera's web interface for user settings

### inst parameter

The `?inst=1` parameter selects the video stream instance: - `inst=1` = First video stream (main) - `inst=2` = Second video stream (sub) - Not all models support multiple instances

### Encoder channel selection

For multi-channel encoders (VIP X1600, VideoJet X-series), use the `inst` parameter to select the channel: - `rtsp://IP:554/video?inst=1` = Channel 1 - `rtsp://IP:554/video?inst=2` = Channel 2

## FAQ

**What is the default RTSP URL for Bosch cameras?**

For current Bosch cameras, the URL is `rtsp://service:password@CAMERA_IP:554/video?inst=1`. For legacy models, try `rtsp://CAMERA_IP:554//rtsp_tunnel` or `rtsp://CAMERA_IP:554/h264`.

**What is Bosch RTSP tunnel mode?**

RTSP tunnel (`//rtsp_tunnel`) is Bosch's proprietary mode that encapsulates RTP data within the RTSP TCP connection, making it easier to traverse firewalls. It's the default streaming mode on many legacy Bosch cameras.

**Do Bosch cameras support H.265?**

Current Bosch IP cameras (CPP13/CPP14 platform, including Dinion/Flexidome 7000/8000 series) support H.265. Legacy cameras support H.264 and MPEG-4. Check your specific model's datasheet for codec support.

**Can I use Bosch encoders to connect analog cameras?**

Yes. Bosch VideoJet and VIP encoders convert analog camera signals to IP streams accessible via RTSP. Use the same URL format (`/video?inst=1` or `//rtsp_tunnel`) as IP cameras.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Axis Connection Guide](../axis/) — Enterprise surveillance peer
- [Honeywell Connection Guide](../honeywell/) — Enterprise / commercial segment
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## BrickCom IP Camera RTSP URL Setup Guide for C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/brickcom/
**Description:** BrickCom CB, MB, OB, VD, and WCB series RTSP URL patterns for C# .NET. Stream and record using VisioForge Video Capture SDK integration code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to BrickCom IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**BrickCom** (Brickcom Corporation) is a Taiwanese professional IP camera manufacturer headquartered in Taipei, Taiwan. Founded in 2004, BrickCom targets professional security and industrial surveillance markets with a wide range of form factors including bullet, dome, cube, and specialty cameras. The brand is known for its straightforward channel-based RTSP URL pattern across its product lines.

**Key facts:**

- **Product lines:** CB (cube), MB (mini bullet), OB (outdoor bullet), VD (vandal dome), FD (fixed dome), MD (multi-directional), WCB/WOB (wireless)
- **Channel-based URL pattern:** `/channel1` for main stream, `/channel2` for sub stream
- **Default RTSP port:** 554
- **Default credentials:** admin / admin
- **ONVIF support:** Yes (most models)
- **Video codecs:** H.264, MJPEG
- **Primary RTSP URL:** `rtsp://IP:554/channel1`

Channel numbering

BrickCom uses simple channel-based URLs. Use `/channel1` for the primary (high-quality) stream and `/channel2` for the secondary (lower bandwidth) stream.

## RTSP URL Patterns

### Standard URL Format

BrickCom cameras use a simple channel-based RTSP URL pattern:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/channel1
```

| Parameter | Value | Description |
| --- | --- | --- |
| `channel1` | Main stream | Primary stream (highest resolution) |
| `channel2` | Sub stream | Secondary stream (lower resolution, less bandwidth) |

### Camera Models

| Model | Type | Main Stream URL | Notes |
| --- | --- | --- | --- |
| CB-100 (cube) | Cube | `rtsp://IP:554/channel1` | Indoor cube camera |
| MB-300Ap (mini bullet) | Mini Bullet | `rtsp://IP:554/channel1` | Compact bullet form factor |
| OB-100Ap (outdoor bullet) | Outdoor Bullet | `rtsp://IP:554/channel1` | Weatherproof bullet |
| OB-300Af (outdoor bullet) | Outdoor Bullet | `rtsp://IP:554/channel1` | Auto-focus bullet |
| VD-130Ae (vandal dome) | Vandal Dome | `rtsp://IP:554/channel1` | IK10-rated dome |
| VD-301AF (vandal dome) | Vandal Dome | `rtsp://IP:554/channel1` | Auto-focus vandal dome |
| VD-500Af (vandal dome) | Vandal Dome | `rtsp://IP:554/channel1` | 5MP vandal dome |
| WCB-100Ap (wireless cube) | Wireless Cube | `rtsp://IP:554/channel1` | Wi-Fi cube camera |
| WCB-300AP (wireless cube) | Wireless Cube | `rtsp://IP:554/channel1` | Wi-Fi cube, 3MP |
| WOB-100Ae (wireless bullet) | Wireless Bullet | `rtsp://IP:554/channel1` | Wi-Fi outdoor bullet |
| MD-500AP-360-A1 (multi-dome) | Multi-Directional | `rtsp://IP:554/channel1` | 360-degree multi-sensor |

### Alternative URL Formats

Some BrickCom models and firmware versions support these additional RTSP URLs:

| URL Pattern | Supported Models | Notes |
| --- | --- | --- |
| `rtsp://IP:554/channel1` | Most models | Standard (recommended) |
| `rtsp://IP:554/h264` | Various | Direct H.264 stream |
| `rtsp://IP//ONVIF/channel2` | VD-500Af, WCB-100Ap | ONVIF sub stream |
| `rtsp://IP/stream/bidirect/channel1` | Select models | Bidirectional stream with audio |

## Connecting with VisioForge SDK

Use your BrickCom camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// BrickCom OB-300Af, main stream
var uri = new Uri("rtsp://192.168.1.90:554/channel1");
var username = "admin";
var password = "admin";
```

For sub-stream access, use `/channel2` instead of `/channel1`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/snapshot.jpg` | No authentication required |
| JPEG Snapshot (auth) | `http://IP/snapshot.jpg?user=USER&pwd=PASS` | URL-based authentication |
| Channel Snapshot | `http://IP/snapshot.jpg?user=USER&pwd=PASS&strm=1` | Specific channel with auth |
| CGI Snapshot | `http://IP/cgi-bin/media.cgi?action=getSnapshot` | CGI-based snapshot |
| HTTP Channel Stream | `http://IP/channel2` | HTTP sub stream |

## Troubleshooting

### "401 Unauthorized" error

BrickCom cameras ship with default credentials of **admin / admin**. If you have changed the password via the web interface:

1. Access the camera at `http://CAMERA_IP` in a browser
2. Navigate to **Configuration > User Management**
3. Verify your credentials
4. Use those credentials in your RTSP URL

### Channel URL not connecting

If `rtsp://IP:554/channel1` does not work, try the alternative H.264 URL:

- `rtsp://IP:554/h264` -- direct H.264 stream without channel specification
- Some older firmware versions may require the ONVIF format: `rtsp://IP//ONVIF/channel2`

### ONVIF discovery issues

BrickCom cameras support ONVIF on most models. If ONVIF discovery fails:

1. Access the web interface at `http://CAMERA_IP`
2. Navigate to **Configuration > Network > ONVIF**
3. Ensure ONVIF is enabled
4. Verify the ONVIF port (default: 80 or 8080)

### Wireless models (WCB/WOB) connection drops

Wireless BrickCom cameras (WCB and WOB series) may experience intermittent RTSP disconnections on congested Wi-Fi networks. Use the sub stream (`/channel2`) for lower bandwidth requirements, or connect via Ethernet for maximum reliability.

## FAQ

**What is the default RTSP URL for BrickCom cameras?**

The URL is `rtsp://admin:admin@CAMERA_IP:554/channel1` for the main stream. Use `/channel2` for the sub stream with lower resolution and bandwidth.

**Do BrickCom cameras support ONVIF?**

Yes. Most current BrickCom models support ONVIF. Some models also expose an ONVIF-specific RTSP path at `rtsp://IP//ONVIF/channel2`.

**What is the difference between channel1 and channel2?**

`/channel1` provides the primary high-resolution stream and `/channel2` provides a secondary lower-resolution stream suitable for thumbnails, mobile viewing, or bandwidth-constrained scenarios.

**Can I access multiple streams simultaneously?**

Yes. BrickCom cameras support concurrent connections to both `/channel1` and `/channel2`. The maximum number of simultaneous connections depends on the specific model.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [AVTech Connection Guide](../avtech/) — Taiwanese industrial cameras
- [LILIN Connection Guide](../lilin/) — Taiwanese professional cameras
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Canon IP Camera RTSP URL and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/canon/
**Description:** Canon VB-H, VB-M, VB-S, VB-R camera RTSP URL patterns for C# .NET. Integrate with VisioForge SDK for streaming and recording in WPF, WinForms, MAUI.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, H.265, MJPEG, C#

# How to Connect to Canon IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Canon Inc.** is a Japanese multinational corporation headquartered in Tokyo. Canon's IP camera division produces the **VB series** of network cameras targeting professional and enterprise surveillance markets. Canon cameras are known for their optical quality, leveraging Canon's expertise in lens manufacturing. Canon has been reducing its IP camera lineup in recent years, focusing on higher-end models.

**Key facts:**

- **Product lines:** VB-H series (box/PTZ, current), VB-M series (PTZ/compact), VB-S series (compact), VB-R series (PTZ), VB-C series (legacy PTZ)
- **Protocol support:** RTSP, ONVIF (VB-H and VB-M series), HTTP/CGI with proprietary `-wvhttp-01-` path
- **Default RTSP port:** 554
- **Default credentials:** root / (camera-specific) or admin / admin (varies by model)
- **ONVIF support:** Yes (VB-H and VB-M series)
- **Video codecs:** H.264, H.265 (VB-H47, VB-H761 series), MJPEG

## RTSP URL Patterns

Canon cameras use profile-based streaming with channel and profile identifiers in the URL path.

### Current Models (VB-H / VB-M / VB-S / VB-R Series)

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Channel-based | `rtsp://IP:554/cam1/h264` | Channel 1, H.264 |
| Profile stream | `rtsp://IP:554//stream/profile1=r` | Profile 1, read mode (note double slash) |
| Profile (short) | `rtsp://IP:554/profile1=r` | Profile 1, shorter variant |
| Unicast profile | `rtsp://IP/profile1=u` | Unicast mode, no port |

Profile-based streaming

Canon cameras use profile identifiers with access modes: `profile1=r` for **read** (multicast-capable) and `profile1=u` for **unicast** (direct connection). Use `=r` for general access and `=u` when connecting directly without multicast.

### Model-Specific URLs

| Model | RTSP URL | Type | Notes |
| --- | --- | --- | --- |
| VB-H41 | `rtsp://IP:554//stream/profile1=r` | Fixed box | Profile with double slash |
| VB-H43 / VB-H45 | `rtsp://IP:554/cam1/h264` | Fixed box | Channel-based |
| VB-H47 | `rtsp://IP:554/cam1/h264` | Fixed box | H.265 capable |
| VB-H610D / VB-H610VE | `rtsp://IP:554/cam1/h264` | Fixed dome | Current |
| VB-H730F | `rtsp://IP:554/cam1/h264` | Fixed dome | Fisheye |
| VB-H751LE | `rtsp://IP:554/cam1/h264` | Fixed bullet | Outdoor |
| VB-H761LVE | `rtsp://IP:554/cam1/h264` | Fixed bullet | H.265 capable |
| VB-M40 | `rtsp://IP/profile1=u` | Compact PTZ | Unicast, no port specified |
| VB-M42 / VB-M44 | `rtsp://IP:554/cam1/h264` | Compact PTZ | Channel-based |
| VB-M600D | `rtsp://IP/profile1=r` | Compact dome | Read mode |
| VB-M620D / VB-M640V | `rtsp://IP:554/cam1/h264` | Compact dome | Current |
| VB-M741LE | `rtsp://IP:554/cam1/h264` | Compact PTZ | Outdoor |
| VB-S30D / VB-S31D | `rtsp://IP:554/cam1/h264` | Compact | Indoor |
| VB-S800D / VB-S900F | `rtsp://IP:554/cam1/h264` | Compact | Indoor |
| VB-R11 / VB-R11VE | `rtsp://IP:554/cam1/h264` | PTZ dome | Current |
| VB-R12VE | `rtsp://IP:554/cam1/h264` | PTZ dome | Outdoor |

### Legacy Models (VB-C Series -- HTTP Only)

Legacy VB-C cameras do not support RTSP. They use Canon's proprietary `-wvhttp-01-` HTTP URLs:

| Model | HTTP URL | Type | Notes |
| --- | --- | --- | --- |
| VB-C300 | `http://IP/-wvhttp-01-/GetLiveImage` | PTZ dome | HTTP only |
| VB-C10 | `http://IP/-wvhttp-01-/GetLiveImage` | Compact | HTTP only |
| VB-C50i | `http://IP/-wvhttp-01-/GetLiveImage` | PTZ dome | HTTP only |
| VB-610 | `http://IP/-wvhttp-01-/video.cgi` | Fixed | HTTP only |

## Connecting with VisioForge SDK

Use your Canon camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Canon VB-H series camera, channel 1
var uri = new Uri("rtsp://192.168.1.70:554/cam1/h264");
var username = "root";
var password = "YourPassword";
```

For profile-based access on older VB models, use `rtsp://IP:554/profile1=r` or `rtsp://IP/profile1=u` depending on the model.

## Snapshot and MJPEG URLs

Canon uses a distinctive `-wvhttp-01-` path prefix for all HTTP-based image and video access:

| Type | URL Pattern | Notes |
| --- | --- | --- |
| Live Image | `http://IP/-wvhttp-01-/GetLiveImage` | Current snapshot |
| MJPEG Stream | `http://IP/-wvhttp-01-/video.cgi` | Continuous MJPEG |
| Snapshot (sized) | `http://IP/-wvhttp-01-/GetOneShot?image_size=WIDTHxHEIGHT` | Custom resolution |
| Snapshot (continuous) | `http://IP/-wvhttp-01-/GetOneShot?image_size=WIDTHxHEIGHT&frame_count=0` | Continuous capture |

Canon `-wvhttp-01-` prefix

The `-wvhttp-01-` path prefix is unique to Canon network cameras. All HTTP-based image and video URLs use this prefix. This distinctive path can help identify Canon cameras on a network.

## Troubleshooting

### RTSP must be enabled in the web interface

Canon cameras may not have RTSP enabled by default. Access the camera's web interface and navigate to the streaming settings to enable RTSP. Without this, the camera will only respond to HTTP requests.

### Legacy VB-C series are HTTP only

The VB-C series (VB-C300, VB-C10, VB-C50i) and VB-610 do not support RTSP at all. Use Canon's `-wvhttp-01-` HTTP URLs for video access from these models:

- `http://IP/-wvhttp-01-/GetLiveImage` for snapshots
- `http://IP/-wvhttp-01-/video.cgi` for MJPEG streaming

### Profile read vs unicast modes

Canon profile URLs use two access modes:

- `profile1=r` -- **Read mode**: Allows multicast distribution, suitable for multiple viewers
- `profile1=u` -- **Unicast mode**: Direct connection, one viewer per stream

If multicast is not configured on your network, use `profile1=u` for a direct unicast connection.

### Double slash in some URLs

Some Canon models (notably VB-H41) require a **double forward slash** before the stream path:

- VB-H41: `rtsp://IP:554//stream/profile1=r` (double slash)
- Most others: `rtsp://IP:554/cam1/h264` (single slash)

### Default credentials vary

Canon cameras do not have a universal default credential:

- **Current models:** Often `root` with a password set during initial setup
- **Older models:** May use `admin` / `admin` or `root` / `camera`
- Check the camera label or setup guide for model-specific defaults

## FAQ

**What is the default RTSP URL for Canon cameras?**

For current Canon VB-H and VB-M series cameras, use `rtsp://root:password@CAMERA_IP:554/cam1/h264`. For older models, try `rtsp://CAMERA_IP:554/profile1=r` or `rtsp://CAMERA_IP/profile1=u`.

**Do Canon cameras support H.265?**

Select Canon models support H.265, including the VB-H47 and VB-H761 series. Most other VB-series cameras use H.264. Legacy VB-C models support only MJPEG over HTTP.

**What is the `-wvhttp-01-` path in Canon URLs?**

The `-wvhttp-01-` prefix is Canon's proprietary HTTP path used for all web-based image and video access on their network cameras. It is used for snapshots (`GetOneShot`, `GetLiveImage`), MJPEG streaming (`video.cgi`), and camera control. This path is unique to Canon cameras.

**Can I connect to legacy Canon VB-C cameras?**

Legacy VB-C cameras (VB-C300, VB-C10, VB-C50i) are HTTP-only and do not support RTSP. You can access their video using the HTTP URL `http://CAMERA_IP/-wvhttp-01-/GetLiveImage` for snapshots or `http://CAMERA_IP/-wvhttp-01-/video.cgi` for MJPEG streaming.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Sony Connection Guide](../sony/) — Japanese enterprise cameras
- [Axis Connection Guide](../axis/) — Enterprise surveillance leader
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Cisco IP Camera RTSP URL Setup and C# .NET Integration
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/cisco/
**Description:** Cisco CIVS and Meraki camera RTSP integration for C# .NET. URL patterns for enterprise PVC, VC models with VisioForge SDK code and ONVIF examples.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Cisco IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Cisco Systems** is the world's largest networking company, headquartered in San Jose, California, USA. Cisco produced IP cameras under both the **Cisco** and **Linksys** brands. The main camera lines were **Cisco Video Surveillance (CIVS/VC/PVC)** for enterprise deployments and the former **Linksys-branded (WVC)** series for consumer and small business markets. Cisco sold their video surveillance business to Verkada and discontinued most camera products, but many units remain deployed in the field. The **Meraki MV** line (cloud-managed) is the only current Cisco camera product.

**Key facts:**

- **Product lines:** CIVS (enterprise video surveillance), PVC (small business), VC (video camera), WVC (wireless video camera, Linksys legacy), WCS (wireless camera server), Meraki MV (cloud-managed, current)
- **Protocol support:** RTSP, HTTP/CGI, MJPEG, ASF (WVC models); Meraki MV is cloud-only
- **Default RTSP port:** 554
- **Default credentials:** admin / admin (varies by model)
- **ONVIF support:** Limited (some newer CIVS models only; WVC series does not support ONVIF)
- **Video codecs:** H.264, MPEG-4 (WVC series), MJPEG

Meraki MV cameras

Cisco Meraki MV cameras use cloud-only access and do **not** support direct RTSP streaming. They cannot be connected via local RTSP URLs. The information on this page applies to the legacy Cisco and Linksys camera product lines.

## RTSP URL Patterns

### Enterprise Cameras (CIVS / VC / PVC Series)

Most Cisco enterprise IP cameras use the `/img/media.sav` path:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Main stream | `rtsp://IP:554/img/media.sav` | Most CIVS and WVC cameras |
| Live SDP | `rtsp://IP:554/live.sdp` | VC240, PVC300, VC220 series |
| Video SAV | `rtsp://IP:554/img/video.sav` | PVC2300 |
| Access code | `rtsp://IP:554/[ACCESS_CODE]` | Code configured in camera web UI |
| Root stream | `rtsp://IP:554/` | Fallback for PVC2300 and others |

### Model-Specific URLs

| Model | RTSP URL | Type |
| --- | --- | --- |
| CIVS 2500 / 2521 / 2531 | `rtsp://IP:554/img/media.sav` | Enterprise dome/bullet |
| PVC300 | `rtsp://IP:554/live.sdp` | Small business PTZ |
| PVC2300 | `rtsp://IP:554/img/video.sav` | Small business box |
| PVC2300 (alt) | `rtsp://IP:554/` | Fallback |
| VC220 | `rtsp://IP:554/live.sdp` | Dome camera |
| VC240 | `rtsp://IP:554/live.sdp` | Dome camera |
| WVC80N | `rtsp://IP:554/img/media.sav` | Linksys wireless |
| WVC210 | `rtsp://IP:554/img/media.sav` | Linksys wireless |
| WVC54GCA | `rtsp://IP:554/img/media.sav` | Linksys wireless |
| WCS-1130 | `rtsp://IP:554/play1.sdp` | Wireless camera server |

Unusual file extension

Cisco and Linksys cameras use the `/img/media.sav` path, which has an unusual `.sav` file extension. This is not a standard media format -- it is a Cisco-specific RTSP endpoint. Do not confuse it with a file download URL.

### WVC Series (Linksys Legacy)

The Linksys WVC (Wireless Video Camera) series was a popular consumer camera line before Cisco rebranded and eventually discontinued it:

| Model | RTSP URL | Resolution | Notes |
| --- | --- | --- | --- |
| WVC54GCA | `rtsp://IP:554/img/media.sav` | 640x480 | Wi-Fi, MPEG-4 |
| WVC80N | `rtsp://IP:554/img/media.sav` | 640x480 | Wireless-N |
| WVC210 | `rtsp://IP:554/img/media.sav` | 640x480 | Wireless-G PTZ |

## Connecting with VisioForge SDK

Use your Cisco camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Cisco enterprise camera (CIVS/WVC), main stream
var uri = new Uri("rtsp://192.168.1.50:554/img/media.sav");
var username = "admin";
var password = "YourPassword";
```

For VC240 or PVC300 cameras, use `/live.sdp` instead of `/img/media.sav`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/img/snapshot.cgi?size=3` | Most Cisco cameras (size: 1=QQVGA, 2=QVGA, 3=VGA) |
| JPEG Snapshot (VGA) | `http://IP/img/snapshot.cgi?img=vga` | Named resolution |
| MJPEG Stream | `http://IP/img/video.mjpeg` | Continuous MJPEG stream |
| MJPEG (alt) | `http://IP/img/mjpeg.jpg` | Alternative MJPEG endpoint |
| ASF Stream | `http://IP/img/video.asf` | WVC series ASF stream |
| PVC300 Snapshot | `http://IP/cgi-bin/viewer/snapshot.jpg?resolution=640x480` | Resolution parameter required |

## Troubleshooting

### `/img/media.sav` not responding

The `.sav` extension is a Cisco-specific RTSP endpoint. If the URL does not work:

1. Verify the camera IP address and that port 554 is open
2. Confirm RTSP is enabled in the camera's web UI
3. Some models require an access code to be configured before RTSP access works -- check the camera's streaming settings
4. Try the fallback URL `rtsp://IP:554/` if the specific path does not respond

### WVC series returns MPEG-4 only

The Linksys WVC cameras (WVC54GCA, WVC80N, WVC210) support MPEG-4 but not H.264. The VisioForge SDK handles MPEG-4 streams automatically. If you see artifacts, ensure you are not forcing H.264 decoding.

### Access code authentication

Some Cisco cameras use an access code instead of traditional username/password for RTSP. The access code is configured in the camera's web interface under streaming settings and is appended to the URL:

```
rtsp://IP:554/[YOUR_ACCESS_CODE]
```

### HTTP streams for legacy cameras

Older Cisco/Linksys cameras may work better with HTTP-based ASF or MJPEG streams than RTSP. Use the ASF URL (`http://IP/img/video.asf`) as a fallback if RTSP is unreliable.

### Meraki MV cameras not accessible

Meraki MV cameras are cloud-managed only and do not support local RTSP access. There is no local RTSP URL available for these cameras. Video can only be accessed through the Meraki Dashboard cloud interface.

## FAQ

**What is the default RTSP URL for Cisco cameras?**

For most Cisco and Linksys IP cameras, use `rtsp://admin:password@CAMERA_IP:554/img/media.sav`. For VC/PVC series cameras, try `rtsp://admin:password@CAMERA_IP:554/live.sdp` instead.

**Do Cisco cameras support ONVIF?**

Only some newer CIVS-series enterprise cameras have limited ONVIF support. The Linksys WVC consumer cameras and Meraki MV cameras do not support ONVIF.

**Are Cisco cameras still being manufactured?**

Cisco sold their video surveillance business (CIVS line) to Verkada and discontinued the Linksys WVC cameras. The only current Cisco camera product is the Meraki MV series, which is cloud-managed and does not support RTSP. However, many legacy Cisco cameras remain deployed and operational.

**What codecs do Cisco cameras use?**

Newer CIVS enterprise cameras support H.264. The Linksys WVC series primarily uses MPEG-4 and MJPEG. The codec depends on the model and firmware version.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Linksys Connection Guide](../linksys/) — Same URL patterns, Cisco subsidiary
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## CP Plus IP Camera RTSP URL and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/cp-plus/
**Description:** CP Plus UNC, NC, RNP, Guard+, and Cosmic series RTSP URL patterns for C# .NET. Integrate with VisioForge SDK for IP camera streaming and recording.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MJPEG, C#

# How to Connect to CP Plus IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**CP Plus** (Aditya Infotech Ltd.) is India's #1 security camera brand and one of the largest surveillance manufacturers in the world, headquartered in Delhi, India. CP Plus cameras are primarily **Dahua OEM** products, meaning most models run Dahua firmware and share identical RTSP URL patterns. Some models use alternative chipsets with different URL formats. CP Plus dominates the Indian, Middle Eastern, and Southeast Asian markets with a comprehensive range of IP cameras, NVRs, and analog systems.

**Key facts:**

- **Product lines:** UNC (IP cameras), RNP (NVRs), VAC (analog), Guard+ (wireless), E series (entry-level), Cosmic (value)
- **OEM base:** Dahua (most models use Dahua firmware and URL patterns)
- **Protocol support:** RTSP, ONVIF, HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** admin / admin
- **ONVIF support:** Yes (most models)
- **Video codecs:** H.264, H.265 (newer models)
- **Dominant market:** India (#1), Middle East, Southeast Asia

CP Plus = Dahua OEM

CP Plus cameras are primarily Dahua OEM products and use the same RTSP URL patterns. See our [Dahua connection guide](../dahua/) for additional details. Some CP Plus models use the `/VideoInput/` URL format instead.

## RTSP URL Patterns

### Standard URL Format (Dahua-style)

Most CP Plus cameras use the Dahua `cam/realmonitor` URL pattern:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/cam/realmonitor?channel=1&subtype=1
```

| Parameter | Value | Description |
| --- | --- | --- |
| `channel` | 1, 2, 3... | Camera channel (1 for standalone cameras) |
| `subtype` | 0 | Main stream (highest resolution) |
| `subtype` | 1 | Sub stream (lower resolution, less bandwidth) |

### Camera Models

| Model | Type | Main Stream URL | Notes |
| --- | --- | --- | --- |
| CP-UNC-DP10L2C | IP dome | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Dahua-style URL |
| CP-UNC-TY20FL2C | IP turret | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Dahua-style URL |
| CP-NC9W-K | Network camera | `rtsp://IP:554/VideoInput/1/mpeg4/1` | VideoInput format |
| B series | Basic | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Dahua-style URL |

### NVR Channel URLs

For CP Plus NVRs (CP-RNP-36D, CN-RNP-36D, etc.):

| Channel | Main Stream | Sub Stream |
| --- | --- | --- |
| Camera 1 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` |
| Camera 2 | `rtsp://IP:554/cam/realmonitor?channel=2&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=2&subtype=1` |
| Camera N | `rtsp://IP:554/cam/realmonitor?channel=N&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=N&subtype=1` |

### Alternative URL Formats

Some CP Plus models use different URL patterns depending on firmware and chipset:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` | Standard Dahua-style (most models) |
| `rtsp://IP:554//cam/realmonitor` | Dahua-style alternate (double slash) |
| `rtsp://IP:554/VideoInput/1/mpeg4/1` | VideoInput format (CP-NC9W-K, CP-UNC-DP10L2C on some firmware) |
| `rtsp://IP:554//cam/realmonitor?channel=1&subtype=00&authbasic=AUTH` | With base64-encoded authentication |

## Connecting with VisioForge SDK

Use your CP Plus camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// CP Plus CP-UNC-DP10L2C, main stream
var uri = new Uri("rtsp://192.168.1.90:554/cam/realmonitor?channel=1&subtype=0");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `subtype=1` instead of `subtype=0`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/snapshot.cgi?1` | Requires basic auth (CP-UNC-TY20FL2C) |
| JPEG Snapshot (legacy) | `http://IP/cgi-bin/snapshot.cgi?loginuse=USER&loginpas=PASS` | URL-based auth for older models |
| JPEG Image | `http://IP/cgi-bin/jpg/image.cgi` | Alternative JPEG endpoint |
| MJPEG Stream | `http://IP/api/mjpegvideo.cgi?InputNumber=1&StreamNumber=CHANNEL` | Continuous MJPEG stream |
| Direct HTTP Stream | `http://IP:8008/` | Some NVR models (CN-RNP-36D, CP-RNP-36D) |

## Troubleshooting

### "401 Unauthorized" error

CP Plus cameras ship with default credentials (`admin` / `admin`). If you've changed the password via the web interface or mobile app, ensure your RTSP URL uses the updated credentials.

1. Access the camera at `http://CAMERA_IP` in a browser
2. Log in with your credentials
3. Verify RTSP is enabled under **Setup > Network > Port**
4. Use those credentials in your RTSP URL

### Dahua-style URL not working

Some CP Plus models (particularly the CP-NC series) use the `/VideoInput/` URL format instead of the Dahua `cam/realmonitor` pattern. Try:

```
rtsp://admin:password@IP:554/VideoInput/1/mpeg4/1
```

### Port 554 vs custom port

Check the RTSP port setting at:

- Web interface: **Setup > Network > Port > RTSP Port**
- Default is 554

### Stream type confusion

- `subtype=0` = Main stream (full resolution, higher bandwidth)
- `subtype=1` = Sub stream (reduced resolution, lower bandwidth)

### Direct HTTP stream on port 8008

Some CP Plus NVR models (CP-RNP-36D, CN-RNP-36D) expose a direct HTTP stream on port 8008. Try accessing `http://CAMERA_IP:8008/` if standard RTSP is unavailable.

## FAQ

**Are CP Plus cameras the same as Dahua?**

Most CP Plus cameras are manufactured by Dahua and use Dahua firmware. The RTSP URL format (`cam/realmonitor?channel=1&subtype=0`) is identical for the majority of models. However, some CP Plus models use different chipsets with the `/VideoInput/` URL format. Any code written for Dahua cameras generally works with CP Plus and vice versa.

**What is the default RTSP URL for CP Plus cameras?**

The URL is `rtsp://admin:password@CAMERA_IP:554/cam/realmonitor?channel=1&subtype=1` for the sub stream. Replace `subtype=1` with `subtype=0` for the main stream. For NVR setups, change `channel=1` to the appropriate channel number.

**Do CP Plus cameras support ONVIF?**

Yes. Most current CP Plus IP cameras support ONVIF, which provides a standardized way to discover and connect to cameras regardless of the specific URL format.

**What if my CP Plus camera uses a different URL format?**

Some CP Plus models (especially the CP-NC series) use `rtsp://IP:554/VideoInput/1/mpeg4/1` instead of the Dahua-style URL. If the standard URL does not work, try the VideoInput format. You can also use ONVIF discovery to automatically detect the correct URL.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Dahua Connection Guide](../dahua/) — Same URL format for most models
- [Amcrest Connection Guide](../amcrest/) — Another Dahua OEM
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Dahua IP Camera RTSP URL Patterns and C# .NET Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/dahua/
**Description:** Integrate Dahua IPC-HDW, IPC-HFW, NVR, and DVR cameras into C# .NET apps. RTSP URL format, ONVIF auto-discovery, and VisioForge SDK code included.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MJPEG, C#

# How to Connect to Dahua IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Dahua Technology** (Zhejiang Dahua Technology Co., Ltd.) is the world's second-largest video surveillance manufacturer. Founded in 2001 and headquartered in Hangzhou, China, Dahua produces IP cameras, NVRs, DVRs, access control systems, and video intercoms. Dahua cameras are also widely sold under OEM brands including Amcrest, Lorex, and others.

**Key facts:**

- **Product lines:** IPC-HDW (dome), IPC-HFW (bullet), IPC-HDBW (dome vandal-proof), SD (PTZ), NVR4xxx/5xxx (NVRs), XVR (DVRs)
- **Protocol support:** ONVIF Profile S/G/T, RTSP, HTTP, Dahua proprietary (DHIP)
- **Default RTSP port:** 554 (some models use 1554)
- **Default credentials:** admin / admin (older firmware); admin / (set during setup on newer firmware)
- **ONVIF support:** Full
- **Video codecs:** H.264, H.265, H.265+, MJPEG

## RTSP URL Patterns

Dahua cameras use a `cam/realmonitor` URL structure with channel and subtype parameters.

### URL Format

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:[PORT]/cam/realmonitor?channel=[CH]&subtype=[ST]
```

**Parameters:**

- `channel` = camera channel number (1 for single-channel cameras, 1-N for NVR/DVR)
- `subtype` = stream type: 0 = main stream, 1 = sub stream, 2 = third stream

### IP Cameras (Single Channel)

| Model Series | RTSP URL | Stream | Audio |
| --- | --- | --- | --- |
| IPC-HDW (dome) | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Main | Yes |
| IPC-HDW (dome) | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` | Sub | Yes |
| IPC-HFW (bullet) | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Main | Yes |
| IPC-HDBW (vandal dome) | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Main | Yes |
| SD (PTZ) | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Main | Yes |
| DH-IPC-HF2100P | `rtsp://IP:1554/cam/realmonitor?channel=1&subtype=0` | Main | Yes |

### Simplified URL Format

Many Dahua cameras also accept a shorter URL format:

| URL Pattern | Stream | Notes |
| --- | --- | --- |
| `rtsp://IP:554/cam/realmonitor` | Main (ch1) | Defaults to channel 1, main stream |
| `rtsp://IP:554/` | Main | Bare URL, some models only |
| `rtsp://IP:554/live` | Main | Legacy format |

### NVR / DVR Channels

| Device | Channel | RTSP URL | Stream |
| --- | --- | --- | --- |
| NVR Camera 1 | 1 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Main |
| NVR Camera 1 | 1 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` | Sub |
| NVR Camera 2 | 2 | `rtsp://IP:554/cam/realmonitor?channel=2&subtype=0` | Main |
| NVR Camera 4 | 4 | `rtsp://IP:554/cam/realmonitor?channel=4&subtype=0` | Main |
| DVR Channel 1 | 1 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=01` | Sub |

### Amcrest / Lorex (Dahua OEM)

Amcrest and Lorex cameras use the same Dahua RTSP URL format:

| Brand | RTSP URL | Notes |
| --- | --- | --- |
| Amcrest | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Identical to Dahua |
| Lorex | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Identical to Dahua |

## Connecting with VisioForge SDK

Use your Dahua camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Dahua IPC-HDW series, main stream
var uri = new Uri("rtsp://192.168.1.108:554/cam/realmonitor?channel=1&subtype=0");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `subtype=1` instead.

### ONVIF Discovery

Dahua cameras provide strong ONVIF support. See the [ONVIF integration guide](../../mediablocks/Sources/) for discovery code examples.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/snapshot.cgi?channel=1` | Requires basic auth |
| JPEG Snapshot (legacy) | `http://IP/cgi-bin/snapshot.cgi?loginuse=USER&loginpas=PASS` | URL-based auth |
| MJPEG Stream | `http://IP/cgi-bin/mjpg/video.cgi?channel=1` | Continuous MJPEG |
| Axis-compatible MJPEG | `http://IP/axis-cgi/mjpg/video.cgi?camera=1` | Emulated Axis API |
| CGI Snapshot | `http://IP/cgi-bin/video.jpg` | Simple snapshot |
| Image CGI | `http://IP/cgi-bin/jpg/image.cgi` | Alternative snapshot |

## Troubleshooting

### Port 554 vs 1554

Some Dahua models (especially the DH-IPC-HF series) use port **1554** instead of the standard 554. If connection fails on port 554, try 1554.

### Authentication methods

- Dahua supports both **basic** and **digest** RTSP authentication
- Newer firmware defaults to digest authentication
- VisioForge SDK handles both methods automatically
- If using HTTP snapshot URLs, some require URL-embedded credentials (`loginuse`/`loginpas` parameters) while newer firmware uses standard HTTP basic/digest auth

### Connection drops

- Dahua cameras can be sensitive to network congestion. Use TCP transport for reliability.
- Reduce main stream resolution or switch to sub stream (`subtype=1`) to lower bandwidth
- Check the camera's **Max User Connections** setting (Configuration > Network > Connection) -- the default is typically 10

### Amcrest/Lorex cameras not connecting

If you have an Amcrest or Lorex camera (Dahua OEM), use the exact same RTSP URL patterns listed above. The default ports and paths are identical to Dahua. The only difference may be in default credentials:

- **Amcrest default:** admin / admin
- **Lorex default:** admin / (set during setup)

### DVR extra stream format

When connecting to DVR channels, note that `subtype=00` and `subtype=0` are equivalent for the main stream. Some older firmware requires the two-digit format (`01` instead of `1`).

## FAQ

**What is the default RTSP URL for Dahua cameras?**

The standard URL is `rtsp://admin:password@CAMERA_IP:554/cam/realmonitor?channel=1&subtype=0` for the main stream. Use `subtype=1` for the sub stream (lower resolution, less bandwidth).

**Do Amcrest cameras use the same RTSP URLs as Dahua?**

Yes. Amcrest cameras are manufactured by Dahua and use identical RTSP URL patterns, authentication, and port configurations. Any RTSP URL that works for a Dahua camera will work for the corresponding Amcrest model.

**How do I access multiple cameras on a Dahua NVR?**

Change the `channel` parameter in the RTSP URL. Channel 1 is the first camera, channel 2 is the second, and so on. For example, `rtsp://IP:554/cam/realmonitor?channel=3&subtype=0` connects to the third camera on the NVR's main stream.

**Why does my Dahua camera use port 1554 instead of 554?**

Some older Dahua models, particularly the DH-IPC-HF series, default to RTSP port 1554. You can change this in the camera's web interface under Configuration > Network > Port. Newer models default to port 554.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Amcrest Connection Guide](../amcrest/) — Dahua OEM, identical URL format
- [Lorex Connection Guide](../lorex/) — Uses Dahua URL format for many models
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## D-Link DCS IP Camera RTSP URLs and C# .NET Code Samples
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/dlink/
**Description:** D-Link DCS camera RTSP URL patterns for C# .NET integration. Covers DCS-930, DCS-2130, DCS-5222 with VisioForge SDK code and authentication setup.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to D-Link IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**D-Link Corporation** is a Taiwanese networking equipment manufacturer headquartered in Taipei. D-Link produces IP cameras under the **DCS (D-Link Cloud Security)** product line, targeting consumer and small business markets. D-Link cameras are widely available through retail channels and are popular for home security and small office deployments.

**Key facts:**

- **Product lines:** DCS-930/932/933/934 (consumer Wi-Fi), DCS-2130/2132/2230/2310/2330/2332 (prosumer), DCS-5020/5222/5615 (PTZ), DCS-6010/6113/6818 (enterprise), DCS-7010/7110/7410 (outdoor professional)
- **Protocol support:** RTSP, ONVIF (some models), HTTP/CGI, MJPEG, D-Link mydlink cloud
- **Default RTSP port:** 554
- **Default credentials:** admin / (empty password); some models: admin / admin
- **ONVIF support:** Select models only (typically DCS-2xxx and higher)
- **Video codecs:** H.264, MJPEG, MPEG-4 (legacy)

## RTSP URL Patterns

### Current and Recent Models

D-Link cameras use the `live.sdp` or `play.sdp` URL format:

| Stream | RTSP URL | Quality | Notes |
| --- | --- | --- | --- |
| Main stream (H.264) | `rtsp://IP:554/live1.sdp` | High | Main H.264 stream |
| Sub stream (H.264) | `rtsp://IP:554/live2.sdp` | Medium | Second stream |
| Third stream | `rtsp://IP:554/live3.sdp` | Low | Third stream (some models) |
| Main stream (alt) | `rtsp://IP:554/play1.sdp` | High | Alternative URL |
| Sub stream (alt) | `rtsp://IP:554/play2.sdp` | Medium | Alternative URL |

### Model-Specific URLs

| Model | RTSP URL | Resolution | Type |
| --- | --- | --- | --- |
| DCS-930L | `rtsp://IP:554/play1.sdp` | 640x480 | Consumer Wi-Fi |
| DCS-932L | `rtsp://IP:554/play1.sdp` | 640x480 | Consumer Wi-Fi IR |
| DCS-933L | `rtsp://IP:554/play1.sdp` | 640x480 | Consumer Wi-Fi |
| DCS-934L | `rtsp://IP:554/play1.sdp` | 1280x720 | Consumer HD |
| DCS-942L | `rtsp://IP:554/play1.sdp` | 640x480 | Consumer IR |
| DCS-2100+ | `rtsp://IP:554/live.sdp` | 640x480 | Legacy |
| DCS-2121 | `rtsp://IP:554/play1.sdp` | 640x480 | Prosumer |
| DCS-2130 | `rtsp://IP:554//live1.sdp` | 1280x720 | Prosumer HD |
| DCS-2132L | `rtsp://IP:554//live1.sdp` | 1280x720 | Prosumer HD |
| DCS-2230 | `rtsp://IP:554//live1.sdp` | 1920x1080 | Prosumer FHD |
| DCS-2310L | `rtsp://IP:554/live1.sdp` | 1280x720 | Outdoor HD |
| DCS-2332L | `rtsp://IP:554//live1.sdp` | 1280x720 | Outdoor HD |
| DCS-5020L | `rtsp://IP:554/play1.sdp` | 640x480 | PTZ consumer |
| DCS-5222L | `rtsp://IP:554//live1.sdp` | 1280x720 | PTZ HD |
| DCS-6010L | `rtsp://IP:554/live1.sdp` | 1600x1200 | Panoramic |
| DCS-6113 | `rtsp://IP:554/live1.sdp` | 1920x1080 | Box camera |
| DCS-6818 | `rtsp://IP:554/live3.sdp` | 1920x1080 | Enterprise |
| DCS-7010L | `rtsp://IP:554/live1.sdp` | 1280x720 | Outdoor PoE |
| DCS-7110 | `rtsp://IP:554/live1.sdp` | 1280x800 | Outdoor HD |
| DCS-7410 | `rtsp://IP:554/live1.sdp` | 1280x720 | Outdoor enterprise |

Double slash in some URLs

Some D-Link models use a double slash before the path: `rtsp://IP:554//live1.sdp`. This is common on DCS-2130, DCS-2132L, DCS-2230, DCS-2332L, and DCS-5222L models. Try both single and double slash if one format doesn't work.

### Legacy Models (HTTP Only)

Very old D-Link DCS cameras only support HTTP:

| Model | URL | Notes |
| --- | --- | --- |
| DCS-900 | `http://IP/cgi-bin/video.jpg` | JPEG only |
| DCS-910 | `http://IP/video.cgi` | MJPEG |
| DCS-920 | `http://IP/video.cgi` | MJPEG |
| DCS-2100 | `http://IP/cgi-bin/video.jpg?size=2` | JPEG only |

## Connecting with VisioForge SDK

Use your D-Link camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// D-Link DCS camera, main stream
var uri = new Uri("rtsp://192.168.1.45:554/live1.sdp");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `/live2.sdp` instead.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/image/jpeg.cgi` | Most current DCS models |
| MJPEG Stream | `http://IP/video/mjpg.cgi` | Continuous MJPEG |
| MJPEG (alt) | `http://IP/video.cgi` | Older models |
| MJPEG (auth) | `http://IP/mjpeg.cgi?user=USER&password=PASS&channel=1` | With authentication |
| DMS Snapshot | `http://IP/dms.jpg` | DCS-2130/2132/2230/2310/2332 |
| DMS Stream | `http://IP/dms?nowprofileid=2` | Profile-based |
| ipcam stream | `http://IP/ipcam/stream.cgi?nowprofileid=2` | Some models |
| Legacy JPEG | `http://IP/cgi-bin/video.jpg` | Very old DCS models |

## Troubleshooting

### live vs play URL format

D-Link cameras use two URL naming conventions:

- **Current models (DCS-2xxx+):** `live1.sdp`, `live2.sdp`, `live3.sdp`
- **Consumer models (DCS-930/932/933/942):** `play1.sdp`, `play2.sdp`, `play3.sdp`

If one format doesn't work, try the other.

### Default password is empty

Many D-Link cameras ship with `admin` as the username and an **empty password**. You may need to set a password through the web interface or D-Link Setup Wizard before RTSP works properly.

### mydlink cloud cameras

Some newer D-Link cameras are designed primarily for the mydlink cloud ecosystem and may have limited or no RTSP support. Check the camera's specifications for "RTSP" or "third-party integration" support.

### Port configuration

D-Link cameras use port 554 by default for RTSP. The HTTP interface is typically on port 80. Both can be changed in the camera's web interface under Network Settings.

## FAQ

**What is the default RTSP URL for D-Link cameras?**

For most D-Link DCS cameras, try `rtsp://admin:password@CAMERA_IP:554/live1.sdp` or `rtsp://admin:password@CAMERA_IP:554/play1.sdp`. The `live` format is used by newer models, while `play` is used by consumer models.

**Do D-Link cameras support ONVIF?**

Select models support ONVIF (typically DCS-2xxx and higher-end models). Consumer cameras like the DCS-930L and DCS-932L generally do not support ONVIF.

**What is the difference between live1.sdp and play1.sdp?**

Both serve the same purpose (main video stream) but are used by different D-Link camera generations. `live1.sdp` is more common on newer prosumer/professional models, while `play1.sdp` is used on older consumer models.

**Can I connect to D-Link cameras without the mydlink app?**

Yes. D-Link cameras with RTSP support can be accessed directly via their IP address without the mydlink cloud service. The mydlink cloud is optional for remote access.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Foscam Connection Guide](../foscam/) — Consumer IP camera peer
- [TP-Link Connection Guide](../tp-link/) — Consumer cameras with RTSP
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Edimax IP Camera RTSP URL and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/edimax/
**Description:** Learn how to connect to Edimax IP cameras using C# .NET with RTSP URL patterns, authentication tips, and code samples for IC, IR, PT, and VS series models.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Edimax IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Edimax** (Edimax Technology Co.) is a Taiwanese networking equipment manufacturer headquartered in Taipei, Taiwan. Founded in 1986, Edimax is known primarily for networking products such as routers, switches, and Wi-Fi adapters, but also manufactures a range of consumer and small-to-medium business IP cameras under the IC series. Over the years, Edimax cameras have evolved through several URL format generations.

**Key facts:**

- **Product lines:** IC (IP camera), IR (infrared), PT (pan/tilt), VS (video server)
- **Multiple URL format generations:** older models use `/ipcam.sdp`, newer models use `/stream1`
- **Default RTSP port:** 554 (some models use 8000)
- **Default credentials:** admin / 1234
- **ONVIF support:** Yes (newer models)
- **Video codecs:** H.264, MJPEG
- **Primary RTSP URL:** `rtsp://IP:554/ipcam_h264.sdp`

URL format generations

Edimax cameras have evolved through several URL format generations. Older IC-1500/IC-3000 series use `/ipcam.sdp` or `/ipcam_h264.sdp`, while newer IR/PT series use `/stream1`. Try both formats if one doesn't work.

Dual authentication styles

Edimax cameras use two different authentication parameter styles in HTTP URLs: `account=USER&password=PASS` (older firmware) and `user=USER&pwd=PASS` (newer firmware). Check which format your camera supports.

## RTSP URL Patterns

### Standard URL Format

Edimax cameras primarily use an SDP-based RTSP URL:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/ipcam_h264.sdp
```

| URL Pattern | Description |
| --- | --- |
| `/ipcam.sdp` | SDP-based stream (older IC series) |
| `/ipcam_h264.sdp` | H.264 SDP stream (recommended for most models) |
| `/stream1` | Primary stream (newer IR/PT series) |
| `/stream2` | Secondary stream (newer IR/PT series) |
| `/live1.sdp` | Live SDP stream (PT series) |

### Camera Models

| Model | Type | Main Stream URL | Notes |
| --- | --- | --- | --- |
| IC-1500WG (VGA wireless) | VGA | `rtsp://IP:554/ipcam.sdp` | Older SDP format |
| IC-3010 (HD) | HD | `rtsp://IP:554/ipcam.sdp` | Older SDP format |
| IC-3015WN (HD wireless) | HD Wireless | `rtsp://IP:554/ipcam.sdp` | Wi-Fi, SDP format |
| IC-3030WN (HD wireless) | HD Wireless | `rtsp://IP:554/ipcam.sdp` | Wi-Fi, SDP format |
| IC-3030IWN (HD wireless) | HD Wireless | `rtsp://IP:554/ipcam.sdp` | Indoor Wi-Fi |
| IC-3100W (HD wireless) | HD Wireless | `rtsp://IP:554/ipcam_h264.sdp` | H.264 SDP format |
| IC-3110W (HD wireless) | HD Wireless | `rtsp://IP:554/ipcam_h264.sdp` | H.264 SDP format |
| IC-3116W (HD wireless) | HD Wireless | `rtsp://IP:554/ipcam_h264.sdp` | H.264 SDP format |
| IC-7000 (HD PTZ) | HD PTZ | `rtsp://IP:554/ipcam.sdp` | Pan/tilt/zoom |
| IC-7010PTN (HD PTZ) | HD PTZ | `rtsp://IP:554/ipcam.sdp` | Network PTZ |
| IC-7100 (HD PTZ) | HD PTZ | `rtsp://IP:554/ipcam_h264.sdp` | H.264 PTZ |
| IC-7110P (HD PTZ PoE) | HD PTZ | `rtsp://IP:554/ipcam_h264.sdp` | PoE PTZ |
| IC-7110W (HD PTZ wireless) | HD PTZ | `rtsp://IP:554/ipcam_h264.sdp` | Wi-Fi PTZ |
| IC-9000 (outdoor) | Outdoor | `rtsp://IP:554/CHANNEL/USERNAME:PASSWORD/main` | Credential-in-URL |
| IR-112E (infrared) | Infrared | `rtsp://IP:554//stream2` | Newer stream format |
| IR-113E (infrared) | Infrared | `rtsp://IP:554//stream1` | Newer stream format |
| PT-112E (pan/tilt) | Pan/Tilt | `rtsp://IP:554/live1.sdp` | Live SDP format |
| PT-31E (pan/tilt) | Pan/Tilt | `rtsp://IP:8000//stream1` | Port 8000 |
| VS100 (video server) | Video Server | `rtsp://IP:554//stream1` | Encoder/server |

### Alternative URL Formats

Some Edimax models and firmware versions support these additional RTSP URLs:

| URL Pattern | Supported Models | Notes |
| --- | --- | --- |
| `rtsp://IP:554/ipcam.sdp` | IC-1500, IC-3010, IC-3015WN, IC-3030WN, IC-7000, IC-7010PTN | Older SDP format |
| `rtsp://IP:554/ipcam_h264.sdp` | IC-3100W, IC-3110W, IC-3116W, IC-7100, IC-7110P, IC-7110W | H.264 SDP (recommended) |
| `rtsp://IP:554//stream1` | IR-113E, VS100 | Newer stream format (note double slash) |
| `rtsp://IP:554//stream2` | IR-112E | Sub stream (double slash) |
| `rtsp://IP:554/stream1` | Select newer models | Stream without double slash |
| `rtsp://IP:554/live1.sdp` | PT-112E | Live SDP for pan/tilt |
| `rtsp://IP:8000//stream1` | PT-31E | Non-standard port 8000 |

## Connecting with VisioForge SDK

Use your Edimax camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Edimax IC-3116W, H.264 main stream
var uri = new Uri("rtsp://192.168.1.90:554/ipcam_h264.sdp");
var username = "admin";
var password = "1234";
```

For newer IR/PT series models, use `/stream1` or `//stream1` instead of `/ipcam_h264.sdp`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/snapshot.jpg` | Basic snapshot, may require auth |
| Snapshot (account auth) | `http://IP/snapshot.jpg?account=USER&password=PASS` | Older firmware auth style |
| Snapshot (user auth) | `http://IP/snapshot.jpg?user=USER&pwd=PASS` | Newer firmware auth style |
| JPEG Image | `http://IP/jpg/image.jpg` | Direct JPEG |
| Channel JPEG | `http://IP/jpg/1/image.jpg` | Channel-specific JPEG |
| MJPEG Stream | `http://IP/mjpg/video.mjpg` | Continuous MJPEG stream |
| Channel MJPEG | `http://IP/mjpg/1/video.mjpg` | Channel-specific MJPEG |
| CGI Snapshot | `http://IP/snapshot.cgi` | CGI-based snapshot |
| CGI MJPEG | `http://IP/cgi/mjpg/mjpeg.cgi` | CGI MJPEG stream |
| Stream CGI | `http://IP/cgi-bin/Stream?Video` | Alternative video stream |

## Troubleshooting

### "401 Unauthorized" error

Edimax cameras ship with default credentials of **admin / 1234**. If authentication fails:

1. Access the camera at `http://CAMERA_IP` in a browser
2. Log in with the default credentials or the ones you configured
3. Navigate to **Configuration > Security** to verify or reset credentials
4. Use those credentials in your RTSP URL

### URL format not working

Edimax has used several different RTSP URL formats across model generations. If your URL does not connect:

1. Try `/ipcam_h264.sdp` first (works with most mid-generation models)
2. Try `/ipcam.sdp` for older IC-1500 and IC-3000 series
3. Try `//stream1` (with double slash) for newer IR and PT series
4. Try `/stream1` (single slash) if double slash fails
5. Check if your model uses port 8000 instead of 554 (e.g., PT-31E)

### Double-slash URLs

Some newer Edimax models use a double-slash in the RTSP path (e.g., `rtsp://IP:554//stream1`). This is intentional and not a typo. If `/stream1` does not work, try `//stream1`.

### Port 554 vs port 8000

Most Edimax cameras use the standard RTSP port 554, but some models (such as the PT-31E) use port 8000. Check your camera's web interface under **Configuration > Network > RTSP** for the correct port setting.

### Snapshot authentication style

If snapshot URLs return 401 errors even with correct credentials, try switching between the two authentication parameter styles:

- Older firmware: `?account=USER&password=PASS`
- Newer firmware: `?user=USER&pwd=PASS`

## FAQ

**What is the default RTSP URL for Edimax cameras?**

For most Edimax IC series cameras, the URL is `rtsp://admin:1234@CAMERA_IP:554/ipcam_h264.sdp`. For newer IR and PT series, use `rtsp://admin:1234@CAMERA_IP:554//stream1`. The exact format depends on the model and firmware version.

**Do Edimax cameras support ONVIF?**

Newer Edimax models support ONVIF. Older IC-1500 and IC-3000 series models may not have ONVIF support. Check your camera's specifications or web interface for ONVIF settings.

**Why does my Edimax camera use a double slash in the URL?**

Some newer Edimax models (IR and PT series) use a double-slash path format like `//stream1`. This is the correct format for those models and is not a typo. Both `//stream1` and `/stream1` may work depending on the firmware version.

**What is the difference between ipcam.sdp and ipcam\_h264.sdp?**

`/ipcam.sdp` is the generic SDP stream used by older models and may deliver either MJPEG or H.264 depending on the camera configuration. `/ipcam_h264.sdp` explicitly requests the H.264 encoded stream and is recommended for better compression and quality.

**Can I use both snapshot authentication styles?**

No. Each camera firmware version supports only one authentication style for HTTP URLs. Older firmware uses `account=USER&password=PASS` while newer firmware uses `user=USER&pwd=PASS`. Try both to determine which your camera expects.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Zavio Connection Guide](../zavio/) — Taiwanese SMB cameras
- [RTSP Video Streaming Guide](../../general/network-streaming/rtsp/) — Edimax RTSP network streaming
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Eufy Security Camera RTSP Connection Guide for C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/eufy/
**Description:** Eufy camera RTSP integration for C# .NET developers. Which eufyCam, SoloCam, and Indoor Cam models support RTSP/ONVIF, plus VisioForge SDK code samples.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, C#

# How to Connect to Eufy Security Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Eufy Security** is a smart home security brand owned by **Anker Innovations**, headquartered in Changsha, China. Eufy is known for local storage (no mandatory cloud subscription), AI-powered detection, and a wide range of indoor, outdoor, battery, and doorbell cameras. RTSP and ONVIF support varies significantly by model and firmware version.

**Key facts:**

- **Product lines:** eufyCam (battery), SoloCam (standalone), Indoor Cam, Floodlight Cam, Video Doorbell, HomeBase
- **Protocol support:** RTSP (select models, must be enabled), ONVIF (newer firmware), Eufy Security app
- **Default RTSP port:** 554
- **Default credentials:** No standard defaults — set during RTSP enablement
- **ONVIF support:** Added in recent firmware updates for many models
- **Video codecs:** H.264, H.265 (select models)
- **Local storage:** Yes — HomeBase or camera microSD (no cloud required for recording)

RTSP/ONVIF Support Varies by Model

Eufy has been gradually adding RTSP and ONVIF support across its product line through firmware updates. Not all models support these features. Check the Eufy Security app settings for your specific camera to see if RTSP is available.

## RTSP Support by Model

| Model | RTSP | ONVIF | Notes |
| --- | --- | --- | --- |
| eufyCam 2 / 2 Pro | Yes (via HomeBase) | Yes | Requires HomeBase 2 |
| eufyCam 2C / 2C Pro | Yes (via HomeBase) | Yes | Requires HomeBase 2 |
| eufyCam 3 / 3C | Yes (via HomeBase 3) | Yes | Requires HomeBase 3 |
| eufyCam S330 | Yes (via HomeBase 3) | Yes | 4K model |
| SoloCam S340 | Yes | Yes | Dual-lens, standalone RTSP |
| SoloCam C210 | Yes | Yes | Standalone with RTSP |
| Indoor Cam 2K | Yes | Yes | WiFi, firmware-dependent |
| Indoor Cam Pan & Tilt | Yes | Yes | WiFi, firmware-dependent |
| Floodlight Cam 2 Pro | Yes | Yes | Wired |
| Video Doorbell 2K | Limited | No | Via HomeBase only |
| Video Doorbell Dual | Limited | No | Via HomeBase only |

## Enabling RTSP

### For HomeBase-Connected Cameras (eufyCam series)

1. Open the **Eufy Security** app
2. Go to **HomeBase Settings > Storage > NAS** or **RTSP**
3. Enable RTSP streaming
4. Set an RTSP username and password
5. Note the RTSP URL displayed for each camera

### For Standalone Cameras (SoloCam, Indoor Cam, Floodlight)

1. Open the **Eufy Security** app
2. Select your camera → **Settings** (gear icon)
3. Look for **RTSP** or **Advanced > RTSP Stream**
4. Enable RTSP and set credentials
5. Note the RTSP URL provided

## RTSP URL Patterns

### Standard URL Format

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/live0
```

| Stream | URL Pattern | Description |
| --- | --- | --- |
| Main stream | `rtsp://IP:554/live0` | Full resolution |
| Sub stream | `rtsp://IP:554/live1` | Lower resolution |

### HomeBase RTSP URLs

When connected through a HomeBase, the RTSP URL points to the HomeBase IP:

```
rtsp://[USERNAME]:[PASSWORD]@[HOMEBASE_IP]:554/live0
```

For multiple cameras on one HomeBase, each camera gets a unique stream path shown in the app.

### Alternative URL Formats

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/live0` | Main stream (common) |
| `rtsp://IP:554/live1` | Sub stream |
| `rtsp://IP:554/stream1` | Alternative format (some models) |
| `rtsp://IP:554/h264_stream` | H.264 explicit (some firmware) |

## Connecting with VisioForge SDK

Use your Eufy camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Eufy SoloCam S340, main stream
var uri = new Uri("rtsp://192.168.1.90:554/live0");
var username = "rtsp_user"; // set in Eufy Security app
var password = "rtsp_pass";
```

For sub-stream access, use `/live1` instead of `/live0`.

## Troubleshooting

### RTSP option not visible in app

RTSP support requires specific firmware versions. Update your camera and HomeBase firmware through the Eufy Security app. If RTSP still does not appear, your model may not yet support it.

### HomeBase vs standalone RTSP

- **HomeBase cameras** (eufyCam series): RTSP streams come from the **HomeBase IP**, not the camera IP. The HomeBase acts as a proxy.
- **Standalone cameras** (SoloCam, Indoor Cam): RTSP streams come directly from the **camera IP**.

### Stream drops on battery cameras

Battery-powered eufyCam models may stop RTSP streaming when in standby mode. The camera must be actively recording or in "always streaming" mode for continuous RTSP access. This significantly impacts battery life.

### ONVIF discovery

Newer Eufy firmware supports ONVIF discovery. Use ONVIF to automatically find cameras on your network instead of manually configuring RTSP URLs.

### Firmware inconsistencies

Eufy has been rolling out RTSP/ONVIF support gradually. Different cameras in your setup may have different capabilities depending on their firmware version. Always update all devices to the latest firmware.

## FAQ

**Do Eufy cameras support RTSP?**

Many Eufy cameras now support RTSP, but it must be enabled in the Eufy Security app and varies by model. HomeBase-connected cameras stream RTSP through the HomeBase, while standalone cameras stream directly. Check your specific model's capabilities in the app settings.

**Do Eufy cameras require a cloud subscription for RTSP?**

No. RTSP streaming works locally without any cloud subscription. Eufy cameras store footage on the HomeBase or camera microSD card. The cloud subscription (Eufy Security Plan) is optional and provides additional cloud storage and features.

**Can I use Eufy cameras without the Eufy app?**

Initial setup requires the Eufy Security app. After setup and RTSP enablement, you can access the RTSP stream without the app. However, firmware updates and configuration changes still require the app.

**What is the difference between HomeBase RTSP and standalone RTSP?**

HomeBase RTSP streams all connected cameras through the HomeBase's IP address. The HomeBase acts as a gateway. Standalone cameras (SoloCam, Indoor Cam, Floodlight) stream directly from their own IP. HomeBase RTSP may have slightly higher latency.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Arlo Connection Guide](../arlo/) — Consumer alternative (no RTSP)
- [Reolink Connection Guide](../reolink/) — Consumer with native RTSP
- [EZVIZ Connection Guide](../ezviz/) — Smart home cameras with RTSP
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## EverFocus IP Camera RTSP URL Connection Guide for C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/everfocus/
**Description:** EverFocus EAN, EHN, EMN, EPN, and EQN series RTSP URL patterns for C# .NET. Stream and record using VisioForge Video Capture SDK integration.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MJPEG, C#

# How to Connect to EverFocus IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**EverFocus Electronics** is a Taiwanese professional surveillance company headquartered in New Taipei City, Taiwan, with US operations based in Duarte, California. Founded in 1995, EverFocus manufactures IP cameras, DVRs, and mobile surveillance solutions designed for professional security integrators. The company is well-known in the commercial and industrial surveillance market.

**Key facts:**

- **Product lines:** EAN (bullet), EHN (dome), EMN (mini dome), EPN (PTZ), EZN (compact), EQN (turret), ECOR/EPARA (DVRs)
- **Protocol support:** RTSP, ONVIF, HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** admin / admin
- **ONVIF support:** Yes (all current IP cameras)
- **Video codecs:** H.264 (all current models)

EverFocus RTSP URL Format

EverFocus cameras use a unique `rtspStreamOvf` path in their RTSP URLs. This format is specific to EverFocus and should not be confused with other manufacturers' URL patterns. Note the required double-slash (`//`) before `cgi-bin`.

## RTSP URL Patterns

### Standard URL Format

EverFocus cameras use the `rtspStreamOvf` CGI path for RTSP streaming:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554//cgi-bin/rtspStreamOvf/0
```

| Parameter | Value | Description |
| --- | --- | --- |
| Stream index | `/0` | Main stream (highest resolution) |
| Stream index | `/1` | Sub stream (lower resolution, less bandwidth) |

Double-Slash Required

The URL path must include a double-slash before `cgi-bin` (i.e., `//cgi-bin/rtspStreamOvf/...`). Omitting the leading slash will cause the connection to fail.

### Primary URL Format (rtspStreamOvf)

Most EverFocus IP cameras use the `rtspStreamOvf` format:

| Model | Series | Main Stream URL | Sub Stream URL |
| --- | --- | --- | --- |
| EAN3220 | EAN (bullet) | `rtsp://IP:554//cgi-bin/rtspStreamOvf/0` | `rtsp://IP:554//cgi-bin/rtspStreamOvf/1` |
| EHN3260 | EHN (dome) | `rtsp://IP:554//cgi-bin/rtspStreamOvf/0` | `rtsp://IP:554//cgi-bin/rtspStreamOvf/1` |
| EMN2220 | EMN (mini dome) | `rtsp://IP:554//cgi-bin/rtspStreamOvf/0` | `rtsp://IP:554//cgi-bin/rtspStreamOvf/1` |
| EMN1360 | EMN (mini dome) | `rtsp://IP:554//cgi-bin/rtspStreamOvf/0` | `rtsp://IP:554//cgi-bin/rtspStreamOvf/1` |
| EMN3260 | EMN (mini dome) | `rtsp://IP:554//cgi-bin/rtspStreamOvf/0` | `rtsp://IP:554//cgi-bin/rtspStreamOvf/1` |
| EPN4220 | EPN (PTZ) | `rtsp://IP:554//cgi-bin/rtspStreamOvf/0` | `rtsp://IP:554//cgi-bin/rtspStreamOvf/1` |
| EZN3160 | EZN (compact) | `rtsp://IP:554//cgi-bin/rtspStreamOvf/0` | `rtsp://IP:554//cgi-bin/rtspStreamOvf/1` |

### Alternative URL Format (streaming/channels)

Some newer EverFocus models also support the `streaming/channels` format:

| Model | Series | Main Stream URL |
| --- | --- | --- |
| EPN4220 | EPN (PTZ) | `rtsp://IP:554/streaming/channels/0` |
| EZN3240 | EZN (compact) | `rtsp://IP:554/streaming/channels/0` |
| EHN3260 | EHN (dome) | `rtsp://IP:554/streaming/channels/0` |

Which Format to Use

Try the `rtspStreamOvf` format first, as it is supported across all EverFocus IP camera product lines. The `streaming/channels` format is an alternative available on select newer models.

## Connecting with VisioForge SDK

Use your EverFocus camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// EverFocus EHN3260, main stream
var uri = new Uri("rtsp://192.168.1.90:554//cgi-bin/rtspStreamOvf/0");
var username = "admin";
var password = "admin";
```

For sub-stream access, use `/1` instead of `/0` at the end of the URL.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Supported Models |
| --- | --- | --- |
| Snapshot (with auth) | `http://IP/snapshot.jpg?user=USER&pwd=PASS&strm=CHANNEL` | EQN2101 |
| Snapshot (simple) | `http://IP/snapshot.jpg?user=USER&pwd=PASS` | General IP cameras |
| Mobile snapshot | `http://IP/m/camera[CHANNEL].jpg` | ECOR/EPARA DVRs |

DVR Snapshots

For ECOR and EPARA DVR models, replace `[CHANNEL]` with the camera channel number (e.g., `camera1.jpg` for channel 1).

## Troubleshooting

### Connection refused or timeout

EverFocus cameras use the `rtspStreamOvf` CGI path which is unique to this brand. Make sure you are not accidentally using a URL format from another manufacturer:

1. Verify the URL includes the double-slash: `//cgi-bin/rtspStreamOvf/0`
2. Confirm the RTSP port is 554 (or check the camera's network settings for a custom port)
3. Ensure the camera is accessible on the network by pinging its IP address

### Stream index starts at 0

Unlike some other camera brands where channels start at 1, EverFocus stream indices start at **0**:

- `/0` = Main stream (full resolution)
- `/1` = Sub stream (reduced resolution)

Using `/1` expecting the main stream will return the sub stream instead.

### Alternative URL format not working

The `streaming/channels/0` URL format is only available on certain newer models (EPN4220, EZN3240, EHN3260). If this format does not work, fall back to the standard `//cgi-bin/rtspStreamOvf/0` format.

### Authentication issues

EverFocus cameras default to `admin` / `admin`. If you have changed the password via the web interface and forgotten it, a hardware reset button on the camera will restore factory defaults.

## FAQ

**What is the default RTSP URL for EverFocus cameras?**

The default URL is `rtsp://admin:admin@CAMERA_IP:554//cgi-bin/rtspStreamOvf/0` for the main stream. Use `/1` at the end for the sub stream. Note the double-slash before `cgi-bin` which is required.

**Why does the EverFocus RTSP URL look different from other cameras?**

EverFocus uses a proprietary `rtspStreamOvf` CGI path that is unique to their camera firmware. This is different from the more common formats used by Hikvision, Dahua, or ONVIF generic paths. The double-slash (`//cgi-bin/...`) is intentional and required.

**Do EverFocus cameras support ONVIF?**

Yes. All current EverFocus IP cameras support ONVIF, which provides a standardized way to discover and connect to the camera. You can use ONVIF as an alternative to the proprietary RTSP URL format.

**Can I connect to EverFocus DVRs (ECOR/EPARA) via RTSP?**

EverFocus DVRs primarily expose HTTP-based snapshot URLs for individual channels (`http://IP/m/camera[CHANNEL].jpg`). For RTSP streaming from DVR channels, consult your specific DVR model's documentation or use ONVIF discovery.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Speco Connection Guide](../speco/) — Professional surveillance cameras
- [RTSP Video Streaming Guide](../../general/network-streaming/rtsp/) — EverFocus RTSP streaming setup
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## EZVIZ IP Camera RTSP URL and Connection Guide for C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/ezviz/
**Description:** Connect to EZVIZ cameras in C# .NET with RTSP URL patterns for C1C, C3W, C6N, BC1C and other models. Enable RTSP on cloud-first cameras.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, C#

# How to Connect to EZVIZ IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**EZVIZ** is a consumer smart home and security camera brand owned by **Hikvision**. Originally launched as Hikvision's consumer division, EZVIZ became an independent brand focused on home cameras, doorbells, smart locks, and IoT devices. EZVIZ cameras are designed primarily for cloud-based use via the EZVIZ app, but many models support local RTSP streaming when enabled.

**Key facts:**

- **Product lines:** C-series (indoor/outdoor), BC-series (battery), DB-series (doorbells), H-series (pan/tilt)
- **Protocol support:** RTSP (must be enabled), ONVIF (limited models), EZVIZ Cloud (default)
- **Default RTSP port:** 554
- **Default credentials:** admin / verification code (printed on camera label)
- **ONVIF support:** Limited (some newer models only)
- **Video codecs:** H.264, H.265 (select models)
- **Parent company:** Hikvision

RTSP Must Be Enabled Manually

EZVIZ cameras are cloud-first devices. **RTSP is disabled by default** on most models. You must enable RTSP through the EZVIZ mobile app or web portal before connecting with the VisioForge SDK. Some budget and battery-powered models do not support RTSP at all.

## Enabling RTSP on EZVIZ Cameras

Before connecting, enable RTSP access:

1. Open the **EZVIZ app** on your phone
2. Select your camera → **Settings** (gear icon)
3. Navigate to **Local Network** or **LAN access**
4. Enable **RTSP** or **Third-party access**
5. Note the verification code (usually printed on the camera label or shown in app)

Alternatively, use the EZVIZ web portal at `https://www.ezvizlife.com` to manage camera settings.

## RTSP URL Patterns

### Standard URL Format

EZVIZ cameras use Hikvision-derived RTSP URL patterns:

```
rtsp://admin:[VERIFICATION_CODE]@[IP]:554/h264/ch1/main/av_stream
```

| Stream | URL Pattern | Description |
| --- | --- | --- |
| Main stream | `rtsp://IP:554/h264/ch1/main/av_stream` | Full resolution |
| Sub stream | `rtsp://IP:554/h264/ch1/sub/av_stream` | Lower resolution |

Verification Code as Password

EZVIZ cameras use the **verification code** (printed on the camera label) as the RTSP password. The username is always `admin`. This is different from the EZVIZ cloud account password.

### Alternative URL Formats

Some EZVIZ models support additional URL patterns:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/h264/ch1/main/av_stream` | Standard (recommended) |
| `rtsp://IP:554/h264/ch1/sub/av_stream` | Sub stream |
| `rtsp://IP:554/Streaming/Channels/101` | Hikvision-style (some models) |
| `rtsp://IP:554/Streaming/Channels/102` | Hikvision-style sub stream |
| `rtsp://IP:554/live` | Simple path (older models) |

### Camera Models

| Model | Type | RTSP Support | Main Stream URL |
| --- | --- | --- | --- |
| C6N (indoor pan/tilt) | Indoor | Yes | `rtsp://IP:554/h264/ch1/main/av_stream` |
| C6W (4MP indoor PT) | Indoor | Yes | `rtsp://IP:554/h264/ch1/main/av_stream` |
| C1C (1080p indoor) | Indoor | Yes | `rtsp://IP:554/h264/ch1/main/av_stream` |
| H6c (pan/tilt) | Indoor | Yes | `rtsp://IP:554/h264/ch1/main/av_stream` |
| H8c (outdoor PT) | Outdoor | Yes | `rtsp://IP:554/h264/ch1/main/av_stream` |
| C3W (outdoor bullet) | Outdoor | Yes | `rtsp://IP:554/h264/ch1/main/av_stream` |
| C3WN (outdoor bullet) | Outdoor | Yes | `rtsp://IP:554/h264/ch1/main/av_stream` |
| C3X (dual-lens outdoor) | Outdoor | Yes | `rtsp://IP:554/h264/ch1/main/av_stream` |
| BC1C (battery cam) | Battery | No | N/A — cloud-only |
| DB1C (doorbell) | Doorbell | No | N/A — cloud-only |

Battery and Doorbell Models

EZVIZ battery-powered cameras (BC series) and video doorbells (DB series) generally do **not** support RTSP. These devices only stream through the EZVIZ cloud. Only AC-powered cameras with wired network or stable WiFi connections support RTSP.

## Connecting with VisioForge SDK

Use your EZVIZ camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// EZVIZ C6N, main stream (verification code from label)
var uri = new Uri("rtsp://192.168.1.90:554/h264/ch1/main/av_stream");
var username = "admin";
var password = "ABCDEF"; // verification code from camera label
```

For sub-stream access, use `/h264/ch1/sub/av_stream` instead.

## Snapshot URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/snapshot.cgi` | Requires basic auth with verification code |

## Troubleshooting

### "Connection refused" or no response

RTSP is disabled by default on EZVIZ cameras. You must enable it through the EZVIZ app first. Check **Settings > Local Network > Third-party access**.

### Wrong password

EZVIZ cameras use the **verification code** (6 uppercase letters printed on the camera label) as the RTSP password, **not** your EZVIZ cloud account password. The username is always `admin`.

### Camera not on local network

EZVIZ cameras connect to the cloud via WiFi. To use RTSP, the camera and your application must be on the same local network. The camera's local IP can be found in the EZVIZ app under **Device Info** or in your router's DHCP client list.

### RTSP option not available in app

Some EZVIZ models and firmware versions do not expose RTSP settings. In this case:

1. Update the camera firmware through the EZVIZ app
2. If RTSP still does not appear, the model may not support local streaming
3. Battery-powered and doorbell models typically do not support RTSP

### Hikvision URL format works on some models

Since EZVIZ cameras use Hikvision firmware, some models also accept the Hikvision URL format (`/Streaming/Channels/101`). Try this if the standard EZVIZ URL does not work.

## FAQ

**What is the default RTSP URL for EZVIZ cameras?**

The standard URL is `rtsp://admin:VERIFICATION_CODE@CAMERA_IP:554/h264/ch1/main/av_stream`. The VERIFICATION\_CODE is the 6-character code printed on your camera's label. RTSP must be enabled in the EZVIZ app first.

**Is EZVIZ related to Hikvision?**

Yes. EZVIZ is a brand owned by Hikvision, focused on the consumer smart home market. EZVIZ cameras use Hikvision-derived firmware, which is why similar RTSP URL patterns work. However, EZVIZ cameras are designed primarily for cloud-based use.

**Can I use EZVIZ cameras without the cloud?**

Partially. You can access RTSP streams locally without the EZVIZ cloud for live viewing and recording. However, initial camera setup, firmware updates, and enabling RTSP require the EZVIZ app (which uses the cloud). Features like motion alerts and clip storage require an EZVIZ cloud subscription.

**Do EZVIZ cameras support ONVIF?**

Some newer EZVIZ models support ONVIF, but it is not available on all cameras. Check your camera's specifications or the EZVIZ app settings for ONVIF support. For most EZVIZ cameras, direct RTSP connection is more reliable than ONVIF.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Hikvision Connection Guide](../hikvision/) — Parent company, similar URL format
- [Imou Connection Guide](../imou/) — Dahua consumer brand, similar market
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## FLIR IP Camera RTSP Connection Guide in C# .NET SDK
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/flir/
**Description:** FLIR Quasar, Saros, and Elara thermal camera RTSP URL patterns for C# .NET. Teledyne FLIR integration with VisioForge Video Capture SDK code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, USB3 Vision / GigE, RTSP, ONVIF, H.265, MJPEG, C#

# How to Connect to FLIR IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**FLIR Systems** (now **Teledyne FLIR** following the 2021 acquisition by Teledyne Technologies) is a leading manufacturer of thermal imaging cameras and visible-light security cameras. Headquartered in Wilsonville, Oregon, USA, FLIR serves enterprise, critical infrastructure, and government markets. FLIR is best known for thermal imaging but also produces a full range of visible-light IP cameras for professional surveillance. FLIR previously acquired **Lorex** and **DVTEL** (now FLIR Latitude VMS).

**Key facts:**

- **Product lines:** Quasar (premium multi-sensor/mini-dome), Saros (perimeter detection), Elara (thermal+visible dual-sensor), CM (compact mini dome), CF (compact fixed), PT/PTZ (pan-tilt-zoom), FC (thermal-only), FLIR FX (consumer, discontinued)
- **Protocol support:** RTSP, ONVIF (Quasar, Saros, Elara series), HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** admin / admin (most models), admin / fliradmin (some Quasar models)
- **ONVIF support:** Yes (Quasar, Saros, Elara series)
- **Video codecs:** H.264, H.265 (Quasar series), MJPEG
- **Thermal specialization:** FLIR thermal cameras output radiometric data in addition to visible-light video, with separate RTSP streams for each sensor

Thermal cameras have separate streams

FLIR dual-sensor cameras (Elara, PT-series) provide separate RTSP streams for visible and thermal channels. Typically `ch0` is the visible channel and `ch1` is the thermal channel.

## RTSP URL Patterns

### Current Models (Quasar, Saros, Elara)

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Visible channel | `rtsp://IP:554/ch0` | Primary visible stream |
| Thermal channel | `rtsp://IP:554/ch1` | Thermal stream (dual-sensor models) |
| Visible (alt) | `rtsp://IP:554/vis` | Visible on PT-series |
| Wide FOV thermal | `rtsp://IP:554/wfov` | PT-series, wide field of view |
| Auth stream | `rtsp://IP:554/0/USERNAME:PASSWORD/main` | With embedded credentials |

### Model-Specific URLs

| Model Series | RTSP URL | Type | Notes |
| --- | --- | --- | --- |
| Quasar CM-3308 | `rtsp://IP:554/ch0` | Mini dome | Compact multi-sensor |
| Quasar CM-6208 | `rtsp://IP:554/ch0` | Mini dome | Compact multi-sensor |
| D-series (fixed dome) | `rtsp://IP:554/ch0` | Fixed dome | Visible stream |
| F-series (fixed) | `rtsp://IP:554/ch0` | Fixed | Visible stream |
| PT-series (PTZ-35x140) | `rtsp://IP:554/vis` | PTZ | Visible channel |
| PT-series (PTZ-35x140) | `rtsp://IP:554/wfov` | PTZ | Wide FOV thermal |
| Elara (visible) | `rtsp://IP:554/ch0` | Thermal+visible | Visible channel |
| Elara (thermal) | `rtsp://IP:554/ch1` | Thermal+visible | Thermal channel |
| FC-series (thermal) | `rtsp://IP:554/ch0` | Thermal only | Thermal stream |

### Dual-Sensor Thermal Cameras

FLIR dual-sensor cameras provide both visible and thermal video on separate channels:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Elara visible | `rtsp://IP:554/ch0` | Visible-light sensor |
| Elara thermal | `rtsp://IP:554/ch1` | Thermal sensor |
| PT visible | `rtsp://IP:554/vis` | Visible-light sensor |
| PT wide thermal | `rtsp://IP:554/wfov` | Wide FOV thermal sensor |

## Connecting with VisioForge SDK

Use your FLIR camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// FLIR Quasar mini-dome, visible stream
var uri = new Uri("rtsp://192.168.1.70:554/ch0");
var username = "admin";
var password = "admin";
```

For dual-sensor cameras, use `ch1` to access the thermal stream. For PT-series cameras, use `/vis` for the visible channel or `/wfov` for the wide FOV thermal channel.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/jpg/image.jpg` | Some models |
| Snapshot (alt) | `http://IP/snapshot.jpg` | Alternative path |

## Troubleshooting

### Thermal vs. visible channels

FLIR dual-sensor cameras (Elara, PT-series) expose separate RTSP streams for each sensor:

- `ch0` = visible-light channel (most models)
- `ch1` = thermal channel (most models)
- `/vis` = visible channel (PT-series)
- `/wfov` = wide FOV thermal (PT-series)

If you connect to the wrong channel, you may receive thermal imagery when you expected visible or vice versa. Check your camera's documentation for channel assignments.

### Default credentials differ by model

- **Most FLIR cameras:** admin / admin
- **Some Quasar models:** admin / fliradmin
- **Current Teledyne FLIR firmware:** Password may need to be set during initial configuration

Always change default credentials before deploying cameras on a production network.

### Teledyne FLIR rebranding

Teledyne Technologies acquired FLIR Systems in 2021. Current firmware versions may display Teledyne FLIR branding, and newer cameras may ship with updated web interfaces and configuration tools. RTSP URL patterns remain consistent with legacy FLIR cameras.

### FLIR FX consumer cameras

The discontinued FLIR FX consumer camera line used cloud-only access and does not support RTSP streaming. These cameras cannot be connected via direct RTSP URLs.

### FLIR Lorex cameras

FLIR acquired Lorex, but Lorex cameras use their own RTSP URL patterns (based on Dahua firmware). Do not use FLIR URL patterns for Lorex cameras. See the [Lorex](../lorex/) page for Lorex-specific URLs.

### ONVIF availability

ONVIF is supported on current-generation cameras (Quasar, Saros, Elara). Older FLIR cameras and consumer models (FLIR FX) do not support ONVIF. For ONVIF-supported models, use ONVIF discovery as an alternative to manual RTSP URL configuration.

## FAQ

**What is the default RTSP URL for FLIR cameras?**

For most FLIR cameras, use `rtsp://admin:admin@CAMERA_IP:554/ch0` for the visible stream. For dual-sensor thermal cameras, use `ch1` for the thermal stream. For PT-series cameras, use `/vis` (visible) or `/wfov` (wide FOV thermal).

**Does FLIR support H.265?**

Quasar-series cameras support H.265 encoding. Other FLIR camera lines primarily use H.264 and MJPEG. Check your specific model's datasheet for codec support.

**How do I access the thermal stream on a FLIR dual-sensor camera?**

Dual-sensor cameras provide separate RTSP streams for visible and thermal channels. On Elara models, `ch0` is visible and `ch1` is thermal. On PT-series models, `/vis` is visible and `/wfov` is the wide FOV thermal stream. Connect to the appropriate URL for the desired sensor.

**Are FLIR and Teledyne FLIR the same company?**

Yes. Teledyne Technologies acquired FLIR Systems in 2021. The company now operates as Teledyne FLIR. Existing FLIR cameras continue to work with the same RTSP URL patterns. Newer products may carry Teledyne FLIR branding.

**Can I use FLIR URL patterns for Lorex cameras?**

No. Although FLIR acquired Lorex, Lorex cameras use Dahua-based firmware with different RTSP URL patterns. See the [Lorex](../lorex/) camera connection guide for the correct URLs.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Basler Connection Guide](../basler/) — Industrial / machine vision cameras
- [Mobotix Connection Guide](../mobotix/) — German industrial cameras
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Foscam IP Camera RTSP URL Guide and C# .NET Integration
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/foscam/
**Description:** Connect to Foscam cameras in C# .NET with RTSP and HTTP URL patterns, CGI API access, and code samples for FI, C1, C2, R2, and R4 models.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Foscam IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Foscam** (Shenzhen Foscam Intelligent Technology Co., Ltd.) is a Chinese manufacturer specializing in consumer and small business IP cameras. Founded in 2007 and headquartered in Shenzhen, China, Foscam gained popularity for affordable Wi-Fi cameras and was one of the first brands to bring low-cost IP cameras to the consumer market.

**Key facts:**

- **Product lines:** FI-series (legacy pan/tilt), C1/C2 (indoor HD), R2/R4 (indoor pan/tilt), SD (outdoor), G-series (battery), VZ-series (doorbell)
- **Protocol support:** RTSP, HTTP/CGI, ONVIF (newer models), P2P
- **Default RTSP port:** 88 (not 554 -- this is unique to Foscam)
- **Default HTTP port:** 88
- **Default credentials:** admin / (blank password on older models); admin / (set during setup on newer models)
- **ONVIF support:** Partial (newer HD models only, e.g., C1, C2, R2, R4)
- **Video codecs:** H.264 (HD models), MJPEG (legacy models)

## RTSP URL Patterns

Foscam cameras use a non-standard port (88) and simple stream path names.

### URL Format

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:88/videoMain
```

Non-standard port

Foscam cameras typically use **port 88** for both RTSP and HTTP, not the standard port 554. This is the most common connection issue.

### HD Models (H.264)

| Model Series | RTSP URL | Stream | Audio |
| --- | --- | --- | --- |
| C1 / C1 Lite (indoor) | `rtsp://IP:88/videoMain` | Main (720p) | Yes |
| C1 / C1 Lite (indoor) | `rtsp://IP:88/videoSub` | Sub (VGA) | Yes |
| C2 (indoor 1080p) | `rtsp://IP:88/videoMain` | Main (1080p) | Yes |
| C2 (indoor 1080p) | `rtsp://IP:88/videoSub` | Sub (VGA) | Yes |
| R2 (pan/tilt 1080p) | `rtsp://IP:88/videoMain` | Main (1080p) | Yes |
| R4 (pan/tilt 1440p) | `rtsp://IP:88/videoMain` | Main (2560x1440) | Yes |
| FI9821W V2 (pan/tilt) | `rtsp://IP:88/videoMain` | Main (720p) | Yes |
| FI9826W (pan/tilt/zoom) | `rtsp://IP:88/videoMain` | Main (960p) | Yes |
| FI9828P (outdoor PTZ) | `rtsp://IP:88/videoMain` | Main (960p) | Yes |
| FI9900P (outdoor bullet) | `rtsp://IP:88/videoMain` | Main (1080p) | Yes |
| SD2 (outdoor pan/tilt) | `rtsp://IP:88/videoMain` | Main (1080p) | Yes |

### Legacy Models (MJPEG only)

Older Foscam models (FI8904W, FI8910W, FI8918W, FI8919W) do not support RTSP. They use HTTP streaming only:

| Model | HTTP URL | Type | Audio |
| --- | --- | --- | --- |
| FI8904W | `http://IP:88/videostream.asf?user=USER&pwd=PASS` | ASF stream | Yes |
| FI8910W | `http://IP:88/videostream.asf?user=USER&pwd=PASS` | ASF stream | Yes |
| FI8918W | `http://IP:88/videostream.asf?user=USER&pwd=PASS` | ASF stream | Yes |
| FI8919W | `http://IP:88/videostream.asf?user=USER&pwd=PASS` | ASF stream | Yes |
| FI8904W | `http://IP:88/videostream.cgi?user=USER&pwd=PASS&resolution=32` | MJPEG | No |

### Alternative RTSP Ports

Some Foscam models can be configured for alternative ports:

| URL Pattern | Port | Notes |
| --- | --- | --- |
| `rtsp://IP:88/videoMain` | 88 | Default for most models |
| `rtsp://IP:554/videoMain` | 554 | If reconfigured in settings |
| `rtsp://IP:554/cam1/mpeg4` | 554 | Some OEM variants |
| `rtsp://IP:554/live1.sdp` | 554 | DCS-compatible firmware |

## Connecting with VisioForge SDK

Use your Foscam camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Foscam R2, main stream -- note port 88, not 554!
var uri = new Uri("rtsp://192.168.1.30:88/videoMain");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `/videoSub` instead.

## Snapshot and MJPEG URLs

Foscam provides a CGI API for snapshots and control:

| Type | URL Pattern | Notes |
| --- | --- | --- |
| CGI Snapshot (HD) | `http://IP:88/cgi-bin/CGIProxy.fcgi?cmd=snapPicture2&usr=USER&pwd=PASS` | HD models |
| Legacy Snapshot | `http://IP:88/snapshot.cgi?user=USER&pwd=PASS` | Legacy models |
| Snapshot (count) | `http://IP:88/snapshot.cgi?user=USER&pwd=PASS&count=0` | Single frame |
| MJPEG Stream (legacy) | `http://IP:88/videostream.cgi?user=USER&pwd=PASS&resolution=32` | VGA MJPEG |
| ASF Stream (legacy) | `http://IP:88/videostream.asf?user=USER&pwd=PASS` | ASF container |
| Video CGI | `http://IP:88/video.cgi?resolution=VGA` | Direct video |

## Troubleshooting

### Wrong port -- must use 88, not 554

The most common Foscam connection issue is using port 554. Foscam cameras default to **port 88** for all services (RTSP, HTTP, and CGI). If your connection times out, check the port number first.

### Legacy vs HD models

Foscam has two fundamentally different product generations:

- **Legacy (FI89xx):** MJPEG only, HTTP streaming via `videostream.asf` or `videostream.cgi`, no RTSP
- **HD (C1, C2, R2, R4, FI99xx):** H.264, RTSP via `videoMain`/`videoSub`, ONVIF support

If `rtsp://IP:88/videoMain` doesn't work, your camera is likely a legacy model -- use the HTTP streaming URLs instead.

### Blank/empty password

Older Foscam cameras ship with a blank password (username: `admin`, password: empty string). Newer firmware requires setting a password during initial setup. If authentication fails with a password, try an empty password for legacy models.

### Wi-Fi connection instability

Foscam Wi-Fi cameras can experience stream dropouts. Recommendations:

- Use TCP transport mode for reliability
- Position camera closer to the Wi-Fi router
- Use 2.4GHz Wi-Fi (better range) instead of 5GHz
- Reduce stream resolution to sub stream: `rtsp://IP:88/videoSub`

### ONVIF not available

ONVIF is only supported on newer HD models (C1, C2, R2, R4, FI99xx). Legacy FI89xx cameras do not support ONVIF. For legacy models, use direct HTTP/RTSP URLs instead.

## FAQ

**What is the default RTSP URL for Foscam cameras?**

For HD models, the URL is `rtsp://admin:password@CAMERA_IP:88/videoMain`. Note the non-standard port 88 (not 554). For legacy models (FI89xx series), use HTTP: `http://CAMERA_IP:88/videostream.asf?user=admin&pwd=password`.

**Why does Foscam use port 88 instead of the standard 554?**

Foscam chose port 88 as their default for all camera services to avoid conflicts with other network devices. You can change this in the camera's web interface under Settings > Network > Port, but the default is 88.

**Can I change the Foscam RTSP port to 554?**

Yes. Access the camera's web interface at `http://CAMERA_IP:88`, go to Settings > Network > Port, and change the RTSP port to 554. After saving and rebooting, you can use the standard port 554 in your RTSP URLs.

**Does Foscam support pan/tilt/zoom control via the SDK?**

Foscam PTZ models (R2, R4, FI9821, FI9826) support pan/tilt via their CGI API and ONVIF (HD models). You can send PTZ commands through ONVIF using the VisioForge SDK's PTZ control features.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [TP-Link Connection Guide](../tp-link/) — Consumer cameras with RTSP
- [D-Link Connection Guide](../dlink/) — Consumer segment peer
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## GeoVision IP Camera RTSP URL Setup and C# .NET Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/geovision/
**Description:** GeoVision GV-BL, GV-FD, GV-VD, GV-FE, and GV-DVR RTSP URL patterns for C# .NET. Integrate with VisioForge SDK for multi-channel surveillance apps.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MJPEG, C#

# How to Connect to GeoVision IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**GeoVision** (GeoVision Inc.) is a Taiwanese manufacturer of IP cameras, network video recorders, and video management software, headquartered in Taipei, Taiwan. GeoVision is a well-established brand in the enterprise and professional surveillance market, known for their GV-series IP cameras and the GeoVision VMS platform.

**Key facts:**

- **Product lines:** GV-BL (bullet), GV-FD (fixed dome), GV-VD (vandal dome), GV-FE (fisheye), GV-CB (cube), GV-CA (camera), GV-DVR (digital video recorder), GV-NVR
- **Protocol support:** RTSP, ONVIF, PSIA, HTTP/CGI
- **Default RTSP port:** 8554 (IP cameras), 554 (DVR/Server)
- **Default credentials:** admin / admin
- **ONVIF support:** Yes (current models)
- **Video codecs:** H.264, H.265 (current models), MPEG-4 (legacy)

Non-standard RTSP port

GeoVision IP cameras use **port 8554** by default, not the standard 554. Make sure to specify the correct port when constructing your RTSP URL. GeoVision DVR/Server software uses the standard port 554.

## RTSP URL Patterns

### IP Camera Standard Format

GeoVision IP cameras use a channel-based SDP URL pattern on port 8554:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:8554//CH001.sdp
```

| Parameter | Value | Description |
| --- | --- | --- |
| Port | 8554 | Default for GeoVision IP cameras |
| `CH001` | CH001, CH002... | Channel number (zero-padded 3 digits) |
| `.sdp` | Required | SDP session descriptor suffix |

Double slash

Some GeoVision models require a double slash (`//`) before the channel identifier. If a single slash does not work, try `//CH001.sdp`.

### IP Camera Streams

| Stream | URL | Notes |
| --- | --- | --- |
| Main stream | `rtsp://IP:8554//CH001.sdp` | Full resolution, port 8554 |
| Sub stream | `rtsp://IP:8554//CH002.sdp` | Lower resolution |

### DVR / GeoVision Server

GeoVision DVR and GV-Server software use port 554:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/CH001.sdp
```

| Channel | Main Stream URL | Notes |
| --- | --- | --- |
| Channel 1 | `rtsp://IP:554/CH001.sdp` | Port 554 on DVR/Server |
| Channel 2 | `rtsp://IP:554/CH002.sdp` | Port 554 on DVR/Server |
| Channel N | `rtsp://IP:554/CH00N.sdp` | Zero-pad to 3 digits |

### PSIA Streaming

GeoVision also supports PSIA-compatible RTSP URLs:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/PSIA/Streaming/channels/1?videoCodecType=MPEG4
```

### URL Summary Table

| Device Type | Main Stream URL | Default Port | Notes |
| --- | --- | --- | --- |
| GV-BL (bullet) | `rtsp://IP:8554//CH001.sdp` | 8554 | Standard IP camera |
| GV-FD (fixed dome) | `rtsp://IP:8554//CH001.sdp` | 8554 | Standard IP camera |
| GV-VD (vandal dome) | `rtsp://IP:8554//CH001.sdp` | 8554 | Standard IP camera |
| GV-FE (fisheye) | `rtsp://IP:8554//CH001.sdp` | 8554 | Standard IP camera |
| GV-CB (cube) | `rtsp://IP:8554//CH001.sdp` | 8554 | Standard IP camera |
| GV-DVR | `rtsp://IP:554/CH001.sdp` | 554 | DVR software |
| GV-NVR | `rtsp://IP:554/CH001.sdp` | 554 | NVR software |
| PSIA stream | `rtsp://IP:554/PSIA/Streaming/channels/1` | 554 | PSIA compatible |

## Connecting with VisioForge SDK

Use your GeoVision camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// GeoVision GV-BL2702, main stream (note port 8554)
var uri = new Uri("rtsp://192.168.1.90:8554//CH001.sdp");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `CH002.sdp` instead of `CH001.sdp`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/snapshot.cgi` | Requires basic auth |
| JPEG Snapshot (alt) | `http://IP/GetImage.cgi` | Some models |
| JPEG Snapshot (alt) | `http://IP/cgi-bin/getimage` | Some models |
| JPEG Snapshot (viewer) | `http://IP/cgi-bin/viewer/video.jpg` | Web viewer interface |
| Static image (alt) | `http://IP/cgi-bin/jpg/image.cgi` | Some models |
| Legacy snapshot | `http://IP/cam1.jpg` | Firmware 6.0-8.x, channel 1 |
| Legacy snapshot (ch N) | `http://IP/camN.jpg` | Firmware 6.0-8.x, channel N |

## Troubleshooting

### Wrong port — 554 vs 8554

The most common connection issue with GeoVision cameras is using the wrong port:

- **IP cameras** (GV-BL, GV-FD, GV-VD, GV-FE, GV-CB): Use **port 8554**
- **DVR / GV-Server software**: Use **port 554**

If you get a connection timeout, check that you are using the correct port for your device type.

### Double slash in URL path

Some GeoVision IP camera models require a double slash before the channel identifier (`//CH001.sdp`). If a single slash (`/CH001.sdp`) returns an error, add the extra slash.

### Channel numbering format

GeoVision uses zero-padded three-digit channel numbers: `CH001`, `CH002`, `CH003`, etc. Using `CH1` instead of `CH001` will not work.

### Firmware version differences

Older GeoVision firmware versions (6.x-8.x) may use different snapshot URL formats. If the CGI-based snapshot URL does not work, try the legacy format (`http://IP/cam1.jpg`).

## FAQ

**What port does GeoVision use for RTSP?**

GeoVision IP cameras use **port 8554** by default, which differs from the industry-standard port 554. GeoVision DVR and GV-Server software use the standard port 554.

**What is the default RTSP URL for GeoVision IP cameras?**

The URL is `rtsp://admin:password@CAMERA_IP:8554//CH001.sdp` for the main stream. Use `CH002.sdp` for the sub stream. Note the double slash before `CH001` and port 8554.

**Do GeoVision cameras support ONVIF?**

Yes. All current GeoVision IP camera models support ONVIF Profile S. ONVIF discovery can be used as an alternative to manual RTSP URL configuration.

**Can I connect to a GeoVision DVR and IP camera at the same time?**

Yes. Connect to the DVR on port 554 and individual IP cameras on port 8554. Each device has its own IP address and RTSP endpoint.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Vivotek Connection Guide](../vivotek/) — Taiwanese enterprise cameras
- [ACTi Connection Guide](../acti/) — Taiwanese professional cameras
- [RTSP Camera Integration Guide](../../videocapture/video-sources/ip-cameras/rtsp/) — GeoVision RTSP stream setup
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## How to Connect to Grandstream IP Camera in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/grandstream/
**Description:** Integrate Grandstream GXV and GSC cameras into C# .NET apps via RTSP. URL patterns for GXV3500, GXV3610, GSC3610, plus VisioForge SDK examples.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Grandstream IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Grandstream Networks** is an American company headquartered in Boston, Massachusetts, USA, known for VoIP phones and IP surveillance products. Grandstream offers IP cameras and video encoders under the **GXV** (legacy) and **GSC** (current generation) product lines, targeting SMB and professional markets. Their cameras are often deployed alongside Grandstream VoIP and UCM (Unified Communications Manager) systems.

**Key facts:**

- **Product lines:** GXV (IP cameras and video encoders, legacy), GSC (current generation smart cameras)
- **Protocol support:** RTSP, ONVIF (GXV36xx and newer GSC series), HTTP/CGI, SIP (video calling)
- **Default RTSP port:** 554
- **Default credentials:** admin / admin
- **ONVIF support:** Yes (GXV36xx and newer GSC models)
- **Video codecs:** H.264, H.265 (current GSC models), MPEG-4 (legacy GXV models)

## RTSP URL Patterns

### Current GSC-Series Cameras

Current generation Grandstream GSC cameras use a channel-based URL format:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Primary stream | `rtsp://IP:554/live/ch00_0` | Main stream, channel 0 |
| Secondary stream | `rtsp://IP:554/live/ch00_1` | Sub stream |

### GXV-Series (Legacy)

Older GXV cameras support multiple URL formats depending on the model:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Primary stream | `rtsp://IP:554//0` | Main stream (channel 0) |
| Secondary stream | `rtsp://IP:554//4` | Sub stream (channel 4) |
| H.264 SDP | `rtsp://IP:554/ipcam_h264.sdp` | SDP file-based access |
| Live H.264 | `rtsp://IP:554/live/h264` | Named stream |
| Channel-based | `rtsp://IP:554/[CHANNEL]` | Direct channel number |
| Auth stream | `rtsp://IP:554//0/888888:888888/main` | With embedded credentials |
| MPEG-4 (legacy) | `rtsp://IP:554/cam1/mpeg4?user=USER&pwd=PASS` | Legacy MPEG-4 stream |

Unusual channel numbering

Grandstream uses a non-standard channel numbering scheme. For single-channel cameras, channel **0** is the primary stream and channel **4** is the secondary stream. This differs from most other brands that use sequential numbering.

### Model-Specific URLs

| Model | Primary Stream | Secondary Stream | Type |
| --- | --- | --- | --- |
| GXV3500 | `rtsp://IP:554/0` | `rtsp://IP:554/4` | Video encoder |
| GXV3504 (ch 1) | `rtsp://IP:554/0` | `rtsp://IP:554/4` | 4-channel encoder |
| GXV3504 (ch 2) | `rtsp://IP:554/1` | `rtsp://IP:554/5` | 4-channel encoder |
| GXV3504 (ch 3) | `rtsp://IP:554/2` | `rtsp://IP:554/6` | 4-channel encoder |
| GXV3504 (ch 4) | `rtsp://IP:554/3` | `rtsp://IP:554/7` | 4-channel encoder |
| GXV3601 / GXV3611 | `rtsp://IP:554//4` | -- | Dome camera |
| GXV3601 (alt) | `rtsp://IP:554/ipcam_h264.sdp` | -- | SDP-based |
| GXV3610 | `rtsp://IP:554/0` | `rtsp://IP:554/4` | Dome HD |
| GXV3651 / GXV3661 / GXV3662 | `rtsp://IP:554/0` | `rtsp://IP:554/4` | FHD cameras |
| GXV3672 | `rtsp://IP:554//0` | `rtsp://IP:554/live/ch00_0` | HD/FHD outdoor |
| GSC3610 / GSC3615 | `rtsp://IP:554/live/ch00_0` | `rtsp://IP:554/live/ch00_1` | Current dome |
| GSC3620 | `rtsp://IP:554/live/ch00_0` | `rtsp://IP:554/live/ch00_1` | Current outdoor |

### Multi-Channel Encoder (GXV3504) Channel Map

The GXV3504 is a 4-channel video encoder with the following channel numbering:

| Input | Primary Channel | Secondary Channel |
| --- | --- | --- |
| Input 1 | 0 | 4 |
| Input 2 | 1 | 5 |
| Input 3 | 2 | 6 |
| Input 4 | 3 | 7 |

## Connecting with VisioForge SDK

Use your Grandstream camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Grandstream GSC-series camera, main stream
var uri = new Uri("rtsp://192.168.1.60:554/live/ch00_0");
var username = "admin";
var password = "YourPassword";
```

For legacy GXV models, use `rtsp://IP:554//0` for the primary stream or `rtsp://IP:554//4` for the secondary stream.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/snapshot/view0.jpg` | Channel 0 snapshot |
| JPEG Snapshot (ch 1) | `http://IP/snapshot/view1.jpg` | Channel 1 (multi-channel) |
| HTTP Stream | `http://IP/goform/stream?cmd=get&channel=0` | Channel-based HTTP stream |

## Troubleshooting

### Channel numbering confusion

Grandstream channel numbering is unconventional:

- **Single-channel cameras:** Channel 0 = primary stream, Channel 4 = secondary stream
- **GXV3504 (4-channel encoder):** Channels 0-3 are primary streams for inputs 1-4; Channels 4-7 are secondary streams for inputs 1-4

If you get a blank stream or error, double-check you are using the correct channel number for your desired stream quality.

### Factory default credential `888888`

Some older Grandstream GXV models use `888888` as the default password (or embedded in the RTSP URL as `888888:888888`). If `admin` / `admin` does not work, try `888888` as the password.

### RTSP not enabled

On some older GXV models, RTSP streaming must be explicitly enabled in the camera's web interface. Navigate to the streaming or media settings page and confirm that RTSP is turned on and set to port 554.

### Multiple URL formats per model

Many GXV cameras support several RTSP URL formats simultaneously. If one format does not work, try the alternatives:

1. `rtsp://IP:554//0` (channel number with double slash)
2. `rtsp://IP:554/live/ch00_0` (named channel)
3. `rtsp://IP:554/ipcam_h264.sdp` (SDP file)
4. `rtsp://IP:554/live/h264` (named stream)

### Codec compatibility

Current GSC-series cameras support H.265 and H.264. Legacy GXV models may default to MPEG-4. If you experience decoding issues with a legacy model, check the camera's web interface and switch the codec to H.264 if available.

## FAQ

**What is the default RTSP URL for Grandstream cameras?**

For current GSC-series cameras, use `rtsp://admin:password@CAMERA_IP:554/live/ch00_0`. For older GXV-series cameras, try `rtsp://admin:password@CAMERA_IP:554//0` for the primary stream.

**Do Grandstream cameras support ONVIF?**

Yes, the GXV36xx series and current GSC-series cameras support ONVIF. Older GXV35xx models and video encoders generally do not support ONVIF.

**What is the difference between channel 0 and channel 4?**

On single-channel Grandstream cameras, channel 0 is the primary (high quality) stream and channel 4 is the secondary (lower quality) stream. This is a Grandstream-specific convention that differs from most other camera brands.

**Can I use Grandstream cameras with a UCM system?**

Yes. Grandstream cameras integrate natively with Grandstream UCM (Unified Communications Manager) systems. However, RTSP access works independently of the UCM and can be used with any third-party software including VisioForge SDKs.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Milesight Connection Guide](../milesight/) — SMB / professional camera segment
- [ONVIF IP Camera Integration](../../videocapture/video-sources/ip-cameras/onvif/) — Grandstream ONVIF device setup
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## How to Connect to Hanwha Vision IP Camera in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/hanwha/
**Description:** Hanwha Vision X, Q, P, L series and Wisenet NVR RTSP URL patterns for C# .NET. ONVIF-compatible integration with VisioForge SDK code samples.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Decoding, IP Camera, RTSP, ONVIF, MJPEG, C#

# How to Connect to Hanwha Vision IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Hanwha Vision** (formerly Hanwha Techwin, formerly Samsung Techwin) is a South Korean video surveillance manufacturer and a subsidiary of Hanwha Group. Hanwha acquired Samsung's security division in 2015 and rebranded to Hanwha Vision in 2023. All cameras are sold under the **Wisenet** product brand. Hanwha Vision is a top-5 global surveillance manufacturer with strong enterprise and government market presence.

**Key facts:**

- **Product lines:** Wisenet X (premium), Wisenet P (AI/4K), Wisenet Q (mainstream), Wisenet L (value), Wisenet T (thermal)
- **Protocol support:** RTSP, ONVIF Profile S/G/T, HTTP/CGI, SUNAPI (proprietary)
- **Default RTSP port:** 554
- **Default credentials:** admin / (set during initial setup; older models: admin / 4321)
- **ONVIF support:** Yes (all current models)
- **Video codecs:** H.264, H.265 (WiseStream II), MJPEG
- **Product brand:** Wisenet (see also our [Samsung/Hanwha guide](../samsung/) for legacy Samsung Techwin URLs)

Hanwha Vision vs Samsung vs Wisenet

**Hanwha Vision** is the company name (since 2023). **Wisenet** is the product brand for all cameras and NVRs. **Samsung Techwin** was the previous company name (before 2015). Our [Samsung/Hanwha guide](../samsung/) covers legacy Samsung-branded models. This page covers current Hanwha Vision / Wisenet products.

## RTSP URL Patterns

### Standard URL Format

Hanwha Vision cameras use a profile-based RTSP URL structure:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/profile[N]/media.smp
```

| Parameter | Value | Description |
| --- | --- | --- |
| `profile1` | Profile 1 | Typically configured as main stream |
| `profile2` | Profile 2 | Typically configured as sub stream |
| `profile3` | Profile 3 | Third stream (if configured) |

### Camera Models

| Model Series | Resolution | Main Stream URL | Audio |
| --- | --- | --- | --- |
| XNO-6080R (X 2MP bullet) | 1920x1080 | `rtsp://IP:554/profile2/media.smp` | Yes |
| XNO-8080R (X 5MP bullet) | 2560x1920 | `rtsp://IP:554/profile2/media.smp` | Yes |
| XNO-9080R (X 4K bullet) | 3840x2160 | `rtsp://IP:554/profile2/media.smp` | Yes |
| XND-6080 (X 2MP dome) | 1920x1080 | `rtsp://IP:554/profile2/media.smp` | Yes |
| XND-8080RV (X 5MP dome) | 2560x1920 | `rtsp://IP:554/profile2/media.smp` | Yes |
| XNP-6120H (X 2MP PTZ) | 1920x1080 | `rtsp://IP:554/profile2/media.smp` | Yes |
| PNO-A9081R (P 4K AI bullet) | 3840x2160 | `rtsp://IP:554/profile2/media.smp` | Yes |
| QNO-8080R (Q 5MP bullet) | 2560x1920 | `rtsp://IP:554/profile2/media.smp` | Yes |
| QND-8080R (Q 5MP dome) | 2560x1920 | `rtsp://IP:554/profile2/media.smp` | Yes |
| LNO-6032R (L 2MP bullet) | 1920x1080 | `rtsp://IP:554/profile2/media.smp` | No |

Profile Numbering

On most Hanwha Vision cameras, `profile2` is the main stream and `profile1` is reserved for internal use. If `profile2` does not work, try `profile1` or `profile3`. You can verify profile assignments in the camera's web interface under **Video Profile**.

### NVR Channel URLs

For Wisenet NVRs (XRN, QRN, LRN series):

| Channel | Main Stream | Sub Stream |
| --- | --- | --- |
| Camera 1 | `rtsp://IP:554/profile2/media.smp/trackID=channel1` | `rtsp://IP:554/profile3/media.smp/trackID=channel1` |
| Camera 2 | `rtsp://IP:554/profile2/media.smp/trackID=channel2` | `rtsp://IP:554/profile3/media.smp/trackID=channel2` |
| Camera N | `rtsp://IP:554/profile2/media.smp/trackID=channelN` | `rtsp://IP:554/profile3/media.smp/trackID=channelN` |

### Alternative URL Formats

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/profile2/media.smp` | Standard (recommended) |
| `rtsp://IP:554/profile1/media.smp` | First profile |
| `rtsp://IP:554/onvif-media/media.amp` | ONVIF media service |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Some OEM variants |

## Connecting with VisioForge SDK

Use your Hanwha Vision camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Hanwha Vision XNO-8080R (Wisenet X 5MP), main stream
var uri = new Uri("rtsp://192.168.1.90:554/profile2/media.smp");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `/profile3/media.smp` instead of `/profile2/media.smp`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/video.cgi?msubmenu=jpg&action=view&Resolution=1920x1080&Quality=5&Channel=0` | Full resolution snapshot |
| JPEG Snapshot (simple) | `http://IP/cgi-bin/snapshot.cgi` | Requires digest auth |
| MJPEG Stream | `http://IP/cgi-bin/video.cgi?msubmenu=mjpeg&action=view&Channel=0&Stream=0` | Continuous MJPEG |

## Troubleshooting

### profile2 vs profile1 confusion

Hanwha Vision cameras typically assign `profile2` as the main (highest quality) stream, which differs from most other brands that use profile/channel 1. If you get no video or low resolution from `profile2`, check the profile configuration in the camera's web interface under **Video Profile**.

### Password activation required

Current Hanwha Vision cameras ship without a default password. You must activate the camera and set a password through:

1. Wisenet Installation Wizard (IP Installer tool)
2. Web browser at `http://CAMERA_IP`
3. Wisenet mobile app

Older Samsung Techwin models used `admin` / `4321` as defaults.

### WiseStream II codec

WiseStream II is Hanwha's dynamic encoding technology that adjusts compression per-region in the frame. It produces standard H.265 or H.264 streams that are compatible with any decoder. No special codec is required.

### SUNAPI vs ONVIF

Hanwha Vision cameras support both their proprietary SUNAPI and standard ONVIF. For VisioForge SDK integration, use either the RTSP URLs above or ONVIF discovery. SUNAPI is primarily used by Hanwha's own VMS (SSM/Wisenet WAVE).

## FAQ

**What is the default RTSP URL for Hanwha Vision (Wisenet) cameras?**

The standard URL is `rtsp://admin:password@CAMERA_IP:554/profile2/media.smp` for the main stream. Use `profile3` for the sub stream. The profile numbers can be customized in the camera's web interface.

**Are Hanwha Vision and Samsung cameras the same?**

Hanwha Vision acquired Samsung's security camera division in 2015 (then called Samsung Techwin, later Hanwha Techwin, now Hanwha Vision). Current cameras are sold under the **Wisenet** brand. Legacy Samsung-branded cameras may use different URL patterns -- see our [Samsung/Hanwha guide](../samsung/).

**What is the difference between Wisenet X, P, Q, and L series?**

**X** = premium enterprise (best low-light, WDR). **P** = AI-powered (deep learning analytics). **Q** = mainstream business (good balance of features and price). **L** = value/entry-level (basic features, competitive pricing). **T** = thermal imaging.

**Do Hanwha Vision cameras support ONVIF?**

Yes. All current Hanwha Vision cameras support ONVIF Profile S, G, and T. ONVIF provides standardized discovery, streaming, and PTZ control.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Samsung/Hanwha Legacy Guide](../samsung/) — Older Samsung Techwin models
- [Wisenet Product Guide](../wisenet/) — Wisenet product family details
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Hikvision RTSP URL in C# .NET — IP Camera and NVR Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/hikvision/
**Description:** Hikvision RTSP URL format for DS-2CD, DS-2DE, and NVR models in C# .NET. ONVIF discovery, multi-channel streams, and VisioForge SDK integration guide.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Decoding, IP Camera, RTSP, ONVIF, H.265, MJPEG, C#
**API:** RTSPSourceProtocol

# How to Connect to Hikvision IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Hikvision** (Hangzhou Hikvision Digital Technology Co., Ltd.) is the world's largest manufacturer of video surveillance equipment by market share. Founded in 2001 and headquartered in Hangzhou, China, Hikvision produces IP cameras, DVRs, NVRs, and video management software used across enterprise, government, and consumer markets.

**Key facts:**

- **Product lines:** DS-2CD (fixed cameras), DS-2DE (PTZ cameras), DS-76/77/96 (NVRs), DS-7200/7300/7600 (DVRs)
- **Protocol support:** ONVIF Profile S/G/T, RTSP, HTTP, ISAPI
- **Default RTSP port:** 554
- **Default credentials:** admin / (set during initial setup; older firmware: admin / 12345)
- **ONVIF support:** Full -- recommended for automatic discovery and configuration
- **Video codecs:** H.264, H.265 (Smart Codec), MJPEG

## RTSP URL Patterns

Hikvision cameras use a channel-based URL structure. Channel numbers encode both the camera channel and the stream type.

### URL Format

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:[PORT]/Streaming/Channels/[CHANNEL_ID]
```

**Channel ID encoding:**

- Channel ID = (camera\_number \* 100) + stream\_number
- Stream 1 = main stream, Stream 2 = sub stream, Stream 3 = third stream
- Example: Camera 1, main stream = **101**; Camera 1, sub stream = **102**

### IP Cameras (Single Channel)

| Model Series | RTSP URL | Stream | Audio |
| --- | --- | --- | --- |
| DS-2CD2xx2 (2MP fixed) | `rtsp://IP:554/Streaming/Channels/101` | Main (1080p) | Yes |
| DS-2CD2xx2 (2MP fixed) | `rtsp://IP:554/Streaming/Channels/102` | Sub (CIF/D1) | Yes |
| DS-2CD2x32 (3MP fixed) | `rtsp://IP:554/Streaming/Channels/101` | Main (2048x1536) | Yes |
| DS-2CD2x32 (3MP fixed) | `rtsp://IP:554/Streaming/Channels/102` | Sub | Yes |
| DS-2CD21xx-I (value series) | `rtsp://IP:554/Streaming/Channels/1` | Main | Yes |
| DS-2CD21xx-I (value series) | `rtsp://IP:554/Streaming/Channels/2` | Sub | Yes |
| DS-2DE series (PTZ) | `rtsp://IP:554/Streaming/Channels/101` | Main | Yes |
| DS-2CD6362F (fisheye) | `rtsp://IP:554/Streaming/Channels/101` | Main (3072x2048) | Yes |

### NVR / DVR Channels

For NVR and DVR devices, change the camera number in the channel ID:

| Device | Channel | RTSP URL | Stream |
| --- | --- | --- | --- |
| NVR Camera 1 | 1 | `rtsp://IP:554/Streaming/Channels/101` | Main |
| NVR Camera 1 | 1 | `rtsp://IP:554/Streaming/Channels/102` | Sub |
| NVR Camera 2 | 2 | `rtsp://IP:554/Streaming/Channels/201` | Main |
| NVR Camera 2 | 2 | `rtsp://IP:554/Streaming/Channels/202` | Sub |
| NVR Camera 8 | 8 | `rtsp://IP:554/Streaming/Channels/801` | Main |
| DVR Channel 1 | 1 | `rtsp://IP:554/Streaming/Channels/101` | Main |

### Alternative URL Formats

Some older Hikvision models and OEM variants use different URL patterns:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/h264/ch1/main/av_stream` | Older firmware versions |
| `rtsp://IP:554/h264/ch1/sub/av_stream` | Older firmware, sub stream |
| `rtsp://IP:554/PSIA/Streaming/channels/101` | PSIA protocol (legacy) |
| `rtsp://IP:554/video.h264` | Some OEM models |
| `rtsp://IP:554/live.sdp` | Some older models |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` | Dahua-compatible OEM |
| `rtsp://IP:554/mpeg4` | MPEG4 stream (legacy) |

## Connecting with VisioForge SDK

Use your Hikvision camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Hikvision DS-2CD2032-I, main stream
var uri = new Uri("rtsp://192.168.1.64:554/Streaming/Channels/101");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `/Streaming/Channels/102` instead.

### ONVIF Discovery

Hikvision cameras have excellent ONVIF support. Use ONVIF to automatically discover cameras on your network and retrieve their stream URIs without manually constructing RTSP URLs. See the [ONVIF integration guide](../../mediablocks/Sources/) for discovery code examples.

## Snapshot and MJPEG URLs

Hikvision cameras also provide HTTP endpoints for snapshots and MJPEG streams:

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/ISAPI/Streaming/channels/101/picture` | Requires authentication |
| MJPEG Stream | `http://IP/ISAPI/Streaming/channels/102/httpPreview` | Sub stream as MJPEG |
| Legacy Snapshot | `http://IP/Streaming/channels/1/picture` | Older firmware |
| CGI Snapshot | `http://IP/cgi-bin/snapshot.cgi` | Basic authentication |

## Troubleshooting

### "Double slash" in URL path

Hikvision RTSP URLs use a path starting with `/Streaming/Channels/`. Some tools or code generate `//Streaming/Channels/` (double slash). Both work with Hikvision cameras, but use a single slash for correctness.

### Connection refused on port 554

- Verify RTSP is enabled in the camera's web interface: **Configuration > Network > Advanced Settings > RTSP**
- Check that the RTSP port hasn't been changed from the default (554)
- Ensure no firewall is blocking the port between your application and the camera

### Authentication failures

- Hikvision cameras require **digest authentication** by default. VisioForge SDK handles this automatically.
- On newer firmware, the default `admin/12345` credentials are disabled. You must set a strong password during initial setup via the Hikvision SADP tool or web interface.
- If connecting to an NVR, use the NVR credentials, not the individual camera credentials.

### H.265 stream not playing

- Ensure you have the HEVC decoder redistributable installed
- Alternatively, configure the camera to use H.264 encoding in its video settings
- Use `rtspSettings.UseGPUDecoder = true` for hardware-accelerated H.265 decoding

### High latency

- Use TCP transport: `rtspSettings.AllowedProtocols = RTSPSourceProtocol.TCP`
- Reduce buffer latency: `rtspSettings.Latency = TimeSpan.FromMilliseconds(200)`
- Switch to the sub stream (channel 102) for lower bandwidth requirements
- Disable audio if not needed: `audioEnabled: false`

Combined on a single `RTSPSourceSettings` instance (constructed via the async factory):

```
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    uri: new Uri("rtsp://192.168.1.100:554/Streaming/Channels/102"),  // sub stream
    login: "admin",
    password: "password",
    audioEnabled: false);

rtspSettings.UseGPUDecoder    = true;                        // hardware-accelerated H.265
rtspSettings.AllowedProtocols = RTSPSourceProtocol.TCP;      // TCP transport
rtspSettings.Latency          = TimeSpan.FromMilliseconds(200);
```

## FAQ

**What is the default RTSP URL for Hikvision cameras?**

The standard RTSP URL for Hikvision cameras is `rtsp://admin:password@CAMERA_IP:554/Streaming/Channels/101` for the main stream. Replace `admin` and `password` with your camera credentials, and `CAMERA_IP` with the camera's IP address. Use channel `102` for the sub stream.

**How do I find my Hikvision camera's IP address?**

Use the Hikvision SADP (Search Active Devices Protocol) tool, which is a free utility that discovers all Hikvision devices on your local network. Alternatively, check your router's DHCP client list or use ONVIF device discovery with the VisioForge SDK.

**Can I connect to a Hikvision NVR and view individual camera channels?**

Yes. Use the same RTSP URL format but change the channel number. Camera 1 is channel 101 (main) or 102 (sub), camera 2 is channel 201/202, and so on. The formula is: channel ID = (camera\_number x 100) + stream\_number.

**Does VisioForge SDK support Hikvision's H.265+ (Smart Codec)?**

Yes. The SDK supports standard H.265/HEVC decoding. Hikvision's H.265+ is a proprietary compression optimization that produces standard H.265 streams, so it works with any H.265-capable decoder.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [LTS Connection Guide](../lts/) — Hikvision OEM, uses same URL format
- [EZVIZ Connection Guide](../ezviz/) — Hikvision consumer brand
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Honeywell IP Camera RTSP URL Guide for C# .NET Apps
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/honeywell/
**Description:** Connect to Honeywell Performance Series and equIP cameras in C# .NET with RTSP URL patterns and code samples for HD, HDZ, HBD, HBW, and PSIA models.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, H.265, MJPEG, C#

# How to Connect to Honeywell IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Honeywell Commercial Security** (part of Honeywell Building Technologies) is a major manufacturer of enterprise video surveillance equipment. Honeywell cameras are widely deployed in commercial buildings, critical infrastructure, government facilities, and transportation systems worldwide. Honeywell acquired several camera brands over the years including **Samsung Techwin** (briefly) and markets cameras under the **Performance Series**, **30 Series**, and **60 Series** product lines.

**Key facts:**

- **Product lines:** Performance Series (equIP, H-series), 30 Series (HC30W, HC35W), 60 Series (HC60W), HDZ/HD (legacy equIP), HBD/HBW (bullet/dome), IPCAM (consumer)
- **Protocol support:** RTSP, ONVIF (Profile S/G/T), PSIA, HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** admin / 1234 (Performance Series); admin / admin (legacy models); varies by model and firmware
- **ONVIF support:** Yes (all current Performance Series and 30/60 Series models)
- **Video codecs:** H.264, H.265 (current models), MPEG-4 (legacy)

## RTSP URL Patterns

### Current Models (Performance Series, 30/60 Series)

| Stream | RTSP URL | Codec | Notes |
| --- | --- | --- | --- |
| Main stream (H.264) | `rtsp://IP:554/h264` | H.264 | Primary stream |
| Main stream (H.265) | `rtsp://IP:554/h265` | H.265 | Current models only |
| Channel stream (H.264) | `rtsp://IP:554/cam1/h264` | H.264 | Channel-specific |
| Channel stream (MPEG-4) | `rtsp://IP:554/cam1/mpeg4` | MPEG-4 | Legacy fallback |
| PSIA stream | `rtsp://IP:554/PSIA/Streaming/channels/1` | H.264 | PSIA-compatible |

### Model-Specific URLs

| Model Series | RTSP URL | Resolution | Notes |
| --- | --- | --- | --- |
| HC30W/HC35W (30 Series) | `rtsp://IP:554/h264` | Up to 5MP | Current Wi-Fi |
| HC60W (60 Series) | `rtsp://IP:554/h264` | Up to 4K | Current wired |
| HD45IP | `rtsp://IP:554/h264` | 1080p | equIP dome |
| HD54IP | `rtsp://IP:554/h264` | 1080p | equIP box |
| HD55IPX | `rtsp://IP:554/h264` | 1080p+ | equIP box |
| HDZ20HDEX/HDZ20HDX | `rtsp://IP:554/h264` | 1080p | equIP PTZ |
| HD4MDIP | `rtsp://IP:554/cam1/mpeg4` | 720p | Multi-channel |
| HDM3DIP | `rtsp://IP:554/cam1/mpeg4` | 720p | Mini dome |
| HBD/HBW series | `rtsp://IP:554/h264` | Up to 4MP | Bullet/dome |

### PSIA Streaming

Honeywell cameras that support **PSIA (Physical Security Interoperability Alliance)** use a different URL format:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Channel 1 | `rtsp://IP:554/PSIA/Streaming/channels/1` | First channel |
| Channel 2 | `rtsp://IP:554/PSIA/Streaming/channels/2` | Second channel |

### Legacy Models (HTTP Only)

Older Honeywell consumer cameras (IPCAM series) use HTTP:

| Model | URL | Notes |
| --- | --- | --- |
| IPCAM / IPCAM-PT | `http://IP/img/snapshot.cgi?size=3` | JPEG snapshot |
| IPCAM-PT | `http://IP/img/video.mjpeg` | MJPEG stream |
| IPCAM-PT | `http://IP/img/video.asf` | ASF stream (audio) |
| IPCAM-OD / IPCAM-W12 | `http://IP/img/video.mjpeg` | MJPEG stream |
| IPCAM-OD / IPCAM-W12 | `http://IP/img/video.asf` | ASF stream (audio) |

## Connecting with VisioForge SDK

Use your Honeywell camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Honeywell Performance Series camera, main stream
var uri = new Uri("rtsp://192.168.1.75:554/h264");
var username = "admin";
var password = "YourPassword";
```

For PSIA channel streams, use `/PSIA/Streaming/channels/1` instead. For multi-channel models, use `/cam1/h264` format.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/img/snapshot.cgi?size=3` | Most models |
| MJPEG Stream | `http://IP/img/video.mjpeg` | Continuous MJPEG |
| ASF Stream | `http://IP/img/video.asf` | ASF with audio |
| HREP Snapshot | `http://IP/cgi-bin/webra_fcgi.fcgi?api=get_jpeg_raw&chno=1` | NVR channel snapshot |

## Troubleshooting

### RTSP URL format

Honeywell cameras use a simple RTSP URL format compared to other brands:

- Primary: `rtsp://IP:554/h264` (no complex paths)
- Multi-channel: `rtsp://IP:554/cam1/h264` (channel number in path)
- PSIA: `rtsp://IP:554/PSIA/Streaming/channels/1` (PSIA standard)

If `/h264` doesn't work, try `/cam1/h264` or the PSIA URL.

### Default credentials vary

Honeywell has used different default credentials across product lines:

- **Performance Series:** admin / 1234 (must be changed on first login)
- **30/60 Series:** Set during initial setup (no default)
- **Legacy equIP:** admin / admin
- **IPCAM series:** admin / (empty) or admin / admin

### PSIA vs ONVIF

Honeywell cameras support both PSIA and ONVIF protocols:

- **ONVIF** is recommended for new integrations (wider compatibility)
- **PSIA** is Honeywell's legacy interoperability standard, still supported on most models
- Both provide the same video streams via different discovery and configuration mechanisms

## FAQ

**What is the default RTSP URL for Honeywell cameras?**

For most current Honeywell cameras, use `rtsp://admin:password@CAMERA_IP:554/h264`. For multi-channel models, use `rtsp://admin:password@CAMERA_IP:554/cam1/h264`. PSIA-compatible cameras also respond to `/PSIA/Streaming/channels/1`.

**Do Honeywell cameras support ONVIF?**

Yes. All current Honeywell Performance Series, 30 Series, and 60 Series cameras support ONVIF Profile S (streaming), Profile G (recording), and Profile T (advanced streaming). Legacy equIP models may only support ONVIF Profile S.

**What is PSIA on Honeywell cameras?**

PSIA (Physical Security Interoperability Alliance) is an alternative to ONVIF for device interoperability. Honeywell has historically supported PSIA alongside ONVIF. PSIA streams use the URL format `rtsp://IP:554/PSIA/Streaming/channels/1`.

**Are Honeywell IPCAM models still supported?**

The IPCAM consumer series is discontinued. These cameras only support HTTP MJPEG/JPEG and do not have RTSP. For IPCAM models, use the HTTP snapshot URL `http://IP/img/snapshot.cgi?size=3` or MJPEG stream `http://IP/img/video.mjpeg`.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Bosch Connection Guide](../bosch/) — Enterprise / commercial segment peer
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Imou IP Camera in C# .NET — RTSP & ONVIF Setup Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/imou/
**Description:** Connect Imou cameras (Cruiser, Ranger, Bullet, Cell) to C# / .NET apps via RTSP/ONVIF. Default credentials, stream URLs, H.264/H.265 configs. Sample code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, H.265, MJPEG, C#

# How to Connect to Imou IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Imou** (pronounced "ee-moo") is a consumer smart home and security camera brand owned by **Dahua Technology**. Launched in 2019, Imou targets the consumer and small business market with WiFi cameras, battery cameras, doorbells, and home security kits. Imou cameras use Dahua firmware and RTSP URL patterns.

**Key facts:**

- **Product lines:** Cruiser (outdoor PT), Ranger (indoor PT), Bullet (fixed outdoor), Cell (battery), Versa (versatile), Rex (indoor)
- **Protocol support:** RTSP (must be enabled on some models), ONVIF (select models), Imou Life cloud
- **Default RTSP port:** 554
- **Default credentials:** admin / admin (or admin / imou + serial number suffix)
- **ONVIF support:** Yes (most wired models)
- **Video codecs:** H.264, H.265 (select models)
- **Parent company:** Dahua Technology

Imou = Dahua Consumer Brand

Imou cameras use Dahua firmware and the same `cam/realmonitor` RTSP URL format as Dahua cameras. See our [Dahua connection guide](../dahua/) for additional details.

## RTSP URL Patterns

### Standard URL Format

Imou cameras use the Dahua `cam/realmonitor` URL pattern:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/cam/realmonitor?channel=1&subtype=0
```

| Parameter | Value | Description |
| --- | --- | --- |
| `channel` | 1 | Camera channel (always 1 for standalone cameras) |
| `subtype` | 0 | Main stream (highest resolution) |
| `subtype` | 1 | Sub stream (lower resolution, less bandwidth) |

### Camera Models

| Model | Type | Main Stream URL | Audio |
| --- | --- | --- | --- |
| Cruiser SE+ 4MP | Outdoor PTZ | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| Cruiser 2E 4MP | Outdoor PTZ | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| Ranger 2 (IPC-A22EP) | Indoor PTZ | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| Ranger SE 4MP | Indoor PTZ | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| Rex 3D (IPC-GS7EP) | Indoor PTZ | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| Bullet 2E (IPC-F22FP) | Outdoor fixed | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| Bullet 2S (IPC-F26FP) | Outdoor fixed | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| Versa 4MP | Indoor/outdoor | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| Cell 2 | Battery outdoor | Limited — see note | Yes |
| Cell Go | Battery mini | No RTSP | No |

Battery Models

Imou battery-powered cameras (Cell series) have limited or no RTSP support. The Cell 2 may support RTSP when connected to the Imou Base Station, but the Cell Go and other battery mini cameras are cloud-only devices.

### Alternative URL Formats

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Standard (recommended) |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0&unicast=true` | Force unicast |
| `rtsp://IP:554/live` | Simple path (some models) |

## Connecting with VisioForge SDK

Use your Imou camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Imou Cruiser SE+ 4MP, main stream
var uri = new Uri("rtsp://192.168.1.90:554/cam/realmonitor?channel=1&subtype=0");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `subtype=1` instead of `subtype=0`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/snapshot.cgi?channel=1` | Requires basic auth |
| MJPEG Stream | `http://IP/cgi-bin/mjpg/video.cgi?channel=1&subtype=1` | Continuous MJPEG |

## Troubleshooting

### RTSP not accessible

Some Imou cameras require RTSP to be enabled through the Imou Life app:

1. Open **Imou Life** app → select your camera
2. Go to **Settings > Advanced Settings > RTSP**
3. Enable RTSP and note the password (may differ from app password)

### Default credentials

Imou password defaults vary by model and firmware:

- `admin` / `admin` (common on older models)
- `admin` / specific code (check camera label)
- Custom password set during Imou Life app setup

If RTSP login fails, check the RTSP password in the Imou Life app settings.

### WiFi camera IP address

Imou WiFi cameras get their IP from your router via DHCP. Find the camera's local IP in:

1. The Imou Life app → Device Info
2. Your router's DHCP client list
3. ONVIF discovery (if supported)

### Dahua web interface

Some Imou cameras expose the Dahua web interface at `http://CAMERA_IP`. This provides additional configuration options beyond the Imou Life app, including RTSP settings, video encoding, and network configuration.

## FAQ

**What is the default RTSP URL for Imou cameras?**

The standard URL is `rtsp://admin:password@CAMERA_IP:554/cam/realmonitor?channel=1&subtype=0` for the main stream. This is the same format as Dahua cameras. RTSP may need to be enabled in the Imou Life app first.

**Is Imou the same as Dahua?**

Imou is a consumer brand owned by Dahua Technology. Imou cameras use Dahua firmware and the same RTSP URL format (`cam/realmonitor`). The main differences are branding, consumer-focused features, and cloud service integration.

**Can I use Imou cameras without the cloud?**

Partially. You can access RTSP streams locally without the Imou cloud for live viewing and recording. However, initial camera setup requires the Imou Life app. Cloud-dependent features like smart alerts, cloud storage, and remote access require an Imou subscription.

**Do Imou cameras support ONVIF?**

Most wired and WiFi-connected Imou cameras support ONVIF. Battery-powered models generally do not. Check your camera's specifications in the Imou Life app.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Dahua Connection Guide](../dahua/) — Parent company, identical URL format
- [Amcrest Connection Guide](../amcrest/) — Another Dahua OEM brand
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## IP Camera RTSP URL Directory - Connect Any Camera in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/
**Description:** Complete RTSP URL directory for 62 IP camera brands. Connect Hikvision, Dahua, Axis, Uniview, EZVIZ, Wisenet, Arlo and more using VisioForge .NET SDK.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming
**API:** VideoCaptureCoreX, VideoCaptureCore, RTSPSourceSettings, IVideoView, IPCameraSourceSettings

# IP Camera Connection Guide by Brand

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Connecting to IP cameras in C# .NET is straightforward when you know the right RTSP URL pattern for your camera brand. Each manufacturer uses slightly different URL formats, ports, and authentication methods.

This directory provides **brand-specific RTSP URL patterns**, connection code samples using VisioForge SDK, and troubleshooting tips for the most popular IP camera manufacturers.

## How RTSP Camera Connections Work

Most modern IP cameras expose video streams via the **RTSP (Real-Time Streaming Protocol)** on port 554. The general connection flow is:

1. Determine your camera's IP address (via ONVIF discovery, DHCP lease table, or manufacturer utility)
2. Construct the RTSP URL using the brand-specific pattern
3. Authenticate with camera credentials
4. Connect and render the video stream

### Quick Start Code

Connect to any RTSP camera using one of three VisioForge SDK approaches:

VideoCaptureCoreXVideoCaptureCoreMedia Blocks

```
// Initialize SDK (call once at app startup)
await VisioForgeX.InitSDKAsync();

var videoCapture = new VideoCaptureCoreX(VideoView1);

// Create RTSP source
var rtsp = await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.100:554/stream1"),
    "admin",
    "password",
    true); // capture audio

videoCapture.Video_Source = rtsp;

await videoCapture.StartAsync();
```

```
var videoCapture = new VideoCaptureCore(VideoView1 as IVideoView);

videoCapture.IP_Camera_Source = new IPCameraSourceSettings()
{
    URL = new Uri("rtsp://admin:password@192.168.1.100:554/stream1"),
    Type = IPSourceEngine.Auto_LAV
};

videoCapture.Audio_PlayAudio = true;
videoCapture.Audio_RecordAudio = false;
videoCapture.Mode = VideoCaptureMode.IPPreview;

await videoCapture.StartAsync();
```

```
var pipeline = new MediaBlocksPipeline();

var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.100:554/stream1"),
    "admin",
    "password",
    audioEnabled: true);

rtspSettings.AllowedProtocols = RTSPSourceProtocol.TCP;

var rtspSource = new RTSPSourceBlock(rtspSettings);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
var audioRenderer = new AudioRendererBlock();

pipeline.Connect(rtspSource.VideoOutput, videoRenderer.Input);
pipeline.Connect(rtspSource.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

Replace the RTSP URL with your brand-specific pattern from the pages below.

### Which SDK Should I Choose?

| SDK | Best For | Platforms |
| --- | --- | --- |
| **VideoCaptureCoreX** | New cross-platform projects, modern .NET | Windows, macOS, Linux, Android, iOS |
| **VideoCaptureCore** | Windows-only projects, legacy .NET Framework | Windows |
| **Media Blocks** | Advanced pipelines, custom processing chains | Windows, macOS, Linux, Android, iOS |

**VideoCaptureCoreX** is recommended for most new projects. Use **Media Blocks** when you need to build custom processing pipelines with multiple sources, filters, or outputs.

## Camera Brands

### Featured Brands (Full Guides)

| Brand | Headquarters | Market Segment | Guide |
| --- | --- | --- | --- |
| **Hikvision** | Hangzhou, China | Enterprise / Consumer | [Connection Guide](hikvision/) |
| **Dahua** | Hangzhou, China | Enterprise / Consumer | [Connection Guide](dahua/) |
| **Axis** | Lund, Sweden | Enterprise / Professional | [Connection Guide](axis/) |
| **Reolink** | Hong Kong | Consumer / Prosumer | [Connection Guide](reolink/) |
| **Amcrest** | Houston, USA | Consumer / SMB | [Connection Guide](amcrest/) |
| **Samsung/Hanwha** | Grasbrunn, Germany / Seoul, South Korea | Enterprise / Professional | [Connection Guide](samsung/) |
| **Bosch** | Grasbrunn, Germany | Enterprise / Critical Infrastructure | [Connection Guide](bosch/) |
| **Ubiquiti** | New York, USA | Prosumer / SMB | [Connection Guide](ubiquiti/) |
| **Foscam** | Shenzhen, China | Consumer / SMB | [Connection Guide](foscam/) |
| **TP-Link** | Shenzhen, China | Consumer / SMB | [Connection Guide](tp-link/) |
| **Vivotek** | New Taipei City, Taiwan | Enterprise / Professional | [Connection Guide](vivotek/) |
| **Panasonic/i-PRO** | Tokyo, Japan | Enterprise / Government | [Connection Guide](panasonic/) |
| **Sony** | Tokyo, Japan | Enterprise (discontinued 2020) | [Connection Guide](sony/) |
| **Lorex** | Markham, Canada | Consumer / Prosumer | [Connection Guide](lorex/) |
| **D-Link** | Taipei, Taiwan | Consumer / SMB | [Connection Guide](dlink/) |
| **Honeywell** | Charlotte, USA | Enterprise / Commercial | [Connection Guide](honeywell/) |
| **Pelco** | Fresno, USA (Motorola Solutions) | Enterprise / Government | [Connection Guide](pelco/) |
| **Cisco** | San Jose, USA | Enterprise / Consumer-SMB (legacy) | [Connection Guide](cisco/) |
| **Grandstream** | Boston, USA | SMB / Professional | [Connection Guide](grandstream/) |
| **Swann** | Melbourne, Australia | Consumer / Prosumer | [Connection Guide](swann/) |
| **GeoVision** | Taipei, Taiwan | Enterprise / Professional | [Connection Guide](geovision/) |
| **ACTi** | Taipei, Taiwan | Professional / Enterprise | [Connection Guide](acti/) |
| **Canon** | Tokyo, Japan | Professional / Enterprise | [Connection Guide](canon/) |
| **FLIR (Teledyne)** | Wilsonville, USA | Enterprise / Thermal | [Connection Guide](flir/) |
| **Milesight** | Xiamen, China | Professional / SMB | [Connection Guide](milesight/) |
| **INSTAR** | Hanau, Germany | Consumer / Smart Home | [Connection Guide](instar/) |
| **Zmodo** | Shenzhen, China | Consumer / Budget | [Connection Guide](zmodo/) |
| **Arecont Vision** | Glendale, USA (Costar Group) | Professional / Enterprise | [Connection Guide](arecont/) |
| **JVC** | Yokohama, Japan | Professional (discontinued ~2015) | [Connection Guide](jvc/) |
| **Toshiba** | Tokyo, Japan | Enterprise (discontinued) | [Connection Guide](toshiba/) |
| **LG** | Seoul, South Korea | Enterprise (discontinued) | [Connection Guide](lg/) |
| **Linksys** | Irvine, USA | Consumer (discontinued ~2014) | [Connection Guide](linksys/) |
| **LTS** | City of Industry, USA | Professional (Hikvision OEM) | [Connection Guide](lts/) |
| **Q-See** | Anaheim, USA | Consumer (defunct ~2020) | [Connection Guide](q-see/) |
| **Speco Technologies** | Amityville, USA | Professional | [Connection Guide](speco/) |
| **EverFocus** | New Taipei City, Taiwan | Professional | [Connection Guide](everfocus/) |
| **ABUS** | Wetter, Germany | Consumer / Professional | [Connection Guide](abus/) |
| **Basler** | Ahrensburg, Germany | Machine Vision / Industrial | [Connection Guide](basler/) |
| **Mobotix** | Langmeil, Germany (Konica Minolta) | Industrial / Critical Infrastructure | [Connection Guide](mobotix/) |
| **Avigilon** | Vancouver, Canada (Motorola Solutions) | Enterprise / Critical Infrastructure | [Connection Guide](avigilon/) |
| **AVTech** | Taipei, Taiwan | Commercial / Industrial | [Connection Guide](avtech/) |
| **LILIN** | New Taipei City, Taiwan | Professional / Enterprise | [Connection Guide](lilin/) |
| **Zavio** | Hsinchu, Taiwan | Professional / SMB | [Connection Guide](zavio/) |
| **CP Plus** | Delhi, India | Enterprise / Commercial | [Connection Guide](cp-plus/) |
| **Sanyo** | Osaka, Japan (now Panasonic) | Professional (discontinued) | [Connection Guide](sanyo/) |
| **BrickCom** | Taipei, Taiwan | Professional / Industrial | [Connection Guide](brickcom/) |
| **Edimax** | Taipei, Taiwan | Consumer / SMB | [Connection Guide](edimax/) |
| **Uniview (UNV)** | Hangzhou, China | Enterprise / Government | [Connection Guide](uniview/) |
| **Hanwha Vision** | Seoul, South Korea | Enterprise / Professional | [Connection Guide](hanwha/) |
| **Tiandy** | Tianjin, China | Enterprise / SMB | [Connection Guide](tiandy/) |
| **EZVIZ** | Hangzhou, China (Hikvision) | Consumer / Smart Home | [Connection Guide](ezviz/) |
| **Wisenet** | Seoul, South Korea (Hanwha Vision) | Enterprise / Professional | [Connection Guide](wisenet/) |
| **Annke** | Hong Kong | Consumer / Prosumer | [Connection Guide](annke/) |
| **Imou** | Hangzhou, China (Dahua) | Consumer / Smart Home | [Connection Guide](imou/) |
| **Wyze** | Kirkland, USA | Consumer (limited RTSP) | [Connection Guide](wyze/) |
| **Aqara** | Shenzhen, China | Smart Home / HomeKit | [Connection Guide](aqara/) |
| **Verkada** | San Mateo, USA | Enterprise / Cloud-managed | [Connection Guide](verkada/) |
| **Rhombus** | Sacramento, USA | Enterprise / Cloud-managed | [Connection Guide](rhombus/) |
| **Arlo** | Carlsbad, USA | Consumer (no RTSP) | [Connection Guide](arlo/) |
| **Eufy Security** | Changsha, China (Anker) | Consumer / Smart Home | [Connection Guide](eufy/) |
| **Tenda** | Shenzhen, China | Consumer / Budget | [Connection Guide](tenda/) |
| **Mercusys** | Shenzhen, China (TP-Link) | Consumer / Budget | [Connection Guide](mercusys/) |

### Common RTSP URL Patterns by Brand

For quick reference, here are the primary RTSP URL patterns for popular camera brands:

| Brand | Primary RTSP URL Pattern | Default Port |
| --- | --- | --- |
| Hikvision | `rtsp://IP:554/Streaming/Channels/101` | 554 |
| Dahua | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | 554 |
| Axis | `rtsp://IP:554/axis-media/media.amp` | 554 |
| Foscam | `rtsp://IP:88/videoMain` | 88 |
| TP-Link (Tapo) | `rtsp://IP:554/stream1` | 554 |
| Amcrest | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | 554 |
| Reolink | `rtsp://IP:554/h264Preview_01_main` | 554 |
| Ubiquiti | `rtsp://IP:7447/STREAM_TOKEN` | 7447 |
| Samsung/Hanwha | `rtsp://IP:554/profile2/media.smp` | 554 |
| Bosch | `rtsp://IP:554/video?inst=1` | 554 |
| Vivotek | `rtsp://IP:554/live.sdp` | 554 |
| Panasonic/i-PRO | `rtsp://IP:554/MediaInput/h264` | 554 |
| Sony | `rtsp://IP:554/media/video1` | 554 |
| Lorex | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | 554 |
| D-Link | `rtsp://IP:554/live1.sdp` | 554 |
| Honeywell | `rtsp://IP:554/h264` | 554 |
| Pelco | `rtsp://IP:554//stream1` | 554 |
| Cisco | `rtsp://IP:554/img/media.sav` | 554 |
| Grandstream | `rtsp://IP:554/live/ch00_0` | 554 |
| Swann | `rtsp://IP:554/live/h264` | 554 |
| GeoVision | `rtsp://IP:8554//CH001.sdp` | 8554 |
| ACTi | `rtsp://IP:7070//stream1` | 7070 |
| Canon | `rtsp://IP:554/cam1/h264` | 554 |
| FLIR (Teledyne) | `rtsp://IP:554/ch0` | 554 |
| Milesight | `rtsp://IP:554//main` | 554 |
| INSTAR | `rtsp://IP:554//11` | 554 |
| Zmodo | `rtsp://IP:10554//tcp/av0_0` | 10554 |
| Arecont Vision | `rtsp://IP:554/h264.sdp` | 554 |
| JVC | `rtsp://IP:554/PSIA/Streaming/channels/0` | 554 |
| Toshiba | `rtsp://IP:554/live.sdp` | 554 |
| LG | `rtsp://IP:554/video1+audio1` | 554 |
| Linksys | `rtsp://IP:554/img/media.sav` | 554 |
| LTS | `rtsp://IP:554//Streaming/Channels/1` | 554 |
| Q-See | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` | 554 |
| Speco | `rtsp://IP:554/1/stream1` | 554 |
| EverFocus | `rtsp://IP:554//cgi-bin/rtspStreamOvf/0` | 554 |
| ABUS | `rtsp://IP:554/video.mp4` | 554 |
| Basler | `rtsp://IP:554/h264` | 554 |
| Mobotix | `rtsp://IP:554/mobotix.h264` | 554 |
| Avigilon | `rtsp://IP:554/defaultPrimary?streamType=u` | 554 |
| AVTech | `rtsp://IP:554/live/h264` | 554 |
| LILIN | `rtsp://IP:554/rtsph2641080p` | 554 |
| Zavio | `rtsp://IP:554/video.mp4` | 554 |
| CP Plus | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` | 554 |
| Sanyo | `rtsp://IP:554/VideoInput/1/h264/1` | 554 |
| BrickCom | `rtsp://IP:554/channel1` | 554 |
| Edimax | `rtsp://IP:554/ipcam_h264.sdp` | 554 |
| Uniview (UNV) | `rtsp://IP:554/media/video1` | 554 |
| Hanwha Vision | `rtsp://IP:554/profile2/media.smp` | 554 |
| Tiandy | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | 554 |
| EZVIZ | `rtsp://IP:554/h264/ch1/main/av_stream` | 554 |
| Wisenet | `rtsp://IP:554/profile2/media.smp` | 554 |
| Annke | `rtsp://IP:554/Streaming/Channels/101` | 554 |
| Imou | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | 554 |
| Wyze | `rtsp://IP:8554/live` | 8554 |
| Aqara | `rtsp://IP:554/live/ch00_1` | 554 |
| Verkada | N/A (cloud-only) | N/A |
| Rhombus | `rtsp://IP:554/live` (if enabled) | 554 |
| Arlo | N/A (no RTSP) | N/A |
| Eufy Security | `rtsp://IP:554/live0` | 554 |
| Tenda | `rtsp://IP:554/stream1` | 554 |
| Mercusys | `rtsp://IP:554/stream1` | 554 |

## ONVIF Discovery

Most modern IP cameras support **ONVIF (Open Network Video Interface Forum)**, which allows automatic camera discovery on your network. VisioForge SDK supports ONVIF discovery -- see our [ONVIF integration guide](../mediablocks/Sources/) for details.

## Get Started

### Install via NuGet

Cross-platform (recommended)Windows-only (legacy DirectShow engine)

```
dotnet add package VisioForge.DotNet.VideoCapture
dotnet add package VisioForge.CrossPlatform.Core.Windows.x64
```

Swap the second package for the native runtime of your target OS — `VisioForge.CrossPlatform.Core.Linux.x64`, `.macOS`, `.Android` or `.iOS`.

```
dotnet add package VisioForge.DotNet.VideoCapture
dotnet add package VisioForge.DotNet.Core.Redist.VideoCapture.x64
```

### Sample Projects

Complete working examples for IP camera integration:

- [IP Camera Preview (WinForms)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/_CodeSnippets/ip-camera-preview) — Live camera view
- [IP Camera Recording to MP4](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/_CodeSnippets/ip-camera-capture-mp4) — Record streams to file
- [All .NET SDK Samples](https://github.com/visioforge/.Net-SDK-s-samples) — Full sample repository

## Related Resources

- [RTSP Source Block Documentation](../mediablocks/Sources/)
- [IP Camera Preview Tutorial](../videocapture/video-tutorials/ip-camera-preview/)
- [IP Camera Recording to MP4](../videocapture/video-tutorials/ip-camera-capture-mp4/)
- [Building Camera Applications with Media Blocks](../mediablocks/GettingStarted/camera/)
- [Device Enumeration Guide](../mediablocks/GettingStarted/device-enum/)

---END OF PAGE---


## INSTAR IP Camera RTSP URL and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/instar/
**Description:** INSTAR IN-6xxx, IN-7xxx, IN-8xxx, IN-9xxx HD camera RTSP URL patterns for C# .NET. Stream and record with VisioForge Video Capture SDK integration.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MJPEG, C#

# How to Connect to INSTAR IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**INSTAR** (INSTAR Deutschland GmbH) is a German IP camera manufacturer headquartered in Hanau, Germany. INSTAR specializes in affordable indoor and outdoor IP cameras for the consumer and small business market, with a strong presence in Europe, particularly Germany. INSTAR cameras are known for local storage options, MQTT smart home integration (Home Assistant, ioBroker, Node-RED), and straightforward setup.

**Key facts:**

- **Product lines:** IN-2xxx/3xxx/4xxx (legacy VGA), IN-5xxx (720p), IN-6xxx (720p HD), IN-7xxx (1080p Full HD), IN-8xxx (current 1080p+), IN-9xxx (current 4K/WQHD)
- **Protocol support:** RTSP, HTTP, ONVIF (IN-6xxx and newer), MQTT
- **Default RTSP port:** 554
- **Default credentials:** admin / instar (varies by model)
- **ONVIF support:** Yes (IN-6xxx, IN-7xxx, IN-8xxx, IN-9xxx series)
- **Video codecs:** H.265 (IN-9xxx), H.264 (IN-6xxx/7xxx/8xxx), MPEG-4 (IN-5xxx), MJPEG (legacy IN-2xxx/3xxx/4xxx)

## RTSP URL Patterns

INSTAR cameras use a distinctive URL format with a **double forward slash** before the stream number.

### URL Format (HD Models)

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554//11
```

Double forward slash

INSTAR HD cameras use a **double forward slash** (`//`) before the stream number. Using a single slash will result in a connection failure.

### HD Models (IN-6xxx / IN-7xxx / IN-8xxx / IN-9xxx)

| Stream | RTSP URL | Resolution | Notes |
| --- | --- | --- | --- |
| Main stream | `rtsp://IP:554//11` | Full resolution | H.264 / H.265 |
| Sub stream | `rtsp://IP:554//12` | Lower resolution | Bandwidth-friendly |
| Third stream | `rtsp://IP:554//13` | Mobile optimized | Lowest resolution |

### Model-Specific URLs

| Model | RTSP URL | Resolution | Type |
| --- | --- | --- | --- |
| IN-6012 HD | `rtsp://IP:554//11` | 720p | Indoor pan/tilt |
| IN-6014 HD | `rtsp://IP:554//11` | 720p | Indoor |
| IN-7011 HD | `rtsp://IP:554//11` | 1080p | Indoor pan/tilt |
| IN-8015 Full HD | `rtsp://IP:554//11` | 1080p | Indoor/Outdoor |
| IN-9008 Full HD | `rtsp://IP:554//11` | 1080p+ | Outdoor PoE |
| IN-9020 Full HD | `rtsp://IP:554//11` | WQHD/4K | Outdoor PoE |

### Older 720p Models (IN-5xxx -- MPEG-4)

IN-5xxx cameras use a different RTSP path with MPEG-4 encoding:

| Model | RTSP URL | Resolution | Notes |
| --- | --- | --- | --- |
| IN-5905 HD | `rtsp://IP:554/MediaInput/mpeg4` | 720p | Outdoor |
| IN-5907 HD | `rtsp://IP:554/MediaInput/mpeg4` | 720p | Outdoor |

### Legacy Models (IN-2xxx / IN-3xxx / IN-4xxx -- HTTP Only)

Legacy VGA-resolution INSTAR cameras do not support RTSP. They use HTTP-based streaming only:

| Model Series | HTTP URL | Type | Notes |
| --- | --- | --- | --- |
| IN-2xxx/3xxx/4xxx | `http://IP/videostream.asf?user=USER&pwd=PASS&resolution=32&rate=0` | ASF stream | VGA resolution |
| IN-2xxx/3xxx/4xxx | `http://IP/videostream.cgi?rate=11` | MJPEG | No audio |
| IN-2xxx/3xxx/4xxx | `http://IP//iphone/11?USER:PASS&` | Mobile stream | iPhone-compatible |

## Connecting with VisioForge SDK

Use your INSTAR camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// INSTAR IN-8015 Full HD, main stream -- note the double forward slash!
var uri = new Uri("rtsp://192.168.1.50:554//11");
var username = "admin";
var password = "instar";
```

For sub-stream access, use `//12` instead of `//11`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| Snapshot (HD) | `http://IP/tmpfs/auto.jpg` | IN-6xxx/7xxx/8xxx/9xxx |
| Snapshot (HD, auth) | `http://IP/snap.jpg?usr=USER&pwd=PASS` | With credentials |
| Snapshot (legacy) | `http://IP/snapshot.cgi` | IN-2xxx/3xxx/4xxx |
| Snapshot (legacy, auth) | `http://IP/snapshot.jpg?user=USER&pwd=PASS` | Legacy with credentials |
| ASF Stream (legacy) | `http://IP/videostream.asf?user=USER&pwd=PASS&resolution=32&rate=0` | VGA ASF |
| MJPEG Stream (legacy) | `http://IP/videostream.cgi?rate=11` | Legacy MJPEG |

## Troubleshooting

### Double forward slash is required

The most common INSTAR connection issue is forgetting the **double forward slash** before the stream number. The correct URL is `rtsp://IP:554//11` (two slashes), not `rtsp://IP:554/11` (one slash).

### Legacy cameras have no RTSP support

IN-2xxx, IN-3xxx, and IN-4xxx cameras are HTTP-only. They do not support RTSP at all. Use the ASF or MJPEG HTTP streaming URLs for these models.

### IN-5xxx uses a different RTSP path

IN-5xxx cameras use `rtsp://IP:554/MediaInput/mpeg4` instead of the `//11` path used by newer HD models. If the `//11` URL fails on a 720p INSTAR camera, check whether your model is from the IN-5xxx series.

### MQTT and smart home integration

INSTAR cameras support MQTT for integration with Home Assistant, ioBroker, and Node-RED. MQTT is used for camera control and event notifications, not for video streaming. For video integration with smart home platforms, use the RTSP URL.

### PoE availability

IN-8xxx and IN-9xxx outdoor models support Power over Ethernet (PoE), allowing a single cable for both power and data. Indoor models typically require a separate power adapter.

### Credentials vary by model

While the common default credentials are admin / instar, some models may use different defaults. Check the camera's documentation or label for the factory credentials. INSTAR cameras typically require changing the default password during initial setup.

## FAQ

**What is the default RTSP URL for INSTAR cameras?**

For current HD models (IN-6xxx, IN-7xxx, IN-8xxx, IN-9xxx), the URL is `rtsp://admin:instar@CAMERA_IP:554//11`. Note the double forward slash before `11`. For IN-5xxx models, use `rtsp://admin:instar@CAMERA_IP:554/MediaInput/mpeg4`.

**Do all INSTAR cameras support RTSP?**

No. Legacy models (IN-2xxx, IN-3xxx, IN-4xxx) are VGA-resolution cameras that only support HTTP-based streaming in ASF or MJPEG format. All IN-5xxx and newer cameras support RTSP.

**What is the difference between stream //11, //12, and //13?**

Stream `//11` is the main (highest quality) stream, `//12` is a lower-resolution sub stream suitable for remote viewing over limited bandwidth, and `//13` is a mobile-optimized third stream with the lowest resolution.

**Do INSTAR cameras support ONVIF?**

Yes. ONVIF is supported on IN-6xxx, IN-7xxx, IN-8xxx, and IN-9xxx series cameras. Legacy models do not support ONVIF. You can use the VisioForge SDK's ONVIF features for camera discovery and PTZ control on supported models.

**Can I integrate INSTAR cameras with Home Assistant?**

Yes. INSTAR cameras support MQTT, making them easy to integrate with Home Assistant, ioBroker, and Node-RED for automation and event-driven actions. For video streaming in Home Assistant, use the RTSP URL in a generic camera integration.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [ABUS Connection Guide](../abus/) — German consumer / smart home cameras
- [Save Original RTSP Stream](../../mediablocks/Guides/rtsp-save-original-stream/) — Record INSTAR streams without re-encoding
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## JVC IP Camera RTSP URL and C# .NET Integration Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/jvc/
**Description:** JVC VN-H, VN-T, VN-C, and VN-X network camera RTSP URL patterns for C# .NET. Stream and record with VisioForge Video Capture SDK integration code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to JVC IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**JVC** (JVCKENWOOD Corporation) is a Japanese electronics company headquartered in Yokohama, Japan. JVC's Professional Systems Division produced the VN-series IP cameras for surveillance applications. JVC exited the standalone IP camera market around 2015, but many VN-series cameras remain in active service across enterprise and government installations. These cameras are known for their robust PSIA protocol support and reliable performance.

**Key facts:**

- **Product lines:** VN-H Series (VN-H37, VN-H137, VN-H237, VN-H657), VN-T Series (VN-T216U), VN-X Series (VN-X35U, VN-X235U), VN-C Series (VN-C20U)
- **Protocol support:** RTSP, ONVIF (VN-H/VN-T series), PSIA, HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** admin / jvc (varies by model)
- **ONVIF support:** Yes (VN-H and VN-T series)
- **Video codecs:** H.264 (VN-H/VN-T series), MPEG-4 (older VN-C models)

Discontinued Product Line

JVC exited the IP camera market around 2015. While VN-series cameras remain widely deployed, firmware updates are no longer available. Consider network segmentation and firewall rules to protect these cameras, as they will not receive security patches.

## RTSP URL Patterns

### Standard URL Formats

JVC cameras support multiple RTSP URL patterns depending on the model series:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/PSIA/Streaming/channels/0?videoCodecType=H.264
```

| URL Pattern | Protocol | Description |
| --- | --- | --- |
| `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264` | PSIA | Primary H.264 stream (most VN-H models) |
| `rtsp://IP:554/PSIA/Streaming/channels/CHANNEL` | PSIA | PSIA stream by channel number |
| `rtsp://IP:554/video.h264` | H.264 | Direct H.264 stream (VN Series general) |
| `rtsp://IP:554/1/stream1` | H.264 | Alternative stream URL (VN-T216U) |
| `rtsp://IP:554//livestream` | H.264 | Live stream URL (VN-H57) |

PSIA Channel Numbering

JVC cameras use zero-based channel numbering for PSIA URLs. Channel 0 is the first (and usually only) video channel. This differs from most other brands that start channel numbering at 1.

### PSIA Channel URLs

| Channel | URL | Description |
| --- | --- | --- |
| Channel 0 (primary) | `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264` | First video channel (main stream) |
| Channel 1 | `rtsp://IP:554/PSIA/Streaming/channels/1?videoCodecType=H.264` | Second video channel (sub stream, if available) |

### Camera Models

| Model Series | Resolution | Main Stream URL | Codec |
| --- | --- | --- | --- |
| VN-H37 (HD dome) | 1920x1080 | `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264` | H.264 |
| VN-H137 (HD bullet) | 1920x1080 | `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264` | H.264 |
| VN-H237 (HD dome) | 1920x1080 | `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264` | H.264 |
| VN-H657 (HD PTZ) | 1920x1080 | `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264` | H.264 |
| VN-T216U (HD box) | 1920x1080 | `rtsp://IP:554/1/stream1` | H.264 |
| VN-X35U (network camera) | 1280x960 | `rtsp://IP:554/video.h264` | H.264 |
| VN-X235U (network camera) | 1920x1080 | `rtsp://IP:554/video.h264` | H.264 |
| VN-C20U (legacy network) | 640x480 | N/A (HTTP snapshot only) | MJPEG |

## Connecting with VisioForge SDK

Use your JVC camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// JVC VN-H Series, PSIA H.264 main stream
var uri = new Uri("rtsp://192.168.1.90:554/PSIA/Streaming/channels/0?videoCodecType=H.264");
var username = "admin";
var password = "jvc";
```

For VN-T series cameras using the alternative URL format:

```
// JVC VN-T216U, alternative stream URL
var uri = new Uri("rtsp://192.168.1.90:554/1/stream1");
```

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/video.jpg` | Standard snapshot (most models) |
| Java Applet Snapshot | `http://IP/java.jpg` | Java-based snapshot (legacy) |
| API Snapshot | `http://IP/api/video?encode=jpeg` | API-based JPEG capture (VN-X series) |
| MJPEG Stream | `http://IP/api/video?encode=jpeg&framerate=15&boundary=on` | Continuous MJPEG via API |

### Model-Specific Snapshot URLs

| Model Series | Snapshot URL | Notes |
| --- | --- | --- |
| VN-H Series | `http://IP/cgi-bin/video.jpg` | CGI-based snapshot |
| VN-T Series | `http://IP/cgi-bin/video.jpg` | CGI-based snapshot |
| VN-C Series (VN-C20U) | `http://IP/cgi-bin/video.jpg` | CGI-based snapshot |
| VN-X Series (VN-X35U/X235U) | `http://IP/api/video?encode=jpeg` | API-based snapshot |

## Troubleshooting

### PSIA channel numbering starts at 0

Unlike most camera brands where channel numbering starts at 1, JVC uses **zero-based** PSIA channel numbering. If you are porting code from another brand:

- Channel 0 = First video channel (equivalent to Channel 1 on other brands)
- Channel 1 = Second video channel (sub stream or secondary sensor)

### Default credentials not working

JVC cameras ship with different default credentials depending on the model and firmware version:

1. Try `admin` / `jvc` (most common)
2. Try `admin` / `admin`
3. Try accessing the web interface at `http://CAMERA_IP` to reset or verify credentials
4. Some models ship with no default password - access the web interface first to set one

### Firmware updates unavailable

Since JVC discontinued its IP camera line around 2015, firmware updates are no longer available. To mitigate security risks:

- Place cameras on an isolated VLAN or network segment
- Use firewall rules to restrict access to camera ports
- Disable UPnP and any cloud connectivity features
- Consider replacing end-of-life cameras with currently supported models

### VN-C series HTTP-only access

The older VN-C series cameras (such as VN-C20U) do not support RTSP streaming and only provide HTTP-based MJPEG access. Use the HTTP snapshot or MJPEG stream URLs for these models instead of RTSP.

### Multiple URL formats on VN-T series

The VN-T216U supports multiple RTSP URL formats. If one does not work, try alternatives:

1. `rtsp://IP:554/1/stream1` (preferred)
2. `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264` (PSIA)
3. `rtsp://IP:554/video.h264` (direct H.264)

## FAQ

**What is the default RTSP URL for JVC cameras?**

For most VN-H series cameras, the primary RTSP URL is `rtsp://admin:jvc@CAMERA_IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264`. The VN-T series uses `rtsp://IP:554/1/stream1` as an alternative. VN-X series models use `rtsp://IP:554/video.h264`.

**Are JVC IP cameras still supported?**

JVC exited the standalone IP camera market around 2015. The cameras remain functional but no longer receive firmware updates or official support. Many VN-series cameras are still actively deployed in surveillance systems worldwide.

**Do JVC cameras support ONVIF?**

The VN-H and VN-T series cameras support ONVIF Profile S. Older VN-C and some VN-X models do not support ONVIF and rely on PSIA or proprietary CGI interfaces instead.

**Why does PSIA channel numbering start at 0?**

JVC implements zero-based PSIA channel numbering, meaning the first video channel is channel 0 rather than channel 1. This is specific to JVC's PSIA implementation and differs from most other camera manufacturers. When migrating from another brand, adjust your channel numbers accordingly.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Sony Connection Guide](../sony/) — Japanese enterprise cameras
- [Canon Connection Guide](../canon/) — Japanese professional cameras
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## LG IP Camera RTSP URL Setup and Streaming in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/lg/
**Description:** LG SmartIP, LW, and LV series camera RTSP URL patterns for C# .NET. Stream wireless and wired models using VisioForge Video Capture SDK integration.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Webcam, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to LG IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**LG Electronics** is a South Korean multinational electronics company headquartered in Seoul, South Korea. LG produced IP cameras under the **SmartIP** brand and the **LW/LV series** for the professional security market. LG has since largely exited the IP camera business and sold its security division. A limited number of LG cameras remain deployed in commercial and enterprise installations.

**Key facts:**

- **Product lines:** LW Series (wireless dome/bullet), LV Series (wired), SmartIP (enterprise)
- **Protocol support:** RTSP, HTTP/CGI, ONVIF (SmartIP series), PSIA (select models)
- **Default RTSP port:** 554
- **Default credentials:** admin / admin
- **ONVIF support:** Yes (SmartIP series), limited or absent on LW/LV series
- **Video codecs:** H.264 (LW130W, LW332, SmartIP series), MJPEG (older models)

Discontinued Product Line

LG has exited the IP camera market and sold its security division. No new firmware updates or official support are available. Many database entries labeled "LG" are actually LG smartphones used as IP cameras via third-party apps -- only actual LG camera models (LW, LV, SmartIP, 7210R) are covered here.

## RTSP URL Patterns

### Standard URL Formats

LG cameras use several different RTSP URL patterns depending on the model series:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/video1+audio1
```

| URL Pattern | Description |
| --- | --- |
| `video1+audio1` | H.264 video with audio (LW series, 7210R) |
| `/` (root) | Root stream (LV series) |
| `//Master-0` | Master stream (LW130W alternate) |
| `camera.stm` | Camera stream (LW332) |
| `live1.sdp` | Live SDP stream (LW332 alternate) |
| PSIA channel URL | Enterprise PSIA streaming (SmartIP) |

### Camera Models - RTSP Streams

| Model | Type | Main Stream URL | Notes |
| --- | --- | --- | --- |
| LW130W | Wireless Dome | `rtsp://IP:554/video1+audio1` | H.264 + audio |
| LW130W | Wireless Dome | `rtsp://IP//Master-0` | Alternate Master stream |
| LW332 | Wireless Bullet | `rtsp://IP:554/camera.stm` | Camera stream |
| LW332 | Wireless Bullet | `rtsp://IP:554/live1.sdp` | Alternate SDP stream |
| LVW700 | Wired Dome | `rtsp://IP:554/` | Root stream |
| LVW701 | Wired Dome | `rtsp://IP:554/` | Root stream |
| 7210R | IP Camera | `rtsp://IP:554/video1+audio1` | H.264 + audio |
| SmartIP | Enterprise | `rtsp://IP:554/PSIA/Streaming/channels/2?videoCodecType=H.264` | PSIA H.264 stream |

### Models by Series

#### LW Series (Wireless Cameras)

| Model | Streaming URLs | Protocol |
| --- | --- | --- |
| LW130W | `video1+audio1` or `//Master-0` | RTSP + HTTP |
| LW332 | `camera.stm` or `live1.sdp` | RTSP + HTTP |

#### LV Series (Wired Cameras)

| Model | Streaming URLs | Protocol |
| --- | --- | --- |
| LVW700 | Root stream (`rtsp://IP:554/`) | RTSP |
| LVW701 | Root stream (`rtsp://IP:554/`) | RTSP |

#### SmartIP Series (Enterprise Cameras)

| Model | Streaming URLs | Protocol |
| --- | --- | --- |
| SmartIP models | PSIA channel URL | RTSP + PSIA + ONVIF |

#### Standalone Models

| Model | Streaming URLs | Protocol |
| --- | --- | --- |
| 7210R | `video1+audio1` | RTSP |

### Alternative URL Formats

| URL Pattern | Models | Notes |
| --- | --- | --- |
| `rtsp://IP:554/video1+audio1` | LW130W, 7210R | Standard (recommended for these models) |
| `rtsp://IP//Master-0` | LW130W | Alternate; note double-slash, no port |
| `rtsp://IP:554/camera.stm` | LW332 | Standard for LW332 |
| `rtsp://IP:554/live1.sdp` | LW332 | Alternate SDP format |
| `rtsp://IP:554/` | LVW700, LVW701 | Root stream (unusual but valid) |
| `rtsp://IP:554/PSIA/Streaming/channels/2?videoCodecType=H.264` | SmartIP | PSIA enterprise streaming |

Root Stream URL

The LVW700 and LVW701 use a root RTSP URL (`rtsp://IP:554/`) with no path component. This is unusual but valid. Make sure your RTSP client does not strip the trailing slash or add a default path.

## Connecting with VisioForge SDK

Use your LG camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// LG LW130W, H.264 + audio stream
var uri = new Uri("rtsp://192.168.1.90:554/video1+audio1");
var username = "admin";
var password = "admin";
```

For LW332 cameras, use `camera.stm` or `live1.sdp` as the stream path instead.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| CGI Snapshot | `http://IP/snapshot.cgi` | Standard CGI snapshot |
| JPEG Snapshot | `http://IP/snapshot.jpg` | Direct JPEG (LW130W) |
| Video Feed | `http://IP/videofeed` | Live video feed |
| MJPEG Stream | `http://IP/video?submenu=mjpg` | Continuous MJPEG stream |
| Profile Video | `http://IP/video?profile=CHANNEL` | Profile-based video selection |

## Troubleshooting

### Confusing LG cameras with LG smartphones

Many RTSP camera databases contain entries labeled "LG" that are actually **LG smartphones** (P350, P509, P970, Nexus 4, Optimus V, LS670) running third-party IP camera apps like "IP Webcam." These are not actual LG IP cameras. Look for model numbers starting with **LW**, **LV**, **SmartIP**, or **7210R** to identify genuine LG security cameras.

### Root stream URL not connecting

The LVW700 and LVW701 cameras use a bare root URL (`rtsp://IP:554/`) with no stream path. Some RTSP client libraries may not handle this correctly. If you experience connection issues:

1. Ensure the trailing slash is included
2. Try specifying the URL as `rtsp://admin:admin@192.168.1.90:554/`
3. Verify the camera is responding on port 554 using a network scanner

### Multiple URL formats per model

Some LG cameras (particularly the LW130W and LW332) support multiple RTSP URL formats. If one format fails, try the alternate:

- **LW130W:** Try `video1+audio1` first, then `//Master-0`
- **LW332:** Try `camera.stm` first, then `live1.sdp`

### PSIA streaming on SmartIP models

SmartIP enterprise cameras support PSIA (Physical Security Interoperability Alliance) streaming. The PSIA URL format is:

```
rtsp://admin:admin@192.168.1.90:554/PSIA/Streaming/channels/2?videoCodecType=H.264
```

Change the channel number to select different streams. PSIA requires authentication via the URL or HTTP digest.

### No firmware updates available

LG has exited the security camera market. No new firmware, patches, or official support channels are available. If you encounter bugs or security vulnerabilities, consider replacing the camera with a currently supported model.

## FAQ

**What is the default RTSP URL for LG IP cameras?**

It depends on the model series. For LW130W and 7210R cameras, use `rtsp://admin:admin@CAMERA_IP:554/video1+audio1`. For LW332, use `rtsp://admin:admin@CAMERA_IP:554/camera.stm`. For LVW700/LVW701, use `rtsp://admin:admin@CAMERA_IP:554/`. Each model series has a different URL pattern.

**Are LG IP cameras still supported?**

No. LG sold its security division and exited the IP camera market. No firmware updates, new models, or official technical support are available. Existing cameras continue to function but will not receive security patches or feature updates.

**Do LG cameras support ONVIF?**

Only the SmartIP enterprise series supports ONVIF. The consumer LW and LV series cameras have limited or no ONVIF support. SmartIP cameras also support PSIA as an alternative interoperability protocol.

**Why do I see LG phone models in IP camera databases?**

Many RTSP URL databases list LG smartphone models (Nexus 4, Optimus V, P509, etc.) as "LG cameras." These are actually phones running third-party apps like "IP Webcam" that turn the phone into a makeshift security camera. They are not actual LG IP camera products and use completely different URL patterns determined by the app.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Samsung Connection Guide](../samsung/) — Korean enterprise cameras
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## LILIN IP Camera RTSP URL Patterns and C# .NET Setup
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/lilin/
**Description:** LILIN LR, Z, D, S, and P series camera RTSP URL patterns for C# .NET. Includes snapshot endpoints and VisioForge SDK streaming integration code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to LILIN IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**LILIN** (Merit LILIN Co., Ltd.) is a Taiwanese professional security camera manufacturer headquartered in New Taipei City, Taiwan. Founded in 1980, LILIN is one of the oldest IP camera manufacturers in the world. The company is known for professional-grade surveillance cameras with distinctive RTSP URL patterns that encode the resolution directly in the URL path.

**Key facts:**

- **Product lines:** Z Series (bullet), S Series (speed dome), D Series (dome), LR Series (IR), P Series (panoramic)
- **Protocol support:** RTSP, ONVIF, HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** admin / pass
- **ONVIF support:** Yes (most current models)
- **Video codecs:** H.264, MJPEG
- **Unique URL pattern:** Resolution encoded in RTSP path (e.g., `rtsph264720p`, `rtsph2641080p`)

Resolution-Based RTSP Paths

LILIN uses a unique URL pattern where the resolution is encoded directly in the RTSP path (e.g., `rtsph264720p` for 720p, `rtsph2641080p` for 1080p). Make sure to use the correct resolution suffix for your camera model.

## RTSP URL Patterns

### Standard URL Format

LILIN cameras use a resolution-based RTSP path format:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/rtsph2641080p
```

| Parameter | Value | Description |
| --- | --- | --- |
| `rtsph264720p` | 720p stream | H.264 at 1280x720 resolution |
| `rtsph2641080p` | 1080p stream | H.264 at 1920x1080 resolution |
| `rtsph2641024p` | 1024p stream | H.264 at 1280x1024 resolution (note: double-slash in some models) |

### Camera Models

| Model | Resolution | Main Stream URL | Notes |
| --- | --- | --- | --- |
| LR7022E4 (IR bullet) | 1920x1080 | `rtsp://IP:554/rtsph2641080p` | LR series, 1080p |
| LR7722X (IR bullet) | 1920x1080 | `rtsp://IP:554/rtsph2641080p` | LR series, 1080p |
| IPR712M4.3 (PTZ) | 1280x1024 | `rtsp://IP:554//rtsph2641024p` | IPR series, double-slash path |
| Z Series (bullet) | 1920x1080 | `rtsp://IP:554/rtsph2641080p` | Outdoor bullet cameras |
| D Series (dome) | 1920x1080 | `rtsp://IP:554/rtsph2641080p` | Indoor/outdoor dome |
| S Series (speed dome) | 1920x1080 | `rtsp://IP:554/rtsph2641080p` | PTZ speed dome |

### Alternative URL Formats

Some LILIN models or firmware versions support these alternative URLs:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/rtsph2641080p` | Standard 1080p (recommended) |
| `rtsp://IP:554/rtsph264720p` | 720p stream |
| `rtsp://IP:554//rtsph2641024p` | 1024p stream (double-slash, some PTZ models) |

## Connecting with VisioForge SDK

Use your LILIN camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// LILIN LR7022E4, 1080p main stream
var uri = new Uri("rtsp://192.168.1.90:554/rtsph2641080p");
var username = "admin";
var password = "pass";
```

For 720p access, use `rtsph264720p` instead of `rtsph2641080p`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot (VGA) | `http://IP/getimage?camera=CHANNEL&fmt=vga` | VGA resolution snapshot |
| Snapshot by Channel | `http://IP/getimage[CHANNEL]` | Replace CHANNEL with camera number |
| Quick Snapshot | `http://IP/snap` | Simple snapshot URL |
| CGI Snapshot | `http://IP/cgi-bin/net_jpeg.cgi?ch=CHANNEL` | CGI-based snapshot |
| Auth Snapshot | `http://IP/snapshot.jpg?user=USER&pwd=PASS` | URL-based authentication |
| Direct Image | `http://IP/image/CHANNEL.jpg` | Direct JPEG image by channel |

## Troubleshooting

### "401 Unauthorized" error

LILIN cameras ship with default credentials of `admin` / `pass`. If you have changed the password through the web interface, ensure you update the credentials in your RTSP URL.

1. Access the camera at `http://CAMERA_IP` in a browser
2. Log in with your credentials
3. Verify the RTSP settings under the network configuration section

### Double-slash in RTSP path

Some LILIN models, particularly the IPR PTZ series, require a double-slash (`//`) before the resolution path. If a single-slash URL fails:

- Try `rtsp://IP:554//rtsph2641024p` instead of `rtsp://IP:554/rtsph2641024p`
- This is commonly seen with 1024p resolution models

### Choosing the correct resolution suffix

LILIN cameras do not use `subtype=0/1` like many other brands. Instead, the stream resolution is selected by changing the URL path:

- `rtsph264720p` for 720p (1280x720)
- `rtsph2641080p` for 1080p (1920x1080)
- `rtsph2641024p` for 1024p (1280x1024)

If you specify a resolution your camera does not support, the connection will fail.

### Port 554 connection refused

Verify that RTSP is enabled on the camera:

- Web interface: Check **Network > RTSP** settings
- Confirm port 554 is not blocked by a firewall
- Default RTSP port is 554

## FAQ

**What is the default RTSP URL for LILIN cameras?**

The most common URL is `rtsp://admin:pass@CAMERA_IP:554/rtsph2641080p` for the 1080p main stream. Replace the resolution suffix (`rtsph2641080p`) with the appropriate value for your camera's resolution.

**Do LILIN cameras support ONVIF?**

Yes. Most current LILIN models support ONVIF, which provides an alternative method for discovering and connecting to the camera without needing brand-specific URL patterns.

**Why does LILIN use a different RTSP URL format?**

LILIN encodes the resolution directly in the RTSP path rather than using channel/subtype parameters like Dahua or Hikvision. This is a proprietary design choice. The format is straightforward once you know which resolution suffix your camera model supports.

**What are the default login credentials for LILIN cameras?**

The default username is `admin` and the default password is `pass`. It is recommended to change these credentials after initial setup for security purposes.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [AVTech Connection Guide](../avtech/) — Taiwanese industrial cameras
- [BrickCom Connection Guide](../brickcom/) — Taiwanese industrial cameras
- [RTSP Camera Integration Guide](../../videocapture/video-sources/ip-cameras/rtsp/) — LILIN RTSP stream configuration
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Linksys IP Camera RTSP URL Patterns and C# .NET Setup
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/linksys/
**Description:** Connect to Linksys WVC, PVC, and LCAB cameras in C# .NET with RTSP URL patterns, ASF/MJPEG streams, and code samples for discontinued WVC series models.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MP4, H.264, MJPEG, C#

# How to Connect to Linksys IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Linksys** is an American networking company based in Irvine, California. Originally acquired by Cisco Systems in 2003, the brand was sold to Belkin (a Foxconn subsidiary) in 2013. During the Cisco ownership years, Linksys produced the popular **WVC (Wireless Video Camera)** series of IP cameras for the consumer and prosumer market. The camera product line was discontinued around 2014, but many units remain deployed and operational.

Because Linksys was a Cisco brand, its cameras share identical URL patterns and firmware with Cisco consumer camera products. The `.sav` extension in RTSP URLs is a proprietary Cisco/Linksys endpoint format.

**Key facts:**

- **Product lines:** WVC Series (WVC54G, WVC54GC, WVC54GCA, WVC80N, WVC200, WVC210, WVC2300), PVC Series (PVC2300), LCAB Series
- **Protocol support:** RTSP, HTTP/ASF, MJPEG, MMS (Windows Media)
- **Default RTSP port:** 554
- **Default credentials:** admin / admin
- **ONVIF support:** Limited (LCAB series only)
- **Video codecs:** MPEG-4/ASF (WVC series), H.264 (newer models), MJPEG

Discontinued product line

Linksys IP cameras were discontinued around 2014. No new firmware updates or official support are available. The information on this page is provided for legacy deployments. Many WVC models require Internet Explorer with ActiveX for their web interface.

Linksys = Cisco consumer cameras

Linksys cameras use the same URL patterns as Cisco consumer cameras since Linksys was a Cisco brand. See our [Cisco connection guide](../cisco/) for additional details and enterprise Cisco camera models.

## RTSP URL Patterns

### Standard URL Format

Most Linksys cameras use the Cisco `/img/media.sav` RTSP path:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/img/media.sav
```

Unusual `.sav` extension

The `.sav` extension is a proprietary Cisco/Linksys RTSP endpoint -- it is not a standard media file format. Do not confuse it with a file download URL.

### RTSP URLs by Model

| Model | RTSP URL | Codec | Notes |
| --- | --- | --- | --- |
| WVC54GCA | `rtsp://IP:554/img/media.sav` | MPEG-4 | Wireless-G, 640x480 |
| WVC80N | `rtsp://IP:554/img/media.sav` | MPEG-4 | Wireless-N, 640x480 |
| WVC80N (alt) | `rtsp://IP:554/img/video.sav` | MPEG-4 | Alternative video endpoint |
| WVC210 | `rtsp://IP:554/img/media.sav` | MPEG-4 | Wireless-G PTZ |
| WVC200 | `rtsp://IP:554/img/media.sav` | MPEG-4 | Wireless-G |
| PVC2300 | `rtsp://IP:554/video.mp4` | MPEG-4/H.264 | Small business box camera |
| LCAB03VLNOD | `rtsp://IP:554//ONVIF/channel2` | H.264 | ONVIF-enabled outdoor camera |

### Model Family Summary

| Model Family | RTSP Stream | HTTP ASF | MJPEG | Snapshot CGI |
| --- | --- | --- | --- | --- |
| WVC54G / WVC54GC / WVC54GCA | `/img/media.sav` | Yes | Yes | Yes |
| WVC80N | `/img/media.sav`, `/img/video.sav` | Yes | Yes | -- |
| WVC200 / WVC210 | `/img/media.sav` | Yes | Yes | Yes |
| WVC2300 | `/img/media.sav` | Yes | -- | -- |
| PVC2300 | `/video.mp4` | Yes | -- | -- |
| LCAB series | `//ONVIF/channel2` | -- | -- | -- |

## Connecting with VisioForge SDK

Use your Linksys camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Linksys WVC80N, primary RTSP stream
var uri = new Uri("rtsp://192.168.1.60:554/img/media.sav");
var username = "admin";
var password = "admin";
```

For PVC2300 cameras, use `/video.mp4` instead of `/img/media.sav`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Compatible Models |
| --- | --- | --- |
| ASF Video Stream | `http://IP/img/video.asf` | WVC54G, WVC54GC, WVC54GCA, WVC80N, WVC200, WVC210, WVC11b |
| MJPEG Stream | `http://IP/img/video.mjpeg` | WVC54GC, WVC54GCA, WVC80N, WVC200, WVC210 |
| MJPEG Single Frame | `http://IP/img/mjpeg.jpg` | Most WVC models |
| MJPEG CGI | `http://IP/img/mjpeg.cgi` | Most WVC models |
| MJPEG (uppercase) | `http://IP/MJPEG.CGI` | Some WVC models |
| High-Res Snapshot | `http://IP/img/snapshot.cgi?size=3` | WVC54GCA, WVC200, WVC210 |
| Medium Snapshot | `http://IP/img/snapshot.cgi?size=2` | WVC54GCA, WVC200, WVC210 |
| VGA Snapshot | `http://IP/img/snapshot.cgi?img=vga` | WVC54GCA, WVC200, WVC210 |
| Alternative ASF | `http://IP/videostream.asf` | WVC54GC, WVC80N |
| MMS Stream | `mms://IP/img/video.asf` | Legacy Windows Media (all WVC models) |

HTTP streams as RTSP fallback

Many Linksys WVC cameras work more reliably with HTTP-based ASF or MJPEG streams than with RTSP. If the RTSP URL is unresponsive, try the ASF stream at `http://IP/img/video.asf` as a fallback.

## Troubleshooting

### RTSP stream not connecting

Linksys WVC cameras have limited RTSP support. Many models primarily serve video over HTTP using ASF (Advanced Streaming Format) rather than true RTSP:

1. Verify the camera IP address and that port 554 is open
2. Confirm RTSP is enabled in the camera's web interface
3. Try the HTTP ASF stream (`http://IP/img/video.asf`) as an alternative
4. Some models require the web interface to be accessed first (via Internet Explorer with ActiveX) before RTSP becomes available

### ASF stream requires specific handling

The ASF (Advanced Streaming Format) streams from WVC cameras use a Microsoft proprietary container. The VisioForge SDK handles ASF streams automatically. If you encounter issues:

- Ensure you are connecting via HTTP, not RTSP, for ASF URLs
- ASF streams may require Windows Media components or LAV filters on some systems

### MMS protocol streams

The `mms://` protocol URLs are Windows Media-specific and only work with Windows Media Player or compatible decoders. For modern applications, use the HTTP ASF URL (`http://IP/img/video.asf`) instead of the MMS equivalent.

### Web interface requires Internet Explorer

Many WVC models require Internet Explorer with ActiveX controls for their web configuration interface. Use Internet Explorer or an ActiveX-compatible browser to access camera settings. The RTSP and HTTP streams themselves work with any client.

### Camera not discoverable on network

Linksys cameras do not support modern discovery protocols (except LCAB series with ONVIF). To find the camera:

1. Check your router's DHCP lease table for the camera's IP address
2. Use the Linksys Camera Utility (if still available) for discovery
3. Try the default IP address assigned by the camera (check the model's manual)
4. Use a network scanner such as Advanced IP Scanner

## FAQ

**What is the default RTSP URL for Linksys cameras?**

For most Linksys WVC cameras, use `rtsp://admin:admin@CAMERA_IP:554/img/media.sav`. For the PVC2300, use `rtsp://admin:admin@CAMERA_IP:554/video.mp4` instead. If RTSP does not work, try the HTTP ASF stream at `http://CAMERA_IP/img/video.asf`.

**Are Linksys cameras still available for purchase?**

No. Linksys discontinued its entire IP camera product line around 2014, shortly after the brand was sold from Cisco to Belkin/Foxconn. No firmware updates or official support are available. However, many WVC and PVC cameras remain in use and functional.

**Do Linksys cameras support ONVIF?**

Only the LCAB series cameras have ONVIF support. The WVC and PVC series do not support ONVIF. For WVC cameras, use the direct RTSP or HTTP URL patterns listed above.

**Are Linksys and Cisco camera URLs the same?**

Yes. Linksys cameras were produced during Cisco's ownership of the brand and share the same firmware and URL patterns as Cisco consumer cameras. The `/img/media.sav` RTSP path and `/img/video.asf` HTTP path are identical across both brands. See our [Cisco connection guide](../cisco/) for more details.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Cisco Connection Guide](../cisco/) — Same URL patterns, parent company
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Lorex IP Camera RTSP URL Connection Guide for C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/lorex/
**Description:** Lorex LNB, LNE, LNZ, DVR, and NVR RTSP URL patterns for C# .NET. Stream and record Lorex cameras using VisioForge Video Capture SDK integration.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MP4, H.264, C#

# How to Connect to Lorex IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Lorex Technology** (a subsidiary of Dahua Technology through FLIR/Lorex) is a major consumer and prosumer security camera brand in North America. Lorex cameras are primarily manufactured by **Dahua Technology** and sold under the Lorex brand through retail channels including Amazon, Costco, and Best Buy. Lorex is one of the top-selling security camera brands in the United States and Canada.

**Key facts:**

- **Product lines:** LNB (bullet IP), LNE (dome/turret IP), LNZ (PTZ IP), LNC (consumer Wi-Fi), IPSC (legacy), L-series (legacy)
- **Protocol support:** RTSP, ONVIF, HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** admin / (set during NVR/camera setup); some older models: admin / admin
- **ONVIF support:** Yes (most current models)
- **Video codecs:** H.264, H.265 (newer models)
- **OEM base:** Dahua Technology (some models use Hikvision firmware)

Lorex uses multiple OEM sources

Most Lorex IP cameras are manufactured by Dahua and use Dahua's RTSP URL format. However, some Lorex models (particularly LNB2153 and MCNB2153) use Hikvision-based firmware with `/Streaming/Channels/` URLs. Check both URL formats if one doesn't work.

## RTSP URL Patterns

### Dahua-Based Models (Most Lorex IP Cameras)

Most Lorex IP cameras use Dahua's URL format:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Main stream | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Full resolution |
| Sub stream | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` | Lower resolution |

### Hikvision-Based Models

Some Lorex models use Hikvision firmware:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Main stream | `rtsp://IP:554//Streaming/Channels/1` | Full resolution (note double slash) |
| Sub stream | `rtsp://IP:554//Streaming/Channels/2` | Lower resolution |
| H.264 direct | `rtsp://IP:554/ch0_0.h264` | Direct H.264 stream |

### Model-Specific URLs

| Model | RTSP URL | OEM Base | Notes |
| --- | --- | --- | --- |
| LNB2153 | `rtsp://IP:554//Streaming/Channels/1` | Hikvision | 1080p bullet |
| LNB2184 | `rtsp://IP:554/video.mp4` | Dahua | 4MP bullet |
| LNE1001 | `rtsp://IP:554/` | Dahua | 1080p dome |
| LNE3003 | `rtsp://IP:554/video.mp4` | Dahua | 2K dome |
| LNZ4001 | `rtsp://IP:554/video.mp4` | Dahua | PTZ |
| MCNB2153 | `rtsp://IP:554//Streaming/Channels/1` | Hikvision | 1080p bullet |

### Alternative URL Formats

Some Lorex cameras also respond to these URLs:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/` | Root path (some models) |
| `rtsp://IP:554/video.mp4` | Video stream |
| `rtsp://IP:554/ch0_0.h264` | Direct H.264 |

### Legacy Models

| Model | URL | Notes |
| --- | --- | --- |
| IPSC Series | `rtsp://IP:554/` | Legacy IP cameras |
| L23WD | `rtsp://IP:554/` | Legacy wireless |
| IP1240 | `http://IP/GetData.cgi` | HTTP only |
| LNC104/116/204 | `http://IP/snapshot.jpg?user=USER&pwd=PASS` | Wi-Fi cameras, HTTP only |

## Connecting with VisioForge SDK

Use your Lorex camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code).

### Dahua-Based Models (Most Lorex Cameras)

```
// Lorex camera (Dahua-based), main stream
var uri = new Uri("rtsp://192.168.1.65:554/cam/realmonitor?channel=1&subtype=0");
var username = "admin";
var password = "YourPassword";
```

### Hikvision-Based Lorex Models

```
// Lorex LNB2153 (Hikvision-based), main stream
var uri = new Uri("rtsp://192.168.1.65:554//Streaming/Channels/1");
var username = "admin";
var password = "YourPassword";
```

See the [OEM identification guide](#determine-your-oem-base) in Troubleshooting to determine which URL format your Lorex camera uses.

## Snapshot URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/jpg/image.jpg` | Most Lorex IP cameras |
| Snapshot (auth) | `http://IP/snapshot.jpg?user=USER&pwd=PASS` | Consumer Wi-Fi cameras |
| Snapshot (account) | `http://IP/snapshot.jpg?account=USER&password=PASS` | Alternative auth |
| GetData | `http://IP/GetData.cgi` | Legacy models |
| MJPEG Stream | `http://IP/video.mjpg` | Continuous MJPEG |

## Troubleshooting

### Determine your OEM base

Lorex cameras use firmware from different manufacturers. To determine which URL format to use:

1. Try the **Dahua format** first: `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0`
2. If that fails, try the **Hikvision format**: `rtsp://IP:554//Streaming/Channels/1`
3. Check the camera's web interface -- Dahua-based cameras have a blue/white web UI, while Hikvision-based ones have a dark gray/black UI

### NVR vs direct camera access

- When connecting through a Lorex NVR, use `channel=N` in the Dahua URL format to select the camera
- When connecting directly to an IP camera, always use `channel=1`

### Lorex consumer Wi-Fi cameras (LNC series)

The LNC series (LNC104, LNC116, LNC204) are consumer Wi-Fi cameras that typically don't support RTSP. They provide HTTP snapshot URLs only and are primarily designed for use with the Lorex app.

### Port 9000

Some very old Lorex cameras used port 9000 for streaming instead of 554. If standard port 554 doesn't work on an older model, try: `rtsp://IP:9000/`

## FAQ

**Are Lorex cameras the same as Dahua?**

Most Lorex IP cameras are manufactured by Dahua and use identical firmware. The RTSP URL format (`cam/realmonitor?channel=1&subtype=0`) is the same. However, some Lorex models use Hikvision firmware. See our [Dahua connection guide](../dahua/) for additional details.

**What is the default RTSP URL for Lorex cameras?**

Try `rtsp://admin:password@CAMERA_IP:554/cam/realmonitor?channel=1&subtype=0` first (Dahua-based). If that fails, try `rtsp://admin:password@CAMERA_IP:554//Streaming/Channels/1` (Hikvision-based).

**Can I use Lorex cameras without the Lorex NVR?**

Yes. Lorex IP cameras with RTSP support can be connected directly using their individual IP addresses. You don't need the Lorex NVR for third-party software integration.

**Do Lorex cameras support ONVIF?**

Most current Lorex IP cameras support ONVIF. Consumer Wi-Fi cameras (LNC series) generally do not.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Dahua Connection Guide](../dahua/) — Same URL format for most models
- [Amcrest Connection Guide](../amcrest/) — Another Dahua OEM
- [Swann Connection Guide](../swann/) — Consumer/prosumer segment peer
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## LTS IP Camera RTSP URL and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/lts/
**Description:** Connect to LTS (LT Security) cameras in C# .NET with RTSP URL patterns and code samples for CMIP, CMHR series and NVR models. LTS uses Hikvision firmware.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to LTS IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**LTS (LT Security Inc.)** is an American security company based in City of Industry, California. LTS cameras are manufactured by **Hikvision** and use Hikvision firmware, protocols, and web interfaces. LTS rebrands Hikvision hardware with US-based technical support and competitive pricing, making it a popular choice in the professional installation market.

Because LTS cameras run Hikvision firmware, they use the same RTSP URL format, ONVIF implementation, and API endpoints as Hikvision cameras. Any integration code written for Hikvision works with LTS and vice versa.

**Key facts:**

- **Product lines:** CMIP (IP cameras), CMHR (HD-TVI analog), LTD (DVRs), LTN (NVRs)
- **Protocol support:** RTSP, ONVIF Profile S/G/T, HTTP/ISAPI
- **Default RTSP port:** 554
- **Default credentials:** admin / 123456 (some models: admin / admin)
- **ONVIF support:** Yes (all current models)
- **Video codecs:** H.264, H.265 (CMIP4xxx and newer)
- **OEM base:** Hikvision (identical RTSP URL format)

LTS = Hikvision OEM

LTS cameras use Hikvision firmware and the exact same RTSP URL format as Hikvision cameras. Any code written for Hikvision cameras works with LTS. See our [Hikvision connection guide](../hikvision/) for additional details.

## RTSP URL Patterns

### Standard URL Format (Hikvision)

Most current LTS cameras use the standard Hikvision `Streaming/Channels` URL pattern:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/Streaming/Channels/[CHANNEL_ID]
```

| Parameter | Value | Description |
| --- | --- | --- |
| `CHANNEL_ID` | 101 | Channel 1, main stream |
| `CHANNEL_ID` | 102 | Channel 1, sub stream |
| `CHANNEL_ID` | 201 | Channel 2, main stream (NVR) |
| `CHANNEL_ID` | 202 | Channel 2, sub stream (NVR) |

Double-slash in URL

Some LTS/Hikvision cameras use `//Streaming/Channels/1` (with a double forward slash before `Streaming`). Both single-slash and double-slash variants typically work, but try the double-slash version if the single-slash URL fails.

### RTSP URLs by Model

| Model | RTSP URL | Resolution | Notes |
| --- | --- | --- | --- |
| CMIP3122 | `rtsp://IP:554/Streaming/Channels/101` | 3MP | Hikvision standard format |
| CMIP3132-28 | `rtsp://IP:554/Streaming/Channels/101` | 3MP | Hikvision standard format |
| CMIP3432 | `rtsp://IP:554/Streaming/Channels/101` | 4MP | Hikvision standard format |
| CMIP3243 | `rtsp://IP:554/live.h264` | 3MP | Alternative H.264 stream |
| CMIP3412-28 | `rtsp://IP:554/live.h264` | 4MP | Alternative H.264 stream |
| CMIP8232 | `rtsp://IP:554/live.sdp` | 8MP/4K | SDP live stream |
| CMIP8232 (alt) | `rtsp://IP:554/HighResolutionVideo` | 8MP/4K | High resolution stream |
| CMIP8232 (sub) | `rtsp://IP:554/h264/ch1/sub/` | 8MP/4K | H.264 sub stream |
| CMIP series (low-res) | `rtsp://IP:554/LowResolutionVideo` | Varies | Low resolution sub stream |

### Alternative URL Formats

Some older LTS models or specific firmware versions support these alternative URLs:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/Streaming/Channels/101` | Standard Hikvision (recommended) |
| `rtsp://IP:554//Streaming/Channels/1` | Double-slash variant |
| `rtsp://IP:554/live.h264` | H.264 live stream (older CMIP3xxx) |
| `rtsp://IP:554/live.sdp` | SDP live stream (CMIP8xxx) |
| `rtsp://IP:554/HighResolutionVideo` | Named high-resolution stream |
| `rtsp://IP:554/LowResolutionVideo` | Named low-resolution stream |
| `rtsp://IP:554/h264/ch1/sub/` | H.264 sub stream by channel |
| `rtsp://IP:554/cam1/mpeg4?user=USER&pwd=PASS` | MPEG-4 with URL-based auth |

### NVR Channel URLs (LTN Series)

For LTS NVRs (LTN8704, LTN8708, LTN8716, etc.):

| Channel | Main Stream | Sub Stream |
| --- | --- | --- |
| Camera 1 | `rtsp://IP:554/Streaming/Channels/101` | `rtsp://IP:554/Streaming/Channels/102` |
| Camera 2 | `rtsp://IP:554/Streaming/Channels/201` | `rtsp://IP:554/Streaming/Channels/202` |
| Camera N | `rtsp://IP:554/Streaming/Channels/N01` | `rtsp://IP:554/Streaming/Channels/N02` |

### Model Series Summary

| Model Series | Primary RTSP URL | Alternative URLs |
| --- | --- | --- |
| CMIP3xxx (3MP) | `/Streaming/Channels/101` | `/live.h264` (some models) |
| CMIP4xxx (4MP) | `/Streaming/Channels/101` | `/live.h264` (some models) |
| CMIP8xxx (8MP/4K) | `/Streaming/Channels/101` | `/live.sdp`, `/HighResolutionVideo`, `/h264/ch1/sub/` |
| LTN NVRs | `/Streaming/Channels/N01` | Channel-based |
| LTD DVRs | `/Streaming/Channels/N01` | Channel-based |

## Connecting with VisioForge SDK

Use your LTS camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// LTS CMIP3432, main stream (Hikvision format)
var uri = new Uri("rtsp://192.168.1.80:554/Streaming/Channels/101");
var username = "admin";
var password = "123456";
```

For sub-stream access, use channel ID `102` instead of `101`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/snapshot.jpg` | Standard snapshot |
| 3GP Snapshot | `http://IP/snapshot_3gp.jpg` | 3GP format (mobile-optimized) |
| Stream Snapshot | `http://IP/stream.jpg` | Stream-based snapshot |
| DVR Channel Snapshot | `http://IP/stillimg[CHANNEL].jpg` | Replace `[CHANNEL]` with channel number (LTD DVRs) |
| ISAPI Snapshot | `http://IP/ISAPI/Streaming/channels/101/picture` | Hikvision ISAPI (requires auth) |

## Troubleshooting

### Identifying the correct URL format

LTS cameras span multiple generations with different URL formats. To determine which URL your camera uses:

1. Try the standard Hikvision format first: `rtsp://IP:554/Streaming/Channels/101`
2. If that fails, try the double-slash variant: `rtsp://IP:554//Streaming/Channels/1`
3. For older CMIP3xxx models, try `rtsp://IP:554/live.h264`
4. For CMIP8xxx (4K) models, try `rtsp://IP:554/live.sdp`

### Default credentials and activation

- Older LTS cameras: default password is `123456` or `admin`
- Newer LTS cameras (with Hikvision 5.3+ firmware): require password activation on first use, similar to Hikvision
- If you cannot log in with default credentials, the camera may need to be activated via the LTS Discovery Tool or Hikvision SADP Tool

### Using Hikvision tools with LTS cameras

Since LTS cameras run Hikvision firmware, you can use Hikvision utilities for network discovery and configuration:

- **Hikvision SADP Tool** -- discovers LTS cameras on the local network and can activate/reset them
- **LTS Discovery Tool** -- LTS-branded version of SADP with identical functionality
- **iVMS-4200** -- Hikvision's free VMS software works with LTS cameras

### "401 Unauthorized" error

1. Verify your credentials are correct (default: admin / 123456)
2. On newer firmware, ensure the camera has been activated and you are using the password set during activation
3. Check if the camera has a lockout policy -- too many failed login attempts may temporarily block access
4. Some models require digest authentication rather than basic authentication for RTSP

### Double-slash URL issue

The `//Streaming/Channels/1` URL with a double forward slash at the beginning is a known Hikvision pattern. Some HTTP clients or RTSP libraries may normalize this to a single slash. If your connection fails:

- Ensure your URL string preserves the double slash
- Try both `//Streaming/Channels/1` and `/Streaming/Channels/101` variants

## FAQ

**Are LTS cameras the same as Hikvision?**

LTS cameras are manufactured by Hikvision and run Hikvision firmware. The RTSP URL format (`/Streaming/Channels/101`), ONVIF implementation, and ISAPI interface are identical. The main differences are branding, pricing, and US-based technical support from LTS. Any code written for Hikvision cameras works with LTS cameras.

**What is the default RTSP URL for LTS cameras?**

For most current LTS cameras, use `rtsp://admin:123456@CAMERA_IP:554/Streaming/Channels/101` for the main stream. Use channel ID `102` for the sub stream. Older models may use `/live.h264` or `/live.sdp` instead.

**Do LTS cameras support ONVIF?**

Yes. All current LTS IP cameras (CMIP series) support ONVIF Profile S and Profile T. ONVIF can be used for automatic discovery and configuration alongside direct RTSP URLs.

**What is the difference between CMIP and CMHR series?**

CMIP cameras are IP (network) cameras that support RTSP streaming. CMHR cameras are HD-TVI analog cameras that connect directly to DVRs via coaxial cable and do not have network RTSP capability. Only CMIP series cameras can be connected to via RTSP URLs in software.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Hikvision Connection Guide](../hikvision/) — Same URL format (OEM base)
- [Annke Connection Guide](../annke/) — Another Hikvision OEM
- [RTSP Camera Integration Guide](../../videocapture/video-sources/ip-cameras/rtsp/) — LTS RTSP stream configuration
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Mercusys IP Camera RTSP URL and C# .NET Integration
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/mercusys/
**Description:** Mercusys MC and MB series indoor/outdoor camera RTSP URL patterns for C# .NET. Stream and record using VisioForge Video Capture SDK integration code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, C#

# How to Connect to Mercusys IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Mercusys** is a networking and smart home brand owned by **TP-Link**. Mercusys targets the budget-conscious segment with affordable routers, mesh systems, and security cameras. Mercusys cameras share design and firmware similarities with TP-Link Tapo cameras, offering standard RTSP support at lower price points.

**Key facts:**

- **Product lines:** MC (indoor cameras), MB (outdoor cameras)
- **Protocol support:** RTSP, ONVIF (select models), HTTP
- **Default RTSP port:** 554
- **Default credentials:** Set during app setup (no factory defaults)
- **ONVIF support:** Yes (newer models, must be enabled)
- **Video codecs:** H.264
- **Parent company:** TP-Link
- **Companion app:** Mercusys Security app

Mercusys and TP-Link Tapo

Mercusys cameras share firmware architecture with TP-Link Tapo cameras. The RTSP URL format (`/stream1`, `/stream2`) is similar. If you are familiar with Tapo integration, the same approach works with Mercusys. See our [TP-Link connection guide](../tp-link/) for additional details.

## RTSP URL Patterns

### Standard URL Format

Mercusys cameras use a stream-number-based RTSP URL:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/stream1
```

| Stream | URL Pattern | Description |
| --- | --- | --- |
| Main stream | `rtsp://IP:554/stream1` | Full resolution |
| Sub stream | `rtsp://IP:554/stream2` | Lower resolution, less bandwidth |

### Camera Models

| Model | Type | Resolution | Main Stream URL | Audio |
| --- | --- | --- | --- | --- |
| MC50 (indoor PT) | Indoor pan/tilt | 1920x1080 | `rtsp://IP:554/stream1` | Yes |
| MC60 (2K indoor PT) | Indoor pan/tilt | 2304x1296 | `rtsp://IP:554/stream1` | Yes |
| MC70 (4MP indoor PT) | Indoor pan/tilt | 2560x1440 | `rtsp://IP:554/stream1` | Yes |
| MB50 (outdoor bullet) | Outdoor | 1920x1080 | `rtsp://IP:554/stream1` | Yes |
| MB60 (2K outdoor) | Outdoor | 2304x1296 | `rtsp://IP:554/stream1` | Yes |
| MB70 (4MP outdoor) | Outdoor | 2560x1440 | `rtsp://IP:554/stream1` | Yes |

### Enabling RTSP / ONVIF

RTSP and ONVIF may need to be enabled in the camera settings:

1. Open the **Mercusys Security** app
2. Select your camera → **Settings**
3. Navigate to **Advanced Settings**
4. Enable **RTSP** and/or **ONVIF**
5. Set a username and password for RTSP access

## Connecting with VisioForge SDK

Use your Mercusys camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Mercusys MC70 (4MP indoor pan/tilt), main stream
var uri = new Uri("rtsp://192.168.1.90:554/stream1");
var username = "rtsp_user"; // set in Mercusys Security app
var password = "rtsp_pass";
```

For sub-stream access, use `/stream2` instead of `/stream1`.

## Snapshot URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/snapshot.cgi` | Requires basic auth |

## Troubleshooting

### RTSP not accessible

Mercusys cameras require initial setup through the Mercusys Security app. RTSP may also need to be explicitly enabled in the advanced settings. After enabling RTSP, the credentials set in the app must be used for RTSP authentication.

### Camera IP discovery

Find your Mercusys camera's IP address in:

1. The Mercusys Security app → Device Info
2. Your router's DHCP client list
3. ONVIF discovery (if enabled)

### Similar to TP-Link Tapo

If standard Mercusys troubleshooting does not resolve your issue, check our [TP-Link Tapo guide](../tp-link/) for additional troubleshooting steps, as the firmware is similar.

## FAQ

**What is the default RTSP URL for Mercusys cameras?**

Mercusys cameras use `rtsp://username:password@CAMERA_IP:554/stream1` for the main stream and `/stream2` for the sub stream. The username and password are set during RTSP enablement in the Mercusys Security app.

**Is Mercusys the same as TP-Link?**

Mercusys is a brand owned by TP-Link that targets the budget segment. Mercusys cameras share firmware architecture with TP-Link Tapo cameras and use similar RTSP URL formats.

**Do Mercusys cameras support ONVIF?**

Newer Mercusys camera models support ONVIF, but it must be enabled through the Mercusys Security app. Older models may not include ONVIF support.

**How do Mercusys cameras compare to TP-Link Tapo?**

Mercusys cameras are positioned as a more affordable alternative to Tapo. They share similar firmware and RTSP URL patterns. Tapo cameras generally have more model options and broader community support.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [TP-Link Connection Guide](../tp-link/) — Parent company, similar firmware
- [Tenda Connection Guide](../tenda/) — Budget camera alternative
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Milesight IP Camera RTSP URL and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/milesight/
**Description:** Milesight MS-C, MS-A, MS-V series RTSP URL patterns for C# .NET. ONVIF-compliant integration with VisioForge Video Capture SDK code samples.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.265, MJPEG, C#

# How to Connect to Milesight IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Milesight Technology** is a Chinese manufacturer of IP cameras and IoT devices, headquartered in Xiamen, China. Milesight targets professional and SMB markets with a rapidly growing lineup of AI-enabled cameras at competitive price points. The brand is known for strong ONVIF compliance, built-in AI analytics (face detection, LPR, people counting), and straightforward integration with third-party VMS platforms.

**Key facts:**

- **Product lines:** MS-C (mini dome/bullet), MS-A (PTZ/speed dome), MS-V (vandal dome), MS-F (fisheye), MS-B (box), MS-N (NVR)
- **Protocol support:** RTSP, ONVIF (Profile S/G/T on all current models), HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** admin / ms1234 (must be changed on first login)
- **ONVIF support:** Yes (all current models, Profile S/G/T)
- **Video codecs:** H.264, H.265, MJPEG

Double slash in RTSP URLs

Milesight cameras use a **double forward slash** before `main` and `sub` in their RTSP URLs: `rtsp://IP:554//main`. This is intentional and required for all current Milesight models.

## RTSP URL Patterns

### Current Models (All Series)

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Main stream | `rtsp://IP:554//main` | Full resolution (note double slash) |
| Sub stream | `rtsp://IP:554//sub` | Lower resolution |
| Root stream | `rtsp://IP:554/` | Fallback |

### Model-Specific URLs

All current Milesight camera models use the same RTSP URL pattern:

| Model Series | RTSP URL | Type | Notes |
| --- | --- | --- | --- |
| MS-C2672-P | `rtsp://IP:554//main` | Mini dome | 2MP |
| MS-C3366-FP | `rtsp://IP:554//main` | Bullet | 3MP, AI |
| MS-C3366-FPH | `rtsp://IP:554//main` | Bullet | 3MP, AI, heater |
| MS-C2363 | `rtsp://IP:554//main` | Mini dome | 2MP |
| MS-2681 | `rtsp://IP:554//main` | Dome | 8MP |
| MS-3672 | `rtsp://IP:554//main` | Bullet | 3MP |
| MS-A series (PTZ) | `rtsp://IP:554//main` | PTZ | Speed dome |
| MS-V series (vandal) | `rtsp://IP:554//main` | Vandal dome | IK10 rated |
| MS-F series (fisheye) | `rtsp://IP:554//main` | Fisheye | 360-degree |
| MS-B series (box) | `rtsp://IP:554//main` | Box | Professional |

### NVR Channel Streams

For Milesight MS-N series NVRs, use the `channel` parameter to select individual camera streams:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Channel 1, main | `rtsp://IP:554//main?channel=1` | NVR channel 1 |
| Channel 2, main | `rtsp://IP:554//main?channel=2` | NVR channel 2 |
| Channel 1, sub | `rtsp://IP:554//sub?channel=1` | NVR channel 1, low-res |
| Channel 2, sub | `rtsp://IP:554//sub?channel=2` | NVR channel 2, low-res |

## Connecting with VisioForge SDK

Use your Milesight camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Milesight camera, main stream -- note the double slash before "main"
var uri = new Uri("rtsp://192.168.1.90:554//main");
var username = "admin";
var password = "ms1234";
```

For sub-stream access, use `//sub` instead of `//main`. For NVR channel selection, append `?channel=N` to the URL.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| CGI Snapshot | `http://IP/cgi-bin/snapshot.cgi` | Basic auth required |

## Troubleshooting

### Double slash is required

Milesight cameras require a **double forward slash** before the stream path:

- Correct: `rtsp://IP:554//main`
- May not work: `rtsp://IP:554/main`

If your connection fails, verify that you are using the double-slash URL format. This pattern is similar to Pelco and ACTi cameras.

### Default password must be changed

The factory default password is `ms1234`, but Milesight cameras require this password to be changed during first login through the web interface or Milesight CMS. If the default password does not work, the camera has likely been configured with a new password.

### AI features are independent of RTSP

Milesight AI features (face detection, license plate recognition, people counting, intrusion detection) run on the camera's built-in processor and do not affect RTSP streaming. AI metadata and events are delivered through ONVIF events or the Milesight API, not through the RTSP stream itself.

### Milesight CMS is optional

Milesight CMS (Central Management Software) is Milesight's proprietary VMS. It is not required for RTSP streaming. Milesight cameras work with any ONVIF-compatible VMS or any application that supports standard RTSP connections.

### NVR channel numbering

When connecting through a Milesight MS-N NVR, channel numbers start at 1 and correspond to the physical camera input or network camera order configured in the NVR. Use `?channel=1` for the first camera, `?channel=2` for the second, and so on.

### ONVIF discovery

All current Milesight cameras support ONVIF Profile S, G, and T. If you prefer automatic discovery over manual RTSP URL configuration, use ONVIF device discovery to find cameras on your network and retrieve their streaming URLs automatically.

## FAQ

**What is the default RTSP URL for Milesight cameras?**

For all current Milesight cameras, use `rtsp://admin:ms1234@CAMERA_IP:554//main` (note the double slash). For the sub-stream, use `//sub`. For NVR access, append `?channel=N` to select the desired camera channel.

**Do all Milesight models use the same RTSP URL?**

Yes. All current Milesight camera models (MS-C, MS-A, MS-V, MS-F, MS-B series) use the same `//main` and `//sub` URL pattern. This makes Milesight one of the most consistent brands for RTSP integration.

**Does Milesight support H.265?**

Yes. All current Milesight cameras support H.264, H.265, and MJPEG encoding. H.265 can be enabled through the camera's web interface or Milesight CMS to reduce bandwidth and storage requirements.

**Why does the double slash matter in Milesight URLs?**

The double slash (`//main` instead of `/main`) is part of Milesight's RTSP URL specification. Omitting the extra slash may cause connection failures. This convention is shared with a few other camera brands (Pelco, ACTi) but is not universal across the industry.

**Can I access Milesight AI analytics through RTSP?**

No. RTSP delivers the video stream only. AI analytics results (face detection events, license plate data, people counting statistics) are accessible through ONVIF events, the Milesight HTTP API, or Milesight CMS. The video stream itself does not contain embedded AI metadata.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Grandstream Connection Guide](../grandstream/) — SMB / professional camera segment
- [IP Camera Capture to MP4](../../videocapture/video-tutorials/ip-camera-capture-mp4/) — Record Milesight streams to file
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Mobotix RTSP URL Patterns for IP Camera Access in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/mobotix/
**Description:** Connect to MOBOTIX cameras in C# .NET with RTSP URL patterns for classic Mx and MOVE series. Includes MxPEG, MJPEG, and H.264 stream options.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, USB3 Vision / GigE, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Mobotix IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**MOBOTIX** (MOBOTIX AG) is a German IP camera manufacturer headquartered in Langmeil, Germany, founded in 1999. MOBOTIX pioneered the concept of decentralized IP video systems where intelligent processing, recording, and analytics happen directly inside the camera rather than on a central server. The company was acquired by **Konica Minolta** in 2016. MOBOTIX cameras are known for their rugged construction, long operational lifespan, and suitability for industrial, outdoor, and critical infrastructure environments.

**Key facts:**

- **Product lines:** M-series (outdoor), D-series (dome), S-series (hemispheric), Q-series (panoramic), T-series (door station), MOVE (newer ONVIF line)
- **Protocol support:** RTSP, HTTP/CGI, MxPEG (proprietary); ONVIF (MOVE series only)
- **Default RTSP port:** 554
- **Default credentials:** admin / meinsm
- **ONVIF support:** MOVE series only (classic Mx cameras do not support ONVIF)
- **Video codecs:** MxPEG (proprietary), MJPEG, H.264 (newer models)
- **Architecture:** Decentralized, in-camera recording and processing

Classic vs MOVE Series

Classic Mobotix cameras (M/D/S/Q series) primarily use the proprietary MxPEG codec and do not support ONVIF. For ONVIF and standard H.264/H.265 RTSP, use the newer MOBOTIX MOVE series.

About MxPEG

MxPEG is a proprietary video codec developed by MOBOTIX for efficient bandwidth usage with their decentralized architecture. If your application cannot decode MxPEG natively, use the MJPEG fallback stream via HTTP (`/cgi-bin/faststream.jpg`) or configure the camera to output standard MJPEG or H.264 where supported. VisioForge SDK can connect to MOBOTIX cameras using the MJPEG HTTP stream or the H.264 RTSP stream on supported models.

## RTSP URL Patterns

### Standard URL Format

MOBOTIX cameras use branded path-based RTSP URLs:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/mobotix.h264
```

| Stream | URL Pattern | Description |
| --- | --- | --- |
| H.264 main stream | `rtsp://IP:554/mobotix.h264` | Primary H.264 stream (newer models) |
| MJPEG stream | `rtsp://IP:554/mobotix.mjpeg` | MJPEG over RTSP |

### Camera Series and URLs

| Series | Type | Recommended URL | Codec |
| --- | --- | --- | --- |
| MOVE Bullet | IP bullet | `rtsp://IP:554/mobotix.h264` | H.264 |
| MOVE Dome | IP dome | `rtsp://IP:554/mobotix.h264` | H.264 |
| MOVE Vandal Dome | IP vandal-proof | `rtsp://IP:554/mobotix.h264` | H.264 |
| M-series (M73, M16) | Outdoor | `rtsp://IP:554/mobotix.mjpeg` | MJPEG |
| D-series (D16, D26) | Dome | `rtsp://IP:554/mobotix.mjpeg` | MJPEG |
| S-series (S16, S26) | Hemispheric | `rtsp://IP:554/mobotix.mjpeg` | MJPEG |
| Q-series (Q26) | Panoramic 360 | `rtsp://IP:554/mobotix.mjpeg` | MJPEG |
| T-series (T26) | Door station | `rtsp://IP:554/mobotix.mjpeg` | MJPEG |

### MOVE Series ONVIF URLs

MOBOTIX MOVE cameras support standard ONVIF and provide conventional RTSP streams:

| Stream | URL Pattern | Notes |
| --- | --- | --- |
| Main stream | `rtsp://IP:554/mobotix.h264` | H.264 primary stream |
| Sub stream | `rtsp://IP:554/mobotix.mjpeg` | MJPEG secondary stream |

## Connecting with VisioForge SDK

Use your MOBOTIX camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// MOBOTIX MOVE or classic Mx camera, H.264 stream
var uri = new Uri("rtsp://192.168.1.90:554/mobotix.h264");
var username = "admin";
var password = "meinsm";
```

For classic Mx cameras that only support MxPEG, use the MJPEG HTTP stream URL instead (see below).

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| MJPEG Full Resolution | `http://IP/cgi-bin/faststream.jpg?stream=full` | Full resolution continuous MJPEG |
| MxPEG Stream | `http://IP/cgi-bin/faststream.jpg?stream=MxPEG&needlength&fps=6` | Proprietary MxPEG at 6 fps |
| Controlled FPS MJPEG | `http://IP/control/faststream.jpg?stream=full&fps=10` | MJPEG capped at 10 fps |
| Current Snapshot | `http://IP/record/current.jpg` | Single JPEG snapshot |

## Troubleshooting

### Classic Mx camera not connecting via RTSP

Classic MOBOTIX cameras (M, D, S, Q, T series) primarily use the proprietary MxPEG codec. If the RTSP stream fails:

1. Try the MJPEG RTSP URL: `rtsp://IP:554/mobotix.mjpeg`
2. If RTSP is not available, use the HTTP MJPEG stream: `http://IP/cgi-bin/faststream.jpg?stream=full`
3. Check that RTSP is enabled in the camera's web interface under **Admin Menu > Network Setup > RTSP Server**

### "401 Unauthorized" error

MOBOTIX cameras use the default credentials `admin` / `meinsm`. If authentication fails:

1. Access the camera web interface at `http://CAMERA_IP`
2. Log in with the default or configured credentials
3. Verify the user account has streaming access permissions
4. Use the correct credentials in your RTSP URL

### MxPEG stream not decoding

MxPEG is a proprietary codec that standard media players and libraries may not support. Workarounds:

- Use the MJPEG fallback stream via `http://IP/cgi-bin/faststream.jpg?stream=full`
- Configure the camera to output H.264 if the model and firmware support it
- For MOVE series cameras, H.264 RTSP is natively supported

### ONVIF discovery not finding the camera

Only MOBOTIX MOVE series cameras support ONVIF. Classic Mx cameras (M, D, S, Q, T series) do not implement the ONVIF protocol. For classic cameras, connect directly using the RTSP or HTTP URLs listed above.

### Low frame rate on MJPEG streams

MOBOTIX classic cameras may default to low frame rates to conserve bandwidth. To adjust:

1. Open the camera web interface
2. Navigate to **Admin Menu > Image Control > Frame Rate**
3. Increase the maximum frame rate
4. For HTTP streams, specify the desired fps in the URL: `http://IP/control/faststream.jpg?stream=full&fps=15`

## FAQ

**What is the default RTSP URL for MOBOTIX cameras?**

For newer MOBOTIX MOVE cameras, the default URL is `rtsp://admin:meinsm@CAMERA_IP:554/mobotix.h264`. For classic Mx cameras, use `rtsp://admin:meinsm@CAMERA_IP:554/mobotix.mjpeg` or the HTTP MJPEG stream at `http://CAMERA_IP/cgi-bin/faststream.jpg?stream=full`.

**What is MxPEG and do I need it?**

MxPEG is a proprietary video codec developed by MOBOTIX for bandwidth-efficient streaming in their decentralized camera architecture. You do not need MxPEG support to use MOBOTIX cameras with VisioForge SDK. Instead, use the standard MJPEG HTTP stream or H.264 RTSP stream (on supported models) as described on this page.

**Do MOBOTIX cameras support ONVIF?**

Only the MOBOTIX MOVE series supports ONVIF. Classic MOBOTIX cameras (M, D, S, Q, T series) use a proprietary web interface and do not support ONVIF discovery or profiles.

**What is the difference between MOBOTIX classic and MOVE cameras?**

Classic MOBOTIX cameras (M, D, S, Q, T series) use a decentralized architecture with in-camera recording and the proprietary MxPEG codec. MOVE series cameras are MOBOTIX's newer product line that follows industry-standard protocols including ONVIF, H.264, and H.265, making them easier to integrate with third-party VMS and SDK solutions.

**Can I connect to MOBOTIX cameras without ONVIF?**

Yes. All MOBOTIX cameras support direct RTSP or HTTP connections using the URLs listed on this page. ONVIF is not required for basic video streaming.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Basler Connection Guide](../basler/) — Industrial / machine vision cameras
- [FLIR Connection Guide](../flir/) — Industrial and thermal imaging
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## How to Connect to Panasonic (i-PRO) IP Camera in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/panasonic/
**Description:** Panasonic i-PRO and legacy WV/BL/BB camera RTSP URL patterns for C# .NET. ONVIF-compatible integration with VisioForge SDK for all generations.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, IP Camera, RTSP, ONVIF, H.264, H.265, MJPEG, C#

# How to Connect to Panasonic (i-PRO) IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Panasonic i-PRO** (formerly Panasonic Security Systems, now operating as i-PRO Co., Ltd.) is a Japanese manufacturer of professional video surveillance equipment. Originally part of Panasonic Corporation, the security division was spun off as **i-PRO** in 2019. Panasonic/i-PRO cameras are widely deployed in enterprise, government, transportation, and retail environments worldwide.

**Key facts:**

- **Product lines:** WV-S (current S-series), WV-X (X-series AI), WV-SF/SC/SP/SW (mid-generation), WV-NP/NS/NW (legacy professional), BL (consumer/SMB), BB/KX-HCM (legacy consumer)
- **Protocol support:** RTSP, ONVIF (Profile S/G/T), HTTP/CGI, MJPEG, Panasonic proprietary
- **Default RTSP port:** 554
- **Default credentials:** admin / 12345 (current models require password change on first login); legacy BB/BL models often had no default password
- **ONVIF support:** Yes (all current WV-S/WV-X models)
- **Video codecs:** H.264, H.265 (current models), MPEG-4 (legacy), MJPEG

## RTSP URL Patterns

### Current Models (WV-S/WV-X Series, i-PRO)

Current Panasonic i-PRO cameras use the `MediaInput` URL format:

| Stream | RTSP URL | Codec | Notes |
| --- | --- | --- | --- |
| H.264 stream | `rtsp://IP:554/MediaInput/h264` | H.264 | Primary RTSP stream |
| H.265 stream | `rtsp://IP:554/MediaInput/h265` | H.265 | Current models only |
| MPEG-4 stream | `rtsp://IP:554/MediaInput/mpeg4` | MPEG-4 | Legacy fallback |
| ONVIF stream | `rtsp://IP//ONVIF/MediaInput` | H.264 | ONVIF-compatible (note double slash) |

Double slash in ONVIF URLs

Panasonic ONVIF URLs use a double slash before `ONVIF`: `rtsp://IP//ONVIF/MediaInput`. This is intentional and required for ONVIF-based connections.

### Model-Specific URLs

| Model Series | RTSP URL | Generation |
| --- | --- | --- |
| WV-S1131/S1132 | `rtsp://IP:554/MediaInput/h264` | Current (i-PRO) |
| WV-S2131L/S2231L | `rtsp://IP:554/MediaInput/h264` | Current (i-PRO) |
| WV-X1551L/X2251L | `rtsp://IP:554/MediaInput/h264` | Current AI series |
| WV-SF132/SF135/SF138 | `rtsp://IP:554/MediaInput/h264` | Mid-generation |
| WV-SF332/SF335/SF346 | `rtsp://IP:554/MediaInput/h264` | Mid-generation |
| WV-SC384/SC385/SC386 | `rtsp://IP:554/MediaInput/h264` | Mid-generation |
| WV-SP105/SP306/SP508 | `rtsp://IP:554/MediaInput/h264` | Mid-generation |
| WV-SW115/SW155/SW175 | `rtsp://IP:554/MediaInput/h264` | Mid-generation outdoor |
| WV-SW316/SW352/SW355 | `rtsp://IP:554/MediaInput/h264` | Mid-generation outdoor |
| WV-SW395/SW396/SW458 | `rtsp://IP:554/MediaInput/h264` | Mid-generation outdoor |
| WV-SW558/SW559/SW598 | `rtsp://IP:554/MediaInput/h264` | Mid-generation outdoor |
| WV-ST162/ST165 | `rtsp://IP:554/MediaInput/h264` | Mid-generation PTZ |
| WV-NP240/NP244/NP304 | `rtsp://IP:554/MediaInput/mpeg4` | Legacy professional |
| WV-NP502/NP1000/NP1004 | `rtsp://IP:554/MediaInput/mpeg4` | Legacy professional |
| WV-NS202/NS324/NS954 | `rtsp://IP:554/MediaInput/mpeg4` | Legacy PTZ |
| WV-NW484/NW502/NW960/NW964 | `rtsp://IP:554/MediaInput/mpeg4` | Legacy outdoor |

### Legacy Consumer Models (BB/BL/KX Series)

Older Panasonic consumer cameras used different URL patterns:

| Model Series | RTSP URL | Codec | Notes |
| --- | --- | --- | --- |
| BL-C210/C230 | `rtsp://IP:554/MediaInput/h264` | H.264 | Late consumer models |
| BL-C210/C230 | `rtsp://IP:554/MediaInput/mpeg4` | MPEG-4 | MPEG-4 fallback |
| BL-VP101/VP104 | `rtsp://IP:554/MediaInput/h264` | H.264 | Compact |
| BB-HCM531A/735 | `rtsp://IP/nphMpeg4/g726-640x48` | MPEG-4 | Very old format |
| BB/BL/KX (HTTP only) | `http://IP/nphMotionJpeg?Resolution=640x480&Quality=Standard` | MJPEG | HTTP MJPEG stream |

Legacy BB/BL cameras

Many older Panasonic BB and BL series cameras do not support RTSP at all. They only provide HTTP-based MJPEG and JPEG snapshot streams. Current i-PRO cameras fully support RTSP.

### Encoder/DVR URLs

| Device | RTSP URL | Notes |
| --- | --- | --- |
| WJ-GXE500 encoder | `http://IP/cgi-bin/camera` | MJPEG via HTTP |
| WJ-HD220 DVR | `http://IP/cgi-bin/jpeg` | Snapshot from DVR |
| WJ-ND400 NVR | `http://IP/cgi-bin/jpeg` | Snapshot from NVR |
| WJ-NV200 NVR | `http://IP/cgi-bin/checkimage.cgi?UID=USER&CAM=CHANNEL` | Channel snapshot |

## Connecting with VisioForge SDK

Use your Panasonic camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Panasonic i-PRO camera, H.264 stream
var uri = new Uri("rtsp://192.168.1.80:554/MediaInput/h264");
var username = "admin";
var password = "YourPassword";
```

For H.265, use `/MediaInput/h265` instead.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| MJPEG Stream (current) | `http://IP/cgi-bin/mjpeg?stream=1` | Current WV-S/WV-X models |
| JPEG Snapshot | `http://IP/cgi-bin/camera` | Current models |
| Snapshot (sized) | `http://IP/SnapshotJPEG?Resolution=640x480` | Mid-generation models |
| Snapshot (quality) | `http://IP/SnapShotJPEG?Resolution=320x240&Quality=Motion` | Legacy models |
| MJPEG Stream (legacy) | `http://IP/nphMotionJpeg?Resolution=640x480&Quality=Standard` | BB/BL/KX models |
| Server push | `http://IP/cgi-bin/nphContinuousServerPush` | Continuous JPEG push |

## Troubleshooting

### Brand name confusion

The Panasonic security camera brand has evolved:

- **Panasonic** (before 2019): Full Panasonic branding
- **i-PRO** (2019-present): Spun off from Panasonic as i-PRO Co., Ltd.
- Current products are branded **i-PRO** but many users still search for "Panasonic camera"

All use compatible RTSP URL patterns within their generation.

### MediaInput/h264 vs ONVIF/MediaInput

- Use `rtsp://IP:554/MediaInput/h264` for direct RTSP connections (recommended)
- Use `rtsp://IP//ONVIF/MediaInput` for ONVIF-compatible connections (note the double slash)
- Both provide the same video stream but use different authentication mechanisms

### Legacy cameras without RTSP

Many older Panasonic BB-series and BL-series cameras (particularly BL-C1, BL-C10, BL-C30, BL-C101, BL-C111, BL-C131 and earlier) do not support RTSP. These cameras only provide:

- HTTP MJPEG: `http://IP/nphMotionJpeg?Resolution=640x480&Quality=Standard`
- HTTP Snapshot: `http://IP/SnapshotJPEG?Resolution=320x240`

### MPEG-4 vs H.264

Legacy WV-NP/NS/NW series cameras may only support MPEG-4 over RTSP. Try `MediaInput/mpeg4` if `MediaInput/h264` fails on older models.

## FAQ

**What is the default RTSP URL for Panasonic/i-PRO cameras?**

For current i-PRO cameras, use `rtsp://admin:password@CAMERA_IP:554/MediaInput/h264`. For ONVIF connections, use `rtsp://CAMERA_IP//ONVIF/MediaInput`. Legacy models may need `MediaInput/mpeg4`.

**Is Panasonic the same as i-PRO?**

Yes. Panasonic's security camera division was spun off as i-PRO Co., Ltd. in 2019. Current cameras are branded i-PRO, but use the same RTSP URL patterns as late-generation Panasonic WV-series cameras.

**Do Panasonic cameras support H.265?**

Current i-PRO cameras (WV-S and WV-X series) support H.265. Use `rtsp://IP:554/MediaInput/h265` for the H.265 stream. Mid-generation and older models support H.264 and MPEG-4 only.

**Can I connect to legacy Panasonic BB/BL cameras?**

Many older BB and BL series cameras don't support RTSP and only provide HTTP MJPEG streams. Use the HTTP MJPEG URL `http://IP/nphMotionJpeg?Resolution=640x480&Quality=Standard` with an HTTP source instead of RTSP.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Sanyo Connection Guide](../sanyo/) — Acquired by Panasonic, predecessor product line
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Pelco IP Camera RTSP URL Patterns and C# .NET Setup
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/pelco/
**Description:** Pelco Sarix and Spectra PTZ camera RTSP integration for C# .NET. URL patterns for IX, IMP, IME models with ONVIF support and VisioForge SDK code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MJPEG, C#

# How to Connect to Pelco IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Pelco** (now part of **Motorola Solutions**) is a leading manufacturer of professional video surveillance equipment, headquartered in Fresno, California. Pelco is particularly strong in enterprise, government, and critical infrastructure markets. The brand is known for its **Sarix** fixed camera line and **Spectra** PTZ camera line. Motorola Solutions acquired Pelco in 2020.

**Key facts:**

- **Product lines:** Sarix (Professional/Enhanced/Value fixed cameras), Spectra (Professional PTZ), IX (fixed box), IMP/IME (mini dome), D-series (dome PTZ)
- **Protocol support:** RTSP, ONVIF (Profile S/G/T), HTTP/CGI, Pelco D/P serial protocol
- **Default RTSP port:** 554
- **Default credentials:** admin / admin (must be changed on first login for current models)
- **ONVIF support:** Yes (all current Sarix and Spectra models)
- **Video codecs:** H.264, H.265 (Sarix Professional), MJPEG

Double slash in RTSP URLs

Pelco cameras consistently use a **double forward slash** before the stream path: `rtsp://IP:554//stream1`. This is intentional and required for most Pelco models.

## RTSP URL Patterns

### Current Models (Sarix Professional/Enhanced/Value)

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Main stream | `rtsp://IP:554//stream1` | Full resolution (note double slash) |
| Sub stream | `rtsp://IP:554//stream2` | Lower resolution |
| Low-res stream | `rtsp://IP:554/LowResolutionVideo` | Lowest quality |
| Channel stream | `rtsp://IP:554/stream1` | Single slash (some models) |
| Numbered channel | `rtsp://IP:554/1/stream1` | Channel-specific |

### Model-Specific URLs

| Model Series | RTSP URL | Type | Notes |
| --- | --- | --- | --- |
| Sarix Pro (IMP/IME) | `rtsp://IP:554//stream1` | Fixed dome | Current generation |
| Sarix Enhanced (IX) | `rtsp://IP:554//stream1` | Fixed box | Mid-range |
| Sarix Value | `rtsp://IP:554//stream1` | Fixed | Entry-level |
| IX10 | `rtsp://IP:554//stream1` | Fixed box | Professional |
| IX30C / IX30DN | `rtsp://IP:554//stream1` | Fixed box | Day/night |
| IXDN30 | `rtsp://IP:554//stream1` | Fixed box | Day/night |
| IXE10LW | `rtsp://IP:554//stream1` | Fixed dome | Wireless |
| IXE20DN | `rtsp://IP:554//stream1` | Fixed dome | Day/night |
| IXP31 | `rtsp://IP:554//stream1` | Fixed dome | Professional |
| IMP519 | `rtsp://IP:554//stream1` | Mini dome | 5MP |
| IMP1110-1 / IMP1110-1E | `rtsp://IP:554//stream1` | Mini dome | Sarix Pro |
| IM10C10 | `rtsp://IP:554//stream1` | Multi-sensor | Sarix IMM |
| IM10DN10-1E | `rtsp://IP:554//stream1` | Multi-sensor | Day/night |
| D5230-ADFRZ28 | `rtsp://IP:554//stream1` | PTZ dome | Spectra |
| Spectra IV | `rtsp://IP:554//stream1` | PTZ dome | Legacy PTZ |
| Spectra Professional | `rtsp://IP:554//stream1` | PTZ dome | Current PTZ |

### Multi-Channel / Multi-Sensor

For multi-channel Pelco devices:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Channel 1, main | `rtsp://IP:554/1/stream1` | First sensor/channel |
| Channel 2, main | `rtsp://IP:554/2/stream1` | Second sensor/channel |
| Channel stream (alt) | `rtsp://IP:554/stream1` | Single channel (some models) |

### Legacy Models

| Model | URL | Notes |
| --- | --- | --- |
| IP110 / IP-110 | `http://IP/api/jpegControl.php?frameRate=10` | JPEG stream |
| Spectra IV (HTTP) | `http://IP/jpeg` | JPEG snapshot |
| Spectra IV (pull) | `http://IP/jpeg/pull` | Continuous JPEG |
| Spectra IV (API) | `http://IP/api/jpegControl.php?frameRate=10` | Frame-rate JPEG |

## Connecting with VisioForge SDK

Use your Pelco camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Pelco Sarix camera, main stream
var uri = new Uri("rtsp://192.168.1.85:554//stream1");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `//stream2` instead. For multi-sensor cameras, use `/1/stream1` for channel selection.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/jpeg` | Most current models |
| JPEG (channel) | `http://IP/jpeg?id=1` | Channel-specific |
| JPEG (API) | `http://IP/api/jpegControl.php?frameRate=10` | Legacy models |
| JPEG (tmpfs) | `http://IP/tmpfs/auto.jpg` | Auto-capture |
| Image file | `http://IP/img.jpg` | Simple snapshot |

## Troubleshooting

### Double slash is required

Most Pelco cameras require a **double forward slash** before the stream path:

- Correct: `rtsp://IP:554//stream1`
- May not work: `rtsp://IP:554/stream1`

If a single-slash URL fails, always try the double-slash variant first.

### Channel numbering for multi-sensor

Pelco multi-sensor cameras (IM10-series, Sarix IMM) use numbered channel paths:

- `rtsp://IP:554/1/stream1` — first sensor
- `rtsp://IP:554/2/stream1` — second sensor

Single-sensor cameras should use `//stream1` without a channel number.

### Pelco D/P protocol vs RTSP

Pelco is also known for the **Pelco D** and **Pelco P** serial communication protocols used to control PTZ cameras. These are serial protocols for PTZ control, not video streaming. Video streaming always uses RTSP or HTTP regardless of which PTZ control protocol is used.

### Spectra PTZ cameras

Pelco Spectra PTZ cameras use the same RTSP URL format (`//stream1`) as fixed cameras. PTZ control is handled separately via ONVIF PTZ commands or Pelco D/P serial protocol, not through the RTSP URL.

## FAQ

**What is the default RTSP URL for Pelco cameras?**

For most Pelco cameras, use `rtsp://admin:password@CAMERA_IP:554//stream1` (note the double slash). For the sub-stream, use `//stream2`. Multi-sensor models use `/1/stream1` for channel-specific access.

**Is Pelco still an independent company?**

No. Pelco was acquired by Motorola Solutions in 2020. Current Pelco cameras are manufactured and supported by Motorola Solutions. The Pelco brand and product lines (Sarix, Spectra) continue under Motorola Solutions' video security portfolio.

**Do Pelco cameras support ONVIF?**

Yes. All current Pelco Sarix and Spectra cameras support ONVIF Profile S, G, and T. ONVIF is the recommended discovery and configuration method for new Pelco integrations.

**What is the difference between Pelco D and RTSP?**

Pelco D (and Pelco P) are serial protocols for PTZ camera control (pan, tilt, zoom commands). RTSP is the video streaming protocol. You use RTSP for video and Pelco D/ONVIF for PTZ control — they serve different purposes and are not interchangeable.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Avigilon Connection Guide](../avigilon/) — Also Motorola Solutions, enterprise cameras
- [Honeywell Connection Guide](../honeywell/) — Enterprise surveillance cameras
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## How to Connect to Q-See IP Camera & DVR in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/q-see/
**Description:** Q-See QC, QCN, and QS series camera and DVR RTSP URL patterns for C# .NET. Default credentials, channel setup, and VisioForge SDK integration code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Q-See IP Camera & DVR in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Q-See** was an American consumer surveillance brand based in Anaheim, California. Q-See DVRs and IP cameras were popular budget surveillance systems sold through major US retailers including Costco and Amazon. The company became essentially defunct by 2020, but a large number of Q-See systems remain deployed in homes and businesses. Q-See products used a mix of **Dahua OEM cameras** and components from other Chinese manufacturers, meaning most Q-See devices follow Dahua RTSP URL conventions.

**Key facts:**

- **Product lines:** QC Series (DVRs), QCN Series (IP cameras), QS Series (DVR kits)
- **Protocol support:** RTSP, HTTP/CGI, ONVIF (some IP camera models)
- **Default RTSP port:** 554
- **Default credentials:** admin / admin or admin / 123456
- **ONVIF support:** Some IP camera models (QCN series)
- **Video codecs:** H.264 (most models), MPEG-4 (older DVRs)
- **OEM base:** Mix of Dahua and other manufacturers

Q-See Is Defunct

Q-See ceased operations around 2020. No firmware updates, technical support, or cloud services are available. If you are integrating Q-See hardware, treat it as Dahua-compatible equipment and try Dahua URL patterns first. See our [Dahua connection guide](../dahua/) for additional details.

## RTSP URL Patterns

### Standard URL Format (Dahua-Based)

Most Q-See devices use the Dahua `cam/realmonitor` URL pattern:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/cam/realmonitor?channel=1&subtype=0
```

| Parameter | Value | Description |
| --- | --- | --- |
| `channel` | 1, 2, 3... | Camera channel (1 for standalone cameras, 1-N for DVR channels) |
| `subtype` | 0 | Main stream (highest resolution) |
| `subtype` | 1 | Sub stream (lower resolution, less bandwidth) |

### DVR Models (QC Series, QS Series)

| Model / Series | Main Stream URL | Notes |
| --- | --- | --- |
| QC-804 (4-ch DVR) | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Dahua format, change `channel` for each input |
| QS408 / QS411 (DVR kits) | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Dahua format |
| Various DVRs | `rtsp://IP:554/` | Root stream (fallback) |
| Various DVRs | `rtsp://IP:554/live.sdp` | Live SDP stream |
| Various DVRs | `rtsp://IP:554/ch0_unicast_firststream` | Unicast first stream |

### IP Camera Models (QCN Series)

| Model | Resolution | URL | Notes |
| --- | --- | --- | --- |
| QCN7001B | 1080p | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Dahua format (recommended) |
| QCN7001B | 1080p | `rtsp://IP:554/PSIA/Streaming/channels/0?videoCodecType=H.264` | PSIA format |
| QCN7001B | 1080p | `rtsp://IP:554/VideoInput/1/h264/1` | VideoInput H.264 |
| QCN7001B | 1080p | `rtsp://IP:554/VideoInput/1/mpeg4/1` | VideoInput MPEG-4 |
| QCN7005B | 1080p | `rtsp://IP:554/` | Root stream |

### Alternative URL Formats

Some Q-See devices support additional URL patterns:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Standard Dahua format (recommended) |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` | Sub stream (lower bandwidth) |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=00&authbasic=BASE64` | With base64-encoded credentials |
| `rtsp://IP:554/` | Root stream (fallback for many models) |
| `rtsp://IP:554/live.sdp` | Live SDP format |
| `rtsp://IP:554/ch0_unicast_firststream` | Unicast first stream |

Base64 Authentication

The `authbasic=` parameter used in some Q-See URLs takes base64-encoded credentials in the format `username:password`. For example, `admin:admin` encodes to `YWRtaW46YWRtaW4=`.

### DVR Channel URLs

For Q-See multi-channel DVRs (QC-804, QS408, QS411, etc.):

| Channel | Main Stream | Sub Stream |
| --- | --- | --- |
| Camera 1 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` |
| Camera 2 | `rtsp://IP:554/cam/realmonitor?channel=2&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=2&subtype=1` |
| Camera N | `rtsp://IP:554/cam/realmonitor?channel=N&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=N&subtype=1` |

## Connecting with VisioForge SDK

Use your Q-See camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Q-See QC-804 DVR, channel 1 main stream
var uri = new Uri("rtsp://192.168.1.100:554/cam/realmonitor?channel=1&subtype=0");
var username = "admin";
var password = "admin";
```

For sub-stream access, use `subtype=1` instead of `subtype=0`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| CGI Snapshot | `http://IP/cgi-bin/snapshot.cgi?chn=1&u=USER&p=PASS` | Channel-based snapshot with credentials |
| Login-Based Snapshot | `http://IP/cgi-bin/snapshot.cgi?loginuse=USER&loginpas=PASS` | Login parameter-based snapshot |
| Still Image | `http://IP/stillimg1.jpg` | Replace `1` with channel number |
| Stream Image | `http://IP/images/stream_1.jpg` | Replace `1` with channel number |
| Fast Stream (QS Series) | `http://IP/control/faststream.jpg?stream=MxPEG&needlength&fps=6` | Continuous fast stream |

## Troubleshooting

### No firmware updates or support

Q-See ceased operations around 2020. There are no firmware updates, no technical support, and no replacement parts available. If your Q-See device has a security vulnerability or bug, it cannot be patched. Consider upgrading to a currently supported camera brand.

### Try Dahua URL patterns first

Most Q-See DVRs and many IP cameras use Dahua firmware internally. If the Q-See-specific URLs listed above do not work, try the standard Dahua `cam/realmonitor` format. See our [Dahua connection guide](../dahua/) for the full set of Dahua URL patterns.

### Base64 authentication parameter

Some Q-See devices use an `authbasic=` parameter in the RTSP URL instead of embedding credentials in the URI. Encode `username:password` as base64:

- `admin:admin` = `YWRtaW46YWRtaW4=`
- `admin:123456` = `YWRtaW46MTIzNDU2`

### Port forwarding for remote access

Q-See DVRs typically require manual port forwarding for remote RTSP access. Forward port **554** (RTSP) and optionally port **80** or **8080** (HTTP) on your router to the DVR's local IP address.

### Default credentials

Q-See devices commonly ship with one of these credential pairs:

- `admin` / `admin`
- `admin` / `123456`

If neither works, the password may have been changed by the previous owner or installer.

## FAQ

**What RTSP URL format do Q-See cameras use?**

Most Q-See devices use the Dahua `cam/realmonitor` format: `rtsp://admin:password@CAMERA_IP:554/cam/realmonitor?channel=1&subtype=0`. This is because Q-See cameras and DVRs were primarily OEM versions of Dahua hardware. Use `channel=1` for standalone cameras or the appropriate channel number for DVR inputs.

**Are Q-See cameras still supported?**

No. Q-See ceased operations around 2020. No firmware updates, cloud services, or technical support are available. The hardware still functions, but there will be no future patches or improvements. Many users have migrated to other brands like Amcrest or Reolink that use similar Dahua-based protocols.

**Can I use Q-See cameras with ONVIF?**

Some Q-See IP cameras (QCN series) support ONVIF, but most Q-See DVRs do not. If ONVIF discovery fails, use the direct RTSP URL patterns listed above instead.

**What is the default password for Q-See cameras?**

The default credentials are typically `admin` / `admin` or `admin` / `123456`. Since Q-See is no longer available, there is no official password reset tool. A factory reset (usually a pinhole button on the device) will restore default credentials on most models.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Dahua Connection Guide](../dahua/) — Same URL format for most Q-See devices
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Reolink IP Camera RTSP Connection Guide for C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/reolink/
**Description:** Reolink RLC, E1, Argus, CX, and Duo series RTSP URL patterns for C# .NET. Stream and record using VisioForge SDK with ONVIF discovery support.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, H.265, C#

# How to Connect to Reolink IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Reolink** (Reolink Digital Technology Co., Ltd.) is a consumer and prosumer IP camera manufacturer headquartered in Hong Kong. Founded in 2009, Reolink has grown rapidly through direct-to-consumer sales on Amazon and their own website, offering competitively priced cameras with straightforward RTSP access. Reolink is notable for clear documentation of RTSP URLs and easy integration with third-party software.

**Key facts:**

- **Product lines:** RLC series (PoE wired), RLN series (NVRs), E1 series (Wi-Fi pan/tilt), Argus series (battery/solar), CX series (ColorX night vision), Duo series (dual-lens), TrackMix (auto-tracking)
- **Protocol support:** RTSP, ONVIF, HTTP/HTTPS, proprietary Reolink protocol
- **Default RTSP port:** 554
- **Default credentials:** admin / (blank password or set during setup)
- **ONVIF support:** Yes (most current models, may require enabling in camera settings)
- **Video codecs:** H.264 (all models), H.265 (most current models)

## RTSP URL Patterns

Reolink uses a consistent URL pattern across most models. The main difference is between cameras and NVRs (which use channel numbers).

### Camera RTSP URLs

| Stream | RTSP URL | Resolution | Notes |
| --- | --- | --- | --- |
| Main (clear) | `rtsp://IP:554/h264Preview_01_main` | Full (up to 4K/8MP) | H.264 main stream |
| Sub (fluent) | `rtsp://IP:554/h264Preview_01_sub` | Reduced (640x360) | Lower bandwidth |

H.265 streams

For cameras with H.265 enabled, the URL remains the same (`h264Preview_01_main`). The `h264` in the URL path is not codec-specific -- it works for both H.264 and H.265 streams.

### NVR Channel URLs

For Reolink NVRs (RLN8-410, RLN16-410, RLN36, etc.), append the channel number:

| Channel | Main Stream URL | Sub Stream URL |
| --- | --- | --- |
| Channel 1 | `rtsp://IP:554/h264Preview_01_main` | `rtsp://IP:554/h264Preview_01_sub` |
| Channel 2 | `rtsp://IP:554/h264Preview_02_main` | `rtsp://IP:554/h264Preview_02_sub` |
| Channel 3 | `rtsp://IP:554/h264Preview_03_main` | `rtsp://IP:554/h264Preview_03_sub` |
| Channel N | `rtsp://IP:554/h264Preview_0N_main` | `rtsp://IP:554/h264Preview_0N_sub` |

### Models and Resolutions

| Model | Resolution | Codec | Wi-Fi | RTSP |
| --- | --- | --- | --- | --- |
| RLC-410 | 2560x1440 (4MP) | H.264/H.265 | No (PoE) | Yes |
| RLC-510A | 2560x1920 (5MP) | H.264/H.265 | No (PoE) | Yes |
| RLC-520A | 2560x1920 (5MP) | H.264/H.265 | No (PoE) | Yes |
| RLC-810A | 3840x2160 (8MP) | H.264/H.265 | No (PoE) | Yes |
| RLC-811A | 3840x2160 (8MP) | H.264/H.265 | No (PoE) | Yes |
| RLC-820A | 3840x2160 (8MP) | H.264/H.265 | No (PoE) | Yes |
| RLC-1212A | 4512x2512 (12MP) | H.264/H.265 | No (PoE) | Yes |
| E1 Zoom | 2560x1920 (5MP) | H.264/H.265 | Yes | Yes |
| E1 Pro | 2560x1440 (4MP) | H.264 | Yes | Yes |
| E1 Outdoor | 2560x1920 (5MP) | H.264/H.265 | Yes | Yes |
| CX410 | 2560x1440 (4MP) | H.264/H.265 | No (PoE) | Yes |
| CX810 | 3840x2160 (8MP) | H.264/H.265 | No (PoE) | Yes |
| TrackMix PoE | 3840x2160 (8MP) | H.264/H.265 | No (PoE) | Yes |
| Duo 2 PoE | 4608x1728 (8MP) | H.264/H.265 | No (PoE) | Yes |
| Argus 3 Pro | 2560x1440 (4MP) | H.264 | Yes (battery) | Yes |

Argus battery cameras

Argus series battery-powered cameras support RTSP but drain the battery quickly when streaming continuously. Use RTSP only for testing or event-triggered recording, not 24/7 monitoring.

## Connecting with VisioForge SDK

Use your Reolink camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Reolink RLC-810A, main stream
var uri = new Uri("rtsp://192.168.1.88:554/h264Preview_01_main");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `h264Preview_01_sub` instead of `h264Preview_01_main`. For NVR channels, change the channel number (e.g., `h264Preview_03_main` for channel 3).

## Snapshot URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/api.cgi?cmd=Snap&channel=0&rs=abc123&user=USER&password=PASS` | API-based snapshot |

## Troubleshooting

### RTSP not working -- "Connection refused"

RTSP may need to be enabled on some Reolink models:

1. Open the **Reolink app** or web interface
2. Go to **Settings > Network > Advanced > Port Settings**
3. Ensure **RTSP port** is enabled and set to 554
4. Some older firmware versions have RTSP disabled by default

### H.265 stream not decoding

If your Reolink camera is configured for H.265 and the stream fails to decode:

- The SDK supports H.265 natively, but ensure you're using a recent SDK version
- Try switching the camera to H.264 in **Settings > Display > Encode** as a workaround
- The RTSP URL path (`h264Preview`) remains the same regardless of the actual codec

### Sub stream shows low quality

The sub stream (`h264Preview_01_sub`) is intentionally lower resolution (typically 640x360) to reduce bandwidth. Use `h264Preview_01_main` for full resolution. You can adjust sub stream quality in the Reolink app under Display settings.

### NVR channel numbering

Reolink NVR channels are 1-indexed with zero-padded two-digit format: `01`, `02`, `03`... `16`. Channel 0 does not exist.

## FAQ

**What is the default RTSP URL for Reolink cameras?**

The URL is `rtsp://admin:password@CAMERA_IP:554/h264Preview_01_main` for the main stream and `h264Preview_01_sub` for the sub stream. The password is whatever you set during camera setup.

**Does the RTSP URL change when using H.265?**

No. The URL path `h264Preview_01_main` is used for both H.264 and H.265 streams. The `h264` in the path is a legacy naming convention, not a codec selector.

**Can I access Reolink cameras remotely via RTSP?**

RTSP is designed for local network access. For remote access, you would need to set up port forwarding on your router (forward port 554 to the camera's IP) or use a VPN. Reolink's cloud/P2P access uses a proprietary protocol, not RTSP.

**Do Reolink Duo cameras have separate RTSP streams for each lens?**

Yes. Reolink Duo cameras expose the wide-angle lens on the standard channel and may provide additional streams. Check your specific model's documentation for dual-lens stream access.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Amcrest Connection Guide](../amcrest/) — Consumer alternative with RTSP
- [TP-Link Connection Guide](../tp-link/) — Budget cameras with native RTSP
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Rhombus Camera RTSP URL and Cloud API C# Integration
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/rhombus/
**Description:** Rhombus camera integration options in C# .NET. Cloud-managed architecture, API access, and alternative approaches for Rhombus Systems cameras.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, C#

# How to Connect to Rhombus Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Rhombus Systems** (Rhombus, Inc.) is an American cloud-managed video security company headquartered in Sacramento, California. Founded in 2016, Rhombus provides enterprise cameras, sensors, and access control with a cloud-first management platform. Similar to Verkada, Rhombus cameras are managed through a centralized cloud console.

**Key facts:**

- **Product lines:** R-series (dome), R-series Pro (advanced), R-series Mini (compact)
- **Architecture:** Cloud-managed with on-camera AI processing
- **RTSP support:** Limited — available on some models via LAN configuration
- **ONVIF support:** No
- **Video codecs:** H.264, H.265
- **API access:** Rhombus API (REST, requires subscription)
- **On-camera storage:** Yes (local SD card for edge storage)

Limited Local Streaming

Some Rhombus camera models support RTSP for local LAN streaming, but this feature must be enabled through the Rhombus console and is not available on all models or subscription tiers. Check your Rhombus account settings for RTSP availability.

## RTSP Access (Where Available)

### Enabling RTSP

On supported Rhombus cameras:

1. Log in to the **Rhombus Console** (console.rhombus.com)
2. Navigate to your camera's settings
3. Look for **Local Streaming** or **RTSP** settings
4. Enable RTSP and note the provided URL

### RTSP URL Format

When RTSP is available:

```
rtsp://[IP]:554/live
```

The exact URL format and authentication method depend on the camera model and firmware version. The Rhombus console will provide the specific URL when RTSP is enabled.

## Connecting with VisioForge SDK

If RTSP is available on your Rhombus camera, use the URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Rhombus camera with RTSP enabled
var uri = new Uri("rtsp://192.168.1.90:554/live");
var username = "admin";
var password = "YourPassword"; // from Rhombus console
```

## Integration via Rhombus API

For cameras without RTSP access, Rhombus provides a REST API that offers:

- Camera listing and status
- Video clip export and download
- Snapshot/thumbnail retrieval
- Event and analytics data
- Webhook notifications

The API does not provide real-time RTSP streams. It is designed for clip retrieval, metadata access, and automation workflows.

## Troubleshooting

### RTSP not available on my camera

Not all Rhombus cameras or subscription tiers support RTSP. Contact Rhombus support to verify RTSP availability for your specific camera model and plan.

### RTSP stream disconnects

Rhombus cameras prioritize cloud connectivity. If the local RTSP stream is unstable:

1. Ensure the camera has sufficient network bandwidth for both cloud and local streams
2. Use the sub stream for lower bandwidth requirements
3. Check the Rhombus console for firmware updates

## FAQ

**Do Rhombus cameras support RTSP?**

Some Rhombus cameras support RTSP for local LAN streaming, but it must be enabled through the Rhombus console and may not be available on all models or subscription tiers. Contact Rhombus support for specifics.

**Can I use VisioForge SDK with Rhombus cameras?**

If your Rhombus camera has RTSP enabled, yes. Use the RTSP URL from the Rhombus console with VisioForge SDK's RTSP source. For cameras without RTSP, you would need to use the Rhombus REST API separately for clip and snapshot access.

**How does Rhombus compare to Verkada?**

Both are cloud-managed platforms. Rhombus offers RTSP on some models, while Verkada does not support RTSP at all. Both provide REST APIs for clip/snapshot access. See our [Verkada guide](../verkada/) for comparison.

**What are good alternatives to Rhombus with full RTSP support?**

For enterprise cameras with native RTSP and ONVIF support, consider [Axis](../axis/), [Bosch](../bosch/), [Hanwha Vision](../hanwha/), or [Avigilon](../avigilon/).

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Verkada Connection Guide](../verkada/) — Another cloud-managed platform
- [Axis Connection Guide](../axis/) — Enterprise alternative with full RTSP
- [Hanwha Vision Connection Guide](../hanwha/) — Enterprise alternative with RTSP
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## How to Connect to Samsung (Hanwha) IP Camera in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/samsung/
**Description:** Samsung Wisenet SNO, SND, XNO, XND, and PNO camera RTSP URL patterns for C# .NET. Hanwha Vision integration with VisioForge SDK code samples.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, H.265, MJPEG, C#

# How to Connect to Samsung (Hanwha) IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Hanwha Vision** (formerly Samsung Techwin, then Hanwha Techwin) is a South Korean manufacturer of professional and enterprise-grade video surveillance equipment. The Samsung security camera brand was rebranded to **Wisenet** after Hanwha Group acquired Samsung Techwin in 2015. Hanwha Vision cameras are widely deployed in enterprise, government, and critical infrastructure installations worldwide.

**Key facts:**

- **Product lines:** XNO/XND/XNV (X-series, current flagship), PNO/PND/PNV (P-series, mainstream), QNO/QND/QNV (Q-series, value), SNO/SND/SNV/SNB (S-series, legacy Samsung)
- **Naming convention:** First letter = series, N = network, O = outdoor, D = dome, V = vandal-resistant, B = box, P = PTZ
- **Protocol support:** RTSP, ONVIF (Profile S/G/T), HTTP/CGI, Wisenet WAVE VMS
- **Default RTSP port:** 554
- **Default credentials:** admin / (set during initial setup); legacy Samsung models: admin / 4321
- **ONVIF support:** Yes (all current and most legacy models)
- **Video codecs:** H.264, H.265, MJPEG

## RTSP URL Patterns

### Current Models (Wisenet X/P/Q Series)

Current Hanwha Vision cameras use a profile-based URL format:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Profile 1 (main) | `rtsp://IP:554/profile2/media.smp` | Main stream, H.264/H.265 |
| Profile 2 (sub) | `rtsp://IP:554/profile3/media.smp` | Sub stream |
| ONVIF Profile 1 | `rtsp://IP:554//onvif/profile1/media.smp` | ONVIF-compatible (note double slash) |
| ONVIF Profile 2 | `rtsp://IP:554//onvif/profile2/media.smp` | ONVIF sub stream |

Double slash in ONVIF URLs

Samsung/Hanwha ONVIF URLs use a double slash (`//onvif/`). This is intentional and required. Using a single slash will fail.

### Legacy Samsung S-Series

| Model Series | RTSP URL | Codec |
| --- | --- | --- |
| SNB-xxxx (box) | `rtsp://IP:554/profile2/media.smp` | H.264 |
| SND-xxxx (dome) | `rtsp://IP:554/profile2/media.smp` | H.264 |
| SNO-xxxx (outdoor) | `rtsp://IP:554/profile2/media.smp` | H.264 |
| SNV-xxxx (vandal) | `rtsp://IP:554/profile2/media.smp` | H.264 |
| SNP-xxxx (PTZ) | `rtsp://IP:554/profile2/media.smp` | H.264 |

### Older Samsung Models (Pre-Wisenet)

Older Samsung cameras used different URL formats:

| URL Pattern | Models | Codec |
| --- | --- | --- |
| `rtsp://IP:554/mpeg4unicast` | SNB-2000, SNC-1300, SNP-3301/3370 | MPEG-4 |
| `rtsp://IP:554/h264unicast` | SNP-3301/H, SNP-3370/TH | H.264 |
| `rtsp://IP:554/mjpegunicast` | SNP-3301/H, SNP-3370/TH | MJPEG |
| `rtsp://IP:554/H264/media.smp` | SNB-3000, SND-3080, SNV-3080/3081 | H.264 |
| `rtsp://IP:554/MPEG4/media.smp` | SNV-3080/3081 | MPEG-4 |
| `rtsp://IP:554/MJPEG/media.smp` | SNB-3000, SNV-3081, SNV-6084R | MJPEG |
| `rtsp://IP:554/MediaInput/h264` | Misc. Samsung | H.264 |

### DVR/NVR URLs

| Device | RTSP URL | Notes |
| --- | --- | --- |
| SRD-165 DVR | `rtsp://IP:558/` | Non-standard port 558 |
| SME DVR | `rtsp://IP:554/mpeg4unicast` | MPEG-4 |
| SMT DVR | `rtsp://IP:554/mpeg4unicast` | MPEG-4 |

## Connecting with VisioForge SDK

Use your Samsung (Hanwha Wisenet) camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Hanwha Wisenet X-series camera, main stream
var uri = new Uri("rtsp://192.168.1.70:554/profile2/media.smp");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `profile3/media.smp` instead of `profile2/media.smp`. For legacy Samsung S-series models, use the default password `4321` and URL path `/mpeg4unicast` or `/H264/media.smp`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/video.cgi?msubmenu=jpg` | Current models |
| MJPEG Stream | `http://IP/cgi-bin/video.cgi?msubmenu=mjpg` | Current models |
| Legacy Snapshot | `http://IP/video?submenu=jpg` | Pre-Wisenet models |
| Legacy MJPEG | `http://IP/video?submenu=mjpg` | Pre-Wisenet models |
| CGI Snapshot | `http://IP/cgi-bin/webra_fcgi.fcgi?api=get_jpeg_raw&chno=CHANNEL` | DVR models |
| Snap (sized) | `http://IP/snap.jpg?JpegSize=XL` | Some Bosch-OEM firmware |

## Troubleshooting

### Default password differences

- **Current Hanwha Vision models:** Password must be set during initial setup via web browser
- **Legacy Samsung S-series:** Default password is `4321`
- **Very old Samsung models:** Some used `admin` / `admin`

### profile2 vs profile1 in URL

Samsung/Hanwha cameras use `profile2/media.smp` for the main stream (not `profile1`). This is a common source of confusion:

- `profile2/media.smp` = Main stream (typically H.264 at full resolution)
- `profile3/media.smp` = Sub stream
- The profile numbers may differ based on camera configuration

### ONVIF double-slash issue

The ONVIF URL format requires a double slash before `onvif`: - Correct: `rtsp://IP:554//onvif/profile1/media.smp` - Incorrect: `rtsp://IP:554/onvif/profile1/media.smp`

### Brand name confusion

Samsung Techwin was acquired by Hanwha in 2015. The brand has been called: - **Samsung Techwin** (before 2015) - **Hanwha Techwin** (2015-2022) - **Hanwha Vision** (2022-present) - **Wisenet** (product brand name, used throughout)

All use the same RTSP URL patterns within their respective generation.

## FAQ

**What is the default RTSP URL for Samsung/Hanwha cameras?**

For current Wisenet models, the URL is `rtsp://admin:password@CAMERA_IP:554/profile2/media.smp`. For legacy Samsung models, try `rtsp://admin:4321@CAMERA_IP:554/mpeg4unicast` or `rtsp://CAMERA_IP:554/H264/media.smp`.

**Is Samsung the same as Hanwha Vision?**

Yes. Samsung's security camera division was acquired by Hanwha Group in 2015. The product brand is **Wisenet**. Legacy Samsung cameras (SNB, SND, SNO series) and current Hanwha Vision cameras (XNO, XND, PNO series) use similar RTSP patterns.

**Do Samsung/Hanwha cameras support H.265?**

Yes. Current X-series and P-series cameras support H.265 (HEVC). Legacy S-series cameras typically support H.264 and MPEG-4 only.

**What VMS works with Hanwha cameras?**

Hanwha's own VMS is **Wisenet WAVE**. However, all Hanwha cameras support standard RTSP and ONVIF, making them compatible with any third-party software including VisioForge SDK applications.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Hanwha Vision Connection Guide](../hanwha/) — Current brand name, same URLs
- [Wisenet Connection Guide](../wisenet/) — Hanwha Vision product family
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Sanyo IP Camera RTSP URL Patterns and C# .NET Integration
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/sanyo/
**Description:** Connect Sanyo VCC, VDC, and VCC-HD series IP cameras in C# .NET using RTSP URL patterns, snapshot endpoints, and VisioForge SDK code examples.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Sanyo IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Sanyo** (Sanyo Electric Co., Ltd.) was a Japanese electronics manufacturer headquartered in Osaka, Japan. Sanyo's security camera division produced the well-regarded VCC and VDC camera lines for professional surveillance installations. In 2009-2011, Panasonic acquired Sanyo Electric, and the camera technology was integrated into Panasonic's i-PRO product line. While Sanyo cameras are no longer manufactured, many units remain deployed in legacy installations worldwide.

**Key facts:**

- **Product lines:** VCC (box cameras), VDC (dome cameras), VCC-HD (HD series)
- **Status:** Discontinued (acquired by Panasonic 2009-2011)
- **Protocol support:** RTSP, HTTP/CGI, limited ONVIF (newer firmware)
- **Default RTSP port:** 554
- **Default credentials:** admin / admin
- **ONVIF support:** Limited (older firmware only)
- **Video codecs:** H.264, MJPEG
- **Successor:** Panasonic i-PRO

Sanyo Cameras Are Discontinued

Sanyo security cameras are discontinued. Sanyo Electric was acquired by Panasonic, and the camera technology was integrated into Panasonic's i-PRO product line. See our [Panasonic/i-PRO connection guide](../panasonic/) for current products.

## RTSP URL Patterns

### Standard URL Format

Sanyo cameras use the `VideoInput` RTSP path:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/VideoInput/1/h264/1
```

| Parameter | Value | Description |
| --- | --- | --- |
| `VideoInput` | 1, 2, 3... | Camera channel (1 for standalone cameras) |
| `h264` | h264 | H.264 video codec |
| Trailing `1` | 1 | Stream index |

### Camera Models

| Model | Type | Main Stream URL | Notes |
| --- | --- | --- | --- |
| VCC-HD2300P | HD box camera | `rtsp://IP:554/VideoInput/1/h264/1` | H.264 main stream |
| VCC-HD series | HD cameras | `rtsp://IP:554/VideoInput/1/h264/1` | H.264 main stream |
| VCC-9574N | Box camera | `rtsp://IP:554/VideoInput/1/h264/1` | H.264 main stream |
| VCC-P9574N | PTZ camera | `rtsp://IP:554/VideoInput/1/h264/1` | H.264 main stream |
| VDC series | Dome cameras | `rtsp://IP:554/VideoInput/1/h264/1` | H.264 main stream |

### DVR Channel URLs

For Sanyo DVR systems with multiple channels:

| Channel | Main Stream URL |
| --- | --- |
| Camera 1 | `rtsp://IP:554/VideoInput/1/h264/1` |
| Camera 2 | `rtsp://IP:554/VideoInput/2/h264/1` |
| Camera N | `rtsp://IP:554/VideoInput/N/h264/1` |

### Alternative URL Formats

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/VideoInput/1/h264/1` | Standard H.264 stream (recommended) |
| `rtsp://IP:554/VideoInput/CHANNEL/h264/1` | Multi-channel DVR access |

## Connecting with VisioForge SDK

Use your Sanyo camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Sanyo VCC-HD2300P, main stream
var uri = new Uri("rtsp://192.168.1.90:554/VideoInput/1/h264/1");
var username = "admin";
var password = "YourPassword";
```

For multi-channel DVR access, replace `VideoInput/1` with the appropriate channel number.

## Snapshot and MJPEG URLs

Sanyo's liveimg.cgi Endpoint

Sanyo cameras use a distinctive `/liveimg.cgi` endpoint for HTTP snapshots and MJPEG streams. The `serverpush=1` parameter enables continuous MJPEG streaming.

| Type | URL Pattern | Notes |
| --- | --- | --- |
| Live Snapshot | `http://IP/liveimg.cgi` | Single JPEG frame |
| MJPEG Stream | `http://IP/liveimg.cgi?serverpush=1` | Continuous server-push MJPEG |
| MJPEG with Channel | `http://IP/liveimg.cgi?serverpush=1&jpeg=1&stream=CHANNEL` | Channel-specific MJPEG stream |
| Channel Snapshot (DVR) | `http://IP/liveimg.cgi?ch=CHANNEL` | Channel-specific snapshot for DVR |

## Troubleshooting

### "401 Unauthorized" error

Sanyo cameras use basic authentication by default. Ensure you are providing correct credentials:

1. Access the camera at `http://CAMERA_IP` in a browser
2. Log in with your credentials (default: admin / admin)
3. Verify the RTSP service is enabled in network settings
4. Use those credentials in your RTSP URL

### H.264 stream not available

Older Sanyo models may only support MJPEG. If the H.264 URL does not work, try using the MJPEG HTTP stream instead:

```
http://CAMERA_IP/liveimg.cgi?serverpush=1
```

### Firmware and compatibility

Since Sanyo cameras are discontinued, firmware updates are no longer available. If you encounter compatibility issues:

- Ensure the camera firmware is the latest available version
- Try using ONVIF discovery if direct URL connection fails
- Consider migrating to Panasonic i-PRO cameras, which inherit Sanyo's technology

### MJPEG server-push not working

The `serverpush=1` parameter requires the camera's HTTP server to support chunked transfer encoding. Some older firmware versions may not support this reliably. Try the single snapshot endpoint (`/liveimg.cgi` without parameters) and poll at your desired frame rate instead.

## FAQ

**Are Sanyo cameras still supported?**

Sanyo security cameras are discontinued. Sanyo Electric was fully acquired by Panasonic, and the surveillance camera technology was merged into Panasonic's i-PRO product line. No new firmware updates or support are available for Sanyo-branded cameras.

**What is the default RTSP URL for Sanyo cameras?**

The URL is `rtsp://admin:password@CAMERA_IP:554/VideoInput/1/h264/1` for the main H.264 stream. For DVR setups, replace `VideoInput/1` with the appropriate channel number (e.g., `VideoInput/2` for channel 2).

**Do Sanyo cameras support ONVIF?**

Only some Sanyo cameras with newer firmware versions have limited ONVIF support. Most older models do not support ONVIF and require direct RTSP URL configuration.

**What should I use instead of Sanyo cameras?**

Panasonic's i-PRO product line is the direct successor to Sanyo's security camera division. The i-PRO cameras use similar VideoInput RTSP paths and offer modern features like H.265, advanced analytics, and full ONVIF support. See our [Panasonic/i-PRO connection guide](../panasonic/).

**How do I get snapshots from a Sanyo camera?**

Use the `/liveimg.cgi` HTTP endpoint: `http://CAMERA_IP/liveimg.cgi` returns a single JPEG frame. Add `?serverpush=1` for a continuous MJPEG stream, or `?ch=CHANNEL` for a specific DVR channel.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Panasonic/i-PRO Connection Guide](../panasonic/) — Successor product line
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Sony SNC IP Camera RTSP URL Patterns and C# .NET Setup
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/sony/
**Description:** Sony SNC CH, DH, EB, CX, and IPELA camera RTSP URL patterns for C# .NET. Stream and record with VisioForge Video Capture SDK integration code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Sony IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Sony** (Sony Corporation, Security Systems Division) was a major manufacturer of professional IP surveillance cameras under the **IPELA** brand and later the **SNC** (Sony Network Camera) product line. Sony exited the security camera market in 2020, selling its security business to **Bosch**. However, a large installed base of Sony cameras remains in use worldwide, particularly in enterprise and government installations.

**Key facts:**

- **Product lines:** SNC-CH (box, H.264), SNC-DH (dome, H.264), SNC-EB/ER (E-series), SNC-CX (compact), SNC-VB/VM/WR/XM (current-gen before exit), SNC-DF/RX/RZ/CS (legacy IPELA), SNT (video encoders)
- **Protocol support:** RTSP, ONVIF, HTTP/CGI, Sony proprietary (DEPA)
- **Default RTSP port:** 554
- **Default credentials:** admin / admin (must be changed on setup)
- **ONVIF support:** Yes (SNC-CH/DH and newer models)
- **Video codecs:** H.264, H.265 (late models), MPEG-4 (legacy), MJPEG
- **Status:** Sony exited security camera market in 2020

End of life

Sony exited the security camera market in 2020. While existing cameras continue to work, no new firmware updates or models are being released. The RTSP URLs documented here remain valid for existing installations.

## RTSP URL Patterns

### Current-Gen Models (SNC-CH/DH/EB/ER/CX/VB/VM/WR/XM)

| Stream | RTSP URL | Codec | Notes |
| --- | --- | --- | --- |
| Video 1 (main) | `rtsp://IP:554/media/video1` | H.264 | Main stream |
| Video 2 (sub) | `rtsp://IP:554/media/video2` | H.264 | Sub stream |
| ONVIF profile | `rtsp://IP//profile` | H.264 | ONVIF-based (note double slash) |
| Direct | `rtsp://IP//media/video1` | H.264 | Alternative (double slash) |

### Model-Specific URLs

| Model Series | RTSP URL | Resolution | Notes |
| --- | --- | --- | --- |
| SNC-CH110 | `rtsp://IP/media/video1` | 1280x1024 | Box camera |
| SNC-CH120/CH140 | `rtsp://IP/media/video1` | 1280x1024 / 1920x1080 | Box camera |
| SNC-CH160/CH180 | `rtsp://IP/media/video1` | 1920x1080 | Box camera |
| SNC-CH210/CH260/CH280 | `rtsp://IP/media/video1` | 1920x1080 / 2MP | Box camera |
| SNC-DH110/DH120/DH140 | `rtsp://IP/media/video1` | Up to 1080p | Fixed dome |
| SNC-DH160/DH180 | `rtsp://IP/media/video1` | 1920x1080 | Fixed dome |
| SNC-DH210/DH260 | `rtsp://IP/media/video1` | 1920x1080 | Fixed dome |
| SNC-EB600B | `rtsp://IP/media/video1` | 1080p | E-series |
| SNC-CX600W | `rtsp://IP:554//media/video1` | 1080p | Compact |
| SNC-VB630/WR630/XM632 | `rtsp://IP//profile` | 1080p+ | Latest gen |
| SNC-DM110 | `rtsp://IP:554//media/video1` | 720p | Mini dome |

### Legacy IPELA Models (SNC-RX/RZ/DF/CS/EP)

Older Sony IPELA cameras typically don't support RTSP and use HTTP-based streaming:

| Model Series | URL | Notes |
| --- | --- | --- |
| SNC-RX530/RX550 | `http://IP/jpeg/vga.jpg` | JPEG snapshot |
| SNC-RZ25/RZ30/RZ50 | `http://IP/oneshotimage.jpg` | JPEG snapshot |
| SNC-DF40/DF50/DF70/DF80 | `http://IP/image` | JPEG snapshot |
| SNC-CS11/CS3P/CS50P | `http://IP/oneshotimage.jpg` | JPEG snapshot |
| SNC-EP520/EP580 | `http://IP/jpeg/vga.jpg` | JPEG snapshot |
| SNC-M1/M3 | `http://IP/image` | Very old MPEG-4 |

### Video Encoder URLs

| Encoder | URL | Notes |
| --- | --- | --- |
| SNT-EX101/EX104 | `http://IP/oneshotimage.jpg` | Snapshot per channel |
| SNT-EX104 (channel) | `http://IP/CH1/oneshotimage.jpg` | Channel-specific |
| SNT-V704 | `http://IP/CH1/oneshotimage.jpg` | 4-channel encoder |

## Connecting with VisioForge SDK

Use your Sony camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Sony SNC camera, main stream
var uri = new Uri("rtsp://192.168.1.55:554/media/video1");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `/media/video2` instead.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/oneshotimage.jpg` | Most SNC models |
| JPEG (VGA) | `http://IP/jpeg/vga.jpg` | VGA resolution |
| JPEG (QVGA) | `http://IP/jpeg/qvga.jpg` | QVGA resolution |
| MJPEG Stream | `http://IP/img/mjpeg.cgi` | Continuous MJPEG |
| MJPEG (alt) | `http://IP/mjpeg` | Alternative MJPEG path |
| H.264 over HTTP | `http://IP/h264` | H.264 stream via HTTP |
| Image | `http://IP/image` | Generic snapshot |
| Channel snapshot | `http://IP/oneshotimage1` | Channel-specific |

## Troubleshooting

### Double slash in URLs

Some Sony models use a double slash before the path in RTSP URLs:

- `rtsp://IP//media/video1` (double slash)
- `rtsp://IP:554/media/video1` (single slash with port)

Both formats usually work, but try the double-slash variant if the standard URL fails.

### ONVIF vs direct RTSP

Sony cameras support both direct RTSP and ONVIF-based connections:

- Direct RTSP: `rtsp://IP:554/media/video1` (recommended)
- ONVIF: `rtsp://IP//profile` (ONVIF-discovered URL)

### Legacy cameras without RTSP

Older Sony IPELA cameras (SNC-RX, SNC-RZ, SNC-DF, SNC-CS, SNC-M series) often don't support RTSP and only offer HTTP JPEG/MJPEG. For these cameras, use HTTP snapshot integration.

### Sony exited the market

Sony sold its security camera business in 2020. Existing cameras continue to function but receive no new firmware updates. Plan for eventual migration when deploying new integrations.

## FAQ

**What is the default RTSP URL for Sony SNC cameras?**

For current Sony SNC cameras, use `rtsp://admin:password@CAMERA_IP:554/media/video1` for the main stream and `media/video2` for the sub stream.

**Does Sony still make IP cameras?**

No. Sony exited the security camera market in 2020. Existing Sony SNC cameras remain in use and their RTSP streams continue to work, but no new models or firmware updates are being released.

**Do Sony cameras support ONVIF?**

Yes. Sony SNC-CH, SNC-DH, and newer series support ONVIF Profile S. Use `rtsp://IP//profile` for ONVIF-based connections.

**What about Sony IPELA cameras?**

IPELA was Sony's earlier camera brand. Many IPELA models (SNC-RX, SNC-RZ, SNC-DF series) only support HTTP JPEG/MJPEG, not RTSP. Later IPELA models (SNC-CH/DH series) do support RTSP via `media/video1`.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Canon Connection Guide](../canon/) — Japanese enterprise cameras
- [Axis Connection Guide](../axis/) — Enterprise surveillance peer
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## How to Connect to Speco Technologies IP Camera in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/speco/
**Description:** Speco Technologies O Series, VIP, and DVR RTSP integration for C# .NET. URL patterns, channel selection, and VisioForge SDK code for IP and analog cameras.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Speco Technologies IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Speco Technologies** is an American professional surveillance company based in Amityville, New York. Founded in 1969, Speco manufactures IP cameras, analog cameras, DVRs, NVRs, and access control equipment for the professional security integrator market. Speco products are sold through authorized distributors and security integrators rather than direct-to-consumer channels, making them a common choice in commercial installations.

**Key facts:**

- **Product lines:** O Series (IP cameras: O2B, O2D, OINT), VIP Series (IP cameras), ZIP Series, SIP Series, LS Series, DVR lines (TH/TL, RS, PCPRO)
- **Protocol support:** RTSP, ONVIF, HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** admin / admin
- **ONVIF support:** Yes (all current IP cameras)
- **Video codecs:** H.264 (all current models), MPEG-4 (older models)

Multiple Product Lines

Speco Technologies has many distinct product lines, each with different RTSP URL formats. Identify your exact model series (O, VIP, LS, ZIP, SIP, or DVR type) before configuring the stream URL. The root stream `rtsp://IP:554/` works on many Speco devices as a quick test.

## RTSP URL Patterns

### O Series IP Cameras

The O Series is Speco's current IP camera line, including bullet (O2B), dome (O2D), and intensifier (OINT) models:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/
```

| Model | Resolution | Main Stream URL | Notes |
| --- | --- | --- | --- |
| O2B2 (bullet) | 1080p | `rtsp://IP:554/` | Root stream |
| O2D4 (dome) | 1080p | `rtsp://IP:554/` | Root stream |
| OINT56B1G (intensifier) | 1080p | `rtsp://IP:554/mpeg4` | MPEG-4 stream |
| OINT56B1G (intensifier) | 1080p | `rtsp://IP:554/` | Root stream (H.264) |

### VIP Series IP Cameras

The VIP Series uses a numbered stream path format:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/1/stream1
```

| Model | Resolution | Main Stream URL | Notes |
| --- | --- | --- | --- |
| VIP2B1M (bullet) | 1080p | `rtsp://IP:554/1/stream1` | Stream 1 (main) |
| VIP2C1N (cube) | 1080p | `rtsp://IP:554/1/stream1` | Stream 1 (main) |

### LS Series

The LS Series uses a channel-based H.264 path and also supports a credential-in-URL format:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/cam1/h264` | Channel 1 H.264 stream |
| `rtsp://IP:554/cam2/h264` | Channel 2 H.264 stream |
| `rtsp://IP:554/cam[N]/h264` | Channel N H.264 stream |
| `rtsp://IP:554//user=admin_password=tlJwpbo6_channel=1_stream=0.sdp` | Credential-in-URL format |

LS Series Credential Format

The LS Series supports an unusual credential-in-URL format where the username and password are embedded directly in the path. The password in this format is device-specific and may differ from the web interface password. Check the device's RTSP settings page for the correct value.

### ZIP Series

The ZIP Series uses a profile-based streaming format:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554//stream0/Channel=0;Profile=0
```

| Model | Main Stream URL | Notes |
| --- | --- | --- |
| ZIP2B (bullet) | `rtsp://IP:554//stream0/Channel=0;Profile=0` | Profile 0 (main) |

### DVR Models

Speco DVRs use various URL formats depending on the DVR line:

| DVR Series | URL Pattern | Notes |
| --- | --- | --- |
| DVR4WM | `rtsp://IP:554/` | Root stream |
| RS Series | `rtsp://IP:554/Live/Channel=1` | Live channel format |
| RS Series | `rtsp://IP:554/Live/Channel=2` | Channel 2 |
| General DVRs | `rtsp://IP:554/` | Root stream (fallback) |

### DVR Channel URLs (RS Series)

For Speco RS Series DVRs:

| Channel | Main Stream URL |
| --- | --- |
| Camera 1 | `rtsp://IP:554/Live/Channel=1` |
| Camera 2 | `rtsp://IP:554/Live/Channel=2` |
| Camera N | `rtsp://IP:554/Live/Channel=N` |

### All URL Formats Summary

| URL Pattern | Product Line | Notes |
| --- | --- | --- |
| `rtsp://IP:554/` | O Series, DVRs, general | Root stream (works on many devices) |
| `rtsp://IP:554/mpeg4` | O Series (older) | MPEG-4 stream |
| `rtsp://IP:554/1/stream1` | VIP Series | Numbered stream format |
| `rtsp://IP:554/cam[N]/h264` | LS Series | Channel-based H.264 |
| `rtsp://IP:554//stream0/Channel=0;Profile=0` | ZIP Series | Profile-based format |
| `rtsp://IP:554/Live/Channel=N` | RS DVR | Live channel format |

## Connecting with VisioForge SDK

Use your Speco camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Speco O2D4 dome camera, root stream
var uri = new Uri("rtsp://192.168.1.64:554/");
var username = "admin";
var password = "admin";
```

For VIP Series cameras, use the `/1/stream1` path instead:

```
// Speco VIP2B1M bullet camera, main stream
var uri = new Uri("rtsp://192.168.1.64:554/1/stream1");
var username = "admin";
var password = "admin";
```

## Snapshot and MJPEG URLs

### IP Camera Snapshots

| Type | URL Pattern | Models | Notes |
| --- | --- | --- | --- |
| Still Image | `http://IP/stillimg.jpg` | O2B2, O2D4, OINT56B1G | Basic JPEG snapshot |
| Still Image (port 554) | `http://IP:554/stillimg.jpg` | O2B2, O2D4, OINT56B1G | Alternate port |
| Encoder Snapshot | `http://IP/cgi-bin/encoder?USER=user&PWD=pass&SNAPSHOT` | IP-SD10X, SIP Series | CGI-based with credentials |
| System Stream | `http://IP/cgi-bin/cmd/system?GET_STREAM&USER=user&PWD=pass` | Various IP cameras | System command format |

### DVR Snapshots

| Type | URL Pattern | DVR Series | Notes |
| --- | --- | --- | --- |
| Full Image | `http://IP/images1full` | Various DVRs | Replace `1` with channel number |
| SIF Image | `http://IP/images1sif` | Various DVRs | Lower resolution, replace `1` with channel |
| Get Image | `http://IP/getimage?camera=1&fmt=full` | Various DVRs | Replace `1` with channel number |
| Mobile Snapshot | `http://IP/mobile/channel1.jpg` | PCPRO DVR | Mobile-optimized, replace `1` with channel |
| TH/TL Stream | `http://IP/ivop.get?action=live&THREAD_ID=` | TH/TL DVR | Live stream via HTTP |

## Troubleshooting

### Inconsistent URL formats across product lines

Speco Technologies has many different product lines, each with its own RTSP URL format. If one URL pattern does not work, try the root stream `rtsp://IP:554/` first as a baseline test. Then try the format specific to your product line as listed in the tables above.

### Root stream limitations

The root stream (`rtsp://IP:554/`) works on many Speco devices for the main stream but is unreliable for accessing sub-streams or specific channels on multi-channel devices. Use the product-line-specific URL format for full control over stream selection.

### LS Series credential-in-URL format

The LS Series uses an unusual URL format where credentials are embedded in the path (`/user=admin_password=VALUE_channel=1_stream=0.sdp`). The password in this format may be a device-generated value that differs from the web interface password. Check the device's **RTSP Settings** page in the web interface for the correct credential string.

### Network discovery

Speco provides a DDNS tool and device discovery utility for finding cameras on the network. Download the Speco DDNS tool from the Speco Technologies website to locate devices that are not responding at expected IP addresses.

### Default credentials

Speco devices typically ship with default credentials of `admin` / `admin`. If these do not work, the password may have been changed during installation by the security integrator.

## FAQ

**What is the default RTSP URL for Speco cameras?**

For most Speco IP cameras, try the root stream first: `rtsp://admin:admin@CAMERA_IP:554/`. For VIP Series cameras use `rtsp://IP:554/1/stream1`, and for LS Series cameras use `rtsp://IP:554/cam1/h264`. The correct URL depends on your specific product line.

**Do Speco cameras support ONVIF?**

Yes. All current Speco IP cameras support ONVIF. ONVIF discovery and streaming is the most reliable way to connect to Speco cameras if you are unsure of the exact RTSP URL format for your model.

**Why are there so many different URL formats for Speco cameras?**

Speco Technologies has been manufacturing surveillance equipment since 1969 and has acquired or developed multiple product lines over the decades. Each product line (O Series, VIP, LS, ZIP, SIP, DVR lines) may use different firmware and streaming architectures, resulting in different URL formats. Always identify your exact model series before configuring the connection.

**How do I find my Speco camera on the network?**

Use Speco's DDNS tool or device discovery utility, available from the Speco Technologies website. Alternatively, use ONVIF discovery through the VisioForge SDK or a network scanning tool to locate the camera's IP address on your local network.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [EverFocus Connection Guide](../everfocus/) — Professional surveillance cameras
- [Save Original RTSP Stream](../../mediablocks/Guides/rtsp-save-original-stream/) — Record Speco streams without re-encoding
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Swann IP Camera RTSP URL and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/swann/
**Description:** Swann NHD, SWNHD, DVR/NVR, and ADS camera RTSP URL patterns for C# .NET. Stream and record using VisioForge Video Capture SDK integration code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MJPEG, C#

# How to Connect to Swann IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Swann** (Swann Communications) is an Australian consumer security brand headquartered in Melbourne, Australia, now owned by **Infinova**. Swann is one of the best-known consumer and prosumer security brands, popular for their bundled DVR/NVR camera systems sold through major retailers. Swann offers a range of standalone IP cameras, analog-over-coax (BNC) camera systems, and network video recorders.

**Key facts:**

- **Product lines:** NHD (current network HD cameras), SWNHD (HD IP cameras), SWPRO (analog-over-coax), DVR/NVR systems, ADS (legacy IP cameras)
- **Protocol support:** RTSP, ONVIF (current NHD models), HTTP/MJPEG (legacy)
- **Default RTSP port:** 554
- **Default credentials:** admin / admin or admin / (empty) on older models
- **ONVIF support:** Yes (current NHD-series cameras)
- **Video codecs:** H.264, H.265 (current models), MPEG-4 (legacy DVRs)
- **OEM base:** Many newer Swann NVRs are Hikvision OEM and use Hikvision RTSP URL patterns

Swann NVRs and Hikvision

Many current Swann NVRs are manufactured by Hikvision and use Hikvision firmware. If the standard Swann RTSP URL does not work on your NVR, try the Hikvision URL format (`/Streaming/Channels/`). See our [Hikvision connection guide](../hikvision/) for details.

## RTSP URL Patterns

### Current NHD-Series IP Cameras

Standalone Swann NHD-series IP cameras (SWNHD-820CAM, SWNHD-830CAM, NHD-866, etc.) use the following URL:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/live/h264
```

### NVR Systems (Hikvision-Based)

Most current Swann NVRs use Hikvision-style RTSP paths:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554//Streaming/Channels/[CHANNEL_ID]
```

| Channel | Main Stream | Sub Stream |
| --- | --- | --- |
| Camera 1 | `rtsp://IP:554//Streaming/Channels/1` | `rtsp://IP:554//Streaming/Channels/102` |
| Camera 2 | `rtsp://IP:554//Streaming/Channels/2` | `rtsp://IP:554//Streaming/Channels/202` |
| Camera N | `rtsp://IP:554//Streaming/Channels/N` | `rtsp://IP:554//Streaming/Channels/N02` |

Channel numbering

For Hikvision-based NVRs, the main stream channel ID matches the camera number (1, 2, 3...). The sub stream uses the format `N02` where N is the camera number (102, 202, 302...).

### Legacy DVR Models

Older Swann DVR systems (DVR4-PRO-NET, etc.) and standalone cameras use MPEG-4:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/mpeg4
```

### URL Summary Table

| Model / Series | Main Stream URL | Notes |
| --- | --- | --- |
| NHD-series cameras (SWNHD-820/830) | `rtsp://IP:554/live/h264` | Standalone IP cameras |
| IP-3G ConnectCam | `rtsp://IP:554/mpeg4` | Legacy standalone |
| Max-IP-Cam | `rtsp://IP:554/mpeg4` | Legacy standalone |
| Current NVR (channel 1) | `rtsp://IP:554//Streaming/Channels/1` | Hikvision OEM |
| Current NVR (channel 1, sub) | `rtsp://IP:554//Streaming/Channels/102` | Hikvision OEM |
| DVR4-PRO-NET | `rtsp://IP:554/mpeg4` | Legacy DVR |
| Generic Swann IP cameras | `rtsp://IP:554/live/h264` | Try this first |

## Connecting with VisioForge SDK

Use your Swann camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Swann NHD-series camera, main stream
var uri = new Uri("rtsp://192.168.1.90:554/live/h264");
var username = "admin";
var password = "YourPassword";
```

For NVR sub-stream access, use `/Streaming/Channels/102` instead of `/Streaming/Channels/1`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| HTTP stream (ADS-440 legacy) | `http://IP/videostream.asf?user=USER&pwd=PASS` | ASF format, no RTSP |
| MJPEG stream (legacy) | `http://IP/videostream.cgi?user=USER&pwd=PASS` | Older models |
| ONVIF snapshot | `http://IP/onvif-http/snapshot` | NHD-series with ONVIF |

Legacy HTTP-only cameras

The ADS-440 series and some other older Swann models only support HTTP streaming (ASF or MJPEG) and do not support RTSP at all. Use the HTTP URL directly for these cameras.

## Troubleshooting

### Identify your NVR firmware type

Many Swann NVRs are Hikvision OEM. To determine which URL format to use:

1. Access the NVR web interface at `http://NVR_IP`
2. Check the login page — Hikvision-based NVRs often show a Hikvision-style interface
3. Try the Hikvision URL first (`/Streaming/Channels/1`), then fall back to Swann URLs (`/live/h264` or `/mpeg4`)

### "Connection refused" on legacy cameras

Older Swann cameras (ADS-440 series, early DVR models) may not support RTSP at all. These cameras use HTTP-based streaming only. Try the HTTP ASF or MJPEG URL instead of RTSP.

### Default credentials not working

- Current models typically ship with admin / admin but require password change on first setup
- Some older models use admin with an empty password
- Always complete initial setup via the Swann web interface or SwannView app before attempting RTSP access

### SwannView vs local RTSP access

SwannView (Swann's cloud service) is separate from local RTSP access. You do not need a SwannView account to use RTSP streaming on your local network. RTSP works purely over the local network connection.

## FAQ

**What is the default RTSP URL for Swann cameras?**

For current NHD-series cameras, use `rtsp://admin:password@CAMERA_IP:554/live/h264`. For Swann NVRs (Hikvision-based), use `rtsp://admin:password@NVR_IP:554//Streaming/Channels/1` for channel 1 main stream.

**Are Swann NVRs compatible with Hikvision RTSP URLs?**

Yes. Many current Swann NVRs are manufactured by Hikvision and use identical firmware. The Hikvision RTSP URL format (`/Streaming/Channels/`) works on these systems. If the standard Swann URL fails, try the Hikvision format.

**Do all Swann cameras support RTSP?**

No. Some legacy Swann models (particularly the ADS-440 series) only support HTTP-based streaming in ASF or MJPEG format. All current NHD-series cameras and NVRs support RTSP.

**Do Swann cameras support ONVIF?**

Yes, current NHD-series cameras support ONVIF. Legacy models (SWPRO, ADS series) generally do not support ONVIF.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Lorex Connection Guide](../lorex/) — Consumer/prosumer segment peer
- [Hikvision Connection Guide](../hikvision/) — Swann NVRs with Hikvision firmware
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Tenda IP Camera RTSP URL and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/tenda/
**Description:** Tenda CP, CT, IT series and pan/tilt camera RTSP URL patterns for C# .NET. Stream and record using VisioForge Video Capture SDK integration code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, C#

# How to Connect to Tenda IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Tenda Technology** is a Chinese networking equipment manufacturer headquartered in Shenzhen, China. Founded in 1999, Tenda is primarily known for routers and networking gear but has expanded into the security camera market with a growing line of affordable IP cameras targeting the consumer and small business segments. Tenda cameras are gaining traction in emerging markets across Asia, South America, and Africa.

**Key facts:**

- **Product lines:** CP (pan/tilt), CT (outdoor bullet/turret), IT (indoor)
- **Protocol support:** RTSP, ONVIF (select models), HTTP
- **Default RTSP port:** 554
- **Default credentials:** admin / admin (varies by model)
- **ONVIF support:** Yes (newer models)
- **Video codecs:** H.264, H.265 (select models)
- **Companion app:** Tenda Security app (for setup and remote viewing)

## RTSP URL Patterns

### Standard URL Format

Tenda cameras use a stream-number-based RTSP URL:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/stream1
```

| Stream | URL Pattern | Description |
| --- | --- | --- |
| Main stream | `rtsp://IP:554/stream1` | Full resolution |
| Sub stream | `rtsp://IP:554/stream2` | Lower resolution |

### Camera Models

| Model | Type | Resolution | Main Stream URL | Audio |
| --- | --- | --- | --- | --- |
| CP3 (pan/tilt indoor) | Indoor PTZ | 1920x1080 | `rtsp://IP:554/stream1` | Yes |
| CP6 (2K pan/tilt) | Indoor PTZ | 2304x1296 | `rtsp://IP:554/stream1` | Yes |
| CP7 (4MP pan/tilt) | Indoor PTZ | 2560x1440 | `rtsp://IP:554/stream1` | Yes |
| CT3 (outdoor bullet) | Outdoor | 1920x1080 | `rtsp://IP:554/stream1` | Yes |
| CT6 (2K outdoor) | Outdoor | 2304x1296 | `rtsp://IP:554/stream1` | Yes |
| CT7 (4MP outdoor) | Outdoor | 2560x1440 | `rtsp://IP:554/stream1` | Yes |
| IT6 (indoor) | Indoor | 1920x1080 | `rtsp://IP:554/stream1` | Yes |
| IT7 (2K indoor) | Indoor | 2304x1296 | `rtsp://IP:554/stream1` | Yes |

### Alternative URL Formats

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/stream1` | Main stream (recommended) |
| `rtsp://IP:554/stream2` | Sub stream |
| `rtsp://IP:554/live/ch0` | Alternative format (some models) |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Dahua-compatible (some OEM firmware) |

## Connecting with VisioForge SDK

Use your Tenda camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Tenda CP7 (4MP pan/tilt), main stream
var uri = new Uri("rtsp://192.168.1.90:554/stream1");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `/stream2` instead of `/stream1`.

## Snapshot URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/snapshot.cgi` | Requires basic auth |

## Troubleshooting

### Camera requires app setup first

Tenda cameras must be initially configured through the Tenda Security app. The camera needs WiFi credentials and account setup before RTSP is accessible. After setup, you can connect directly via RTSP on the local network.

### Multiple URL formats

Some Tenda cameras use different firmware bases. If `/stream1` does not work, try:

1. `rtsp://IP:554/live/ch0` (alternative format)
2. `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` (Dahua-compatible)
3. Use ONVIF discovery to retrieve the correct URL automatically

### Finding the camera IP

Tenda WiFi cameras get their IP via DHCP. Find it in:

1. The Tenda Security app (Device Info)
2. Your router's DHCP client list
3. ONVIF discovery (if supported)

## FAQ

**What is the default RTSP URL for Tenda cameras?**

Most Tenda cameras use `rtsp://admin:password@CAMERA_IP:554/stream1` for the main stream and `/stream2` for the sub stream. Some models use alternative URL paths.

**Do Tenda cameras support ONVIF?**

Newer Tenda camera models support ONVIF for standardized discovery and streaming. Older or budget models may not. Check your camera's specifications in the Tenda Security app.

**Are Tenda cameras good for development integration?**

Tenda cameras offer competitive pricing and standard RTSP support, making them suitable for development and prototyping. For production deployments requiring guaranteed RTSP/ONVIF compatibility, consider established surveillance brands like [Hikvision](../hikvision/), [Dahua](../dahua/), or [Reolink](../reolink/).

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [TP-Link Connection Guide](../tp-link/) — Similar consumer segment
- [Mercusys Connection Guide](../mercusys/) — Budget camera alternative
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Tiandy IP Camera in C# .NET — RTSP, ONVIF Setup Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/tiandy/
**Description:** Connect Tiandy IP cameras (TC-C, TC-NC, TC-A, TC-R NVR) to C# / .NET apps via RTSP and ONVIF. Default stream URLs, credentials, H.265 configs. Code sample.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Decoding, IP Camera, RTSP, ONVIF, H.265, MJPEG, C#

# How to Connect to Tiandy IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Tiandy Technologies** (Tiandy Technologies Co., Ltd.) is a Chinese video surveillance manufacturer headquartered in Tianjin, China. Founded in 1994, Tiandy is one of China's largest security equipment manufacturers and has been expanding rapidly into international markets across Asia, the Middle East, Africa, and Latin America. Tiandy specializes in AI-powered IP cameras, NVRs, and integrated video management solutions.

**Key facts:**

- **Product lines:** TC-C (current IP cameras), TC-NC (legacy IP), TC-A (AI analytics), TC-R (NVRs), TC-NR (network recorders)
- **Protocol support:** RTSP, ONVIF Profile S/T, HTTP/CGI
- **Default RTSP port:** 554
- **Default credentials:** admin / 1111 (older models) or admin / admin123 (varies by region)
- **ONVIF support:** Yes (current models)
- **Video codecs:** H.264, H.265 (SuperH.265), MJPEG
- **AI features:** Smart H.265+, face detection, perimeter protection, people counting

## RTSP URL Patterns

### Standard URL Format

Tiandy cameras use a channel and stream-based RTSP URL structure:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/cam/realmonitor?channel=1&subtype=0
```

| Parameter | Value | Description |
| --- | --- | --- |
| `channel` | 1, 2, 3... | Camera channel (1 for standalone cameras) |
| `subtype` | 0 | Main stream (highest resolution) |
| `subtype` | 1 | Sub stream (lower resolution) |

Dahua-Compatible URL Format

Many Tiandy cameras use the same `cam/realmonitor` RTSP URL format as Dahua cameras. If you are familiar with Dahua integration, the same URL patterns may work with Tiandy. See our [Dahua connection guide](../dahua/) for additional details.

### Alternative URL Formats

| URL Pattern | Description |
| --- | --- |
| `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Dahua-compatible (many models) |
| `rtsp://IP:554/live/ch0` | Main stream (legacy format) |
| `rtsp://IP:554/live/ch1` | Sub stream (legacy format) |
| `rtsp://IP:554/media/video1` | Uniview-compatible (some models) |
| `rtsp://IP:554/Streaming/Channels/101` | Hikvision-compatible (some OEM models) |
| `rtsp://IP:554/h264` | Simple H.264 stream path |

### Camera Models

| Model Series | Resolution | Main Stream URL | Audio |
| --- | --- | --- | --- |
| TC-C32JN (2MP bullet) | 1920x1080 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | No |
| TC-C34JN (4MP bullet) | 2560x1440 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | No |
| TC-C35JN (5MP bullet) | 2592x1944 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | No |
| TC-C38JN (4K bullet) | 3840x2160 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| TC-C32DN (2MP dome) | 1920x1080 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | No |
| TC-C34DN (4MP dome) | 2560x1440 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| TC-C32EP (2MP turret) | 1920x1080 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| TC-C34EP (4MP turret) | 2560x1440 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| TC-A32E2T (2MP AI) | 1920x1080 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |
| TC-C32WP (2MP WiFi) | 1920x1080 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | Yes |

### NVR Channel URLs

For Tiandy NVRs (TC-R3100, TC-R3200, TC-NR series):

| Channel | Main Stream | Sub Stream |
| --- | --- | --- |
| Camera 1 | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=1&subtype=1` |
| Camera 2 | `rtsp://IP:554/cam/realmonitor?channel=2&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=2&subtype=1` |
| Camera N | `rtsp://IP:554/cam/realmonitor?channel=N&subtype=0` | `rtsp://IP:554/cam/realmonitor?channel=N&subtype=1` |

## Connecting with VisioForge SDK

Use your Tiandy camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Tiandy TC-C34JN (4MP bullet), main stream
var uri = new Uri("rtsp://192.168.1.90:554/cam/realmonitor?channel=1&subtype=0");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `subtype=1` instead of `subtype=0`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/snapshot.cgi?channel=1` | Requires digest authentication |
| MJPEG Stream | `http://IP/cgi-bin/mjpg/video.cgi?channel=1&subtype=1` | Continuous MJPEG |

## Troubleshooting

### Multiple URL formats

Tiandy cameras may use different RTSP URL formats depending on firmware version and model. If one format does not work, try alternatives in this order:

1. `rtsp://IP:554/cam/realmonitor?channel=1&subtype=0` (Dahua-compatible, most common)
2. `rtsp://IP:554/live/ch0` (legacy Tiandy format)
3. `rtsp://IP:554/h264` (simple path)

### Default credentials vary

Tiandy default passwords differ by model and region. Common defaults include:

- `admin` / `1111`
- `admin` / `admin123`
- `admin` / `123456`

If none of these work, the camera may require initial activation via the web interface or Tiandy's EasyLive utility.

### SuperH.265 codec

Tiandy's SuperH.265 is a proprietary optimization that produces standard H.265/HEVC streams. No special decoder is required. The VisioForge SDK handles H.265 streams natively.

## FAQ

**What is the default RTSP URL for Tiandy cameras?**

Most Tiandy cameras use `rtsp://admin:password@CAMERA_IP:554/cam/realmonitor?channel=1&subtype=0` for the main stream, which is the same format as Dahua cameras. Some older models use `rtsp://IP:554/live/ch0` instead.

**Are Tiandy cameras Dahua OEMs?**

No. Tiandy is an independent manufacturer with its own hardware and firmware. However, some Tiandy firmware uses the same RTSP URL format as Dahua (`cam/realmonitor`), which is common across several Chinese surveillance manufacturers.

**Do Tiandy cameras support ONVIF?**

Yes. Current Tiandy models support ONVIF Profile S and Profile T. ONVIF must be enabled in the camera's web interface under network settings. Some models require creating a separate ONVIF user account.

**Which Tiandy camera series should I choose?**

**TC-C** is the current mainstream series. The number after "TC-C3" indicates resolution: **2** = 2MP, **4** = 4MP, **5** = 5MP, **8** = 4K. The suffix letters indicate form factor: **JN** = bullet, **DN** = dome, **EP** = turret/eyeball, **WP** = WiFi.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Dahua Connection Guide](../dahua/) — Similar URL format
- [Uniview Connection Guide](../uniview/) — Another major Chinese surveillance brand
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Toshiba IP Camera RTSP URL and Streaming in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/toshiba/
**Description:** Toshiba IK-WB, IK-WD, IK-WR, and IK-WP camera RTSP URL patterns for C# .NET. Stream and record with VisioForge Video Capture SDK integration.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Toshiba IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Toshiba** (Toshiba Corporation) is a Japanese multinational conglomerate headquartered in Tokyo, Japan. Toshiba's security division produced the **IK-W series** of IP cameras, covering box, dome, bullet, and PTZ form factors. Toshiba has since exited the standalone security camera market and sold its surveillance business. Despite discontinuation, many IK-W series cameras remain deployed in commercial and industrial installations worldwide.

**Key facts:**

- **Product lines:** IK-WB (box cameras), IK-WD (dome cameras), IK-WR (bullet/rugged cameras), IK-WP (PTZ cameras)
- **Protocol support:** RTSP, HTTP/CGI, ONVIF (limited, newer models only)
- **Default RTSP port:** 554
- **Default credentials:** admin / 1234
- **ONVIF support:** Limited (newer IK-W14/16/30/70/80 models only)
- **Video codecs:** H.264 (IK-W14/16/30/70/80 series), MJPEG (older models)

Discontinued Product Line

Toshiba has exited the IP camera market and sold its surveillance business. No new firmware updates or official support are available. Many early IK-WB models (01A, 02A, 11A) support HTTP snapshot only and do not provide RTSP streaming.

## RTSP URL Patterns

### Standard URL Format

Toshiba IK-W series cameras use the `live.sdp` URL pattern:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/live.sdp
```

| Parameter | Value | Description |
| --- | --- | --- |
| `live.sdp` | Primary stream | Main H.264 stream (highest resolution) |
| `live2.sdp` | Sub stream | Secondary stream (lower resolution) |
| `live3.sdp` | Third stream | Third stream (mobile-optimized, select models) |

### Camera Models - RTSP Streams

| Model | Type | Main Stream URL | Sub Stream URL | Notes |
| --- | --- | --- | --- | --- |
| IK-WB16A | Box | `rtsp://IP:554/live.sdp` | -- | H.264 |
| IK-WB80A | Box | `rtsp://IP:554/live.sdp` | -- | H.264 |
| IK-WD01A | Dome | `rtsp://IP:554/live.sdp` | -- | H.264 |
| IK-WD12A | Dome | `rtsp://IP:554//live.sdp` | -- | Double-slash path |
| IK-WD14A | Dome | `rtsp://IP:554/live.sdp` | `rtsp://IP:554/live2.sdp` | Also supports `live3.sdp` |
| IK-WR04A | Bullet | `rtsp://IP:554/live.sdp` | -- | H.264 |
| IK-WR12A | Bullet | `rtsp://IP:554/live.sdp` | -- | H.264 |
| IK-WR14A | Bullet | `rtsp://IP:554/live.sdp` | -- | H.264 |
| IK-WP41A | PTZ | `rtsp://IP:554/live.sdp` | -- | H.264 |

### Models by Series

#### IK-WB Series (Box Cameras)

| Model | Streaming | Protocol |
| --- | --- | --- |
| IK-WB01A | HTTP snapshot only | HTTP |
| IK-WB02A | HTTP snapshot only | HTTP |
| IK-WB11A | HTTP snapshot only | HTTP |
| IK-WB15A | HTTP snapshot + CGI | HTTP |
| IK-WB16A | RTSP `live.sdp` | RTSP + HTTP |
| IK-WB16A-W | RTSP `live.sdp`, `live3.sdp` | RTSP + HTTP |
| IK-WB21A | HTTP CGI only | HTTP |
| IK-WB30A | RTSP `live.sdp` | RTSP + HTTP |
| IK-WB70A | RTSP `live.sdp` | RTSP + HTTP + MJPEG |
| IK-WB80A | RTSP `live.sdp` | RTSP + HTTP + MJPEG |

#### IK-WD Series (Dome Cameras)

| Model | Streaming | Protocol |
| --- | --- | --- |
| IK-WD01A | RTSP `live.sdp` | RTSP |
| IK-WD12A | RTSP `//live.sdp` | RTSP (double-slash) |
| IK-WD14A | RTSP `live.sdp`, `live2.sdp`, `live3.sdp` | RTSP (multi-stream) |

#### IK-WR Series (Bullet/Rugged Cameras)

| Model | Streaming | Protocol |
| --- | --- | --- |
| IK-WR01A | HTTP snapshot only | HTTP |
| IK-WR02A | HTTP snapshot only | HTTP |
| IK-WR04A | RTSP `live.sdp` | RTSP |
| IK-WR12A | RTSP `live.sdp` | RTSP + MJPEG |
| IK-WR14A | RTSP `live.sdp` | RTSP + HTTP |

#### IK-WP Series (PTZ Cameras)

| Model | Streaming | Protocol |
| --- | --- | --- |
| IK-WP41A | RTSP `live.sdp` | RTSP |

### Alternative URL Formats

Some Toshiba models use a double-slash in the RTSP path:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/live.sdp` | Standard (recommended) |
| `rtsp://IP:554//live.sdp` | Double-slash variant (IK-WD12A, some IK-WD14A units) |
| `rtsp://IP:554/live2.sdp` | Sub stream (IK-WD14A) |
| `rtsp://IP:554/live3.sdp` | Third stream (IK-WB16A-W, IK-WD14A) |

Double-Slash Path

If `rtsp://IP:554/live.sdp` does not work on your Toshiba camera, try the double-slash variant `rtsp://IP:554//live.sdp`. Some IK-WD models require this format.

## Connecting with VisioForge SDK

Use your Toshiba camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Toshiba IK-WD14A, main stream
var uri = new Uri("rtsp://192.168.1.90:554/live.sdp");
var username = "admin";
var password = "1234";
```

For sub-stream access on supported models, use `live2.sdp` instead of `live.sdp`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Compatible Models | Notes |
| --- | --- | --- | --- |
| JPEG Snapshot | `http://IP/__live.jpg?&&&` | IK-WB01A, WB11A, WB15A, WB16A-W, WB21A | Note underscore prefix |
| CGI Snapshot | `http://IP/GetData.cgi` | IK-WB01A, WB11A, WB15A, WB21A, WR01A | Basic snapshot |
| Configurable Snapshot | `http://IP/GetData.cgi?CH=CHANNEL&Codec=jpeg&Size=WIDTHxHEIGHT` | IK-WB series | Set resolution and channel |
| Resolution Snapshot | `http://IP/cgi-bin/viewer/video.jpg?resolution=WIDTHxHEIGHT` | IK-WB15A, WB16A, WB30A, WB70A, WR12A, WR14A | Specify output resolution |
| Simple Snapshot | `http://IP/Jpeg/CamImg.jpg` | IK-WB02A, WR01A | Basic JPEG capture |
| MJPEG Stream | `http://IP/video.mjpg` | IK-WB70A, WB80A, WR12A | Continuous MJPEG stream |

HTTP-Only Models

Early Toshiba models (IK-WB01A, WB02A, WB11A, WR01A, WR02A) do not support RTSP. For these cameras, use HTTP snapshot URLs or MJPEG streams. You can capture these via the VisioForge SDK's HTTP source or MJPEG source modes.

## Troubleshooting

### Camera is HTTP-only (no RTSP)

Many early IK-WB models (01A, 02A, 11A) and IK-WR models (01A, 02A) do not support RTSP streaming at all. These cameras only provide HTTP snapshot and CGI endpoints. If your camera does not respond on port 554, check whether it is an HTTP-only model from the tables above.

### Underscore prefix in snapshot URL

The `__live.jpg` snapshot URL uses a **double underscore prefix**, which is unusual. Make sure to include both underscores:

```
http://192.168.1.90/__live.jpg?&&&
```

The trailing `&&&` characters are also required on some firmware versions.

### Double-slash in RTSP path

Some IK-WD series cameras (WD12A, certain WD14A units) require a double forward slash in the RTSP path:

```
rtsp://admin:1234@192.168.1.90:554//live.sdp
```

If the standard single-slash URL does not connect, try this variant.

### No firmware updates available

Toshiba has exited the security camera market. No new firmware, patches, or official support channels are available. If you encounter bugs or security vulnerabilities, consider replacing the camera with a currently supported model.

### Default credentials not working

The factory default credentials are **admin / 1234**. If these do not work, the password may have been changed by a previous administrator. A hardware factory reset (usually a pinhole reset button) will restore defaults on most models.

## FAQ

**What is the default RTSP URL for Toshiba IP cameras?**

The primary RTSP URL is `rtsp://admin:1234@CAMERA_IP:554/live.sdp` for models that support RTSP streaming. Use `live2.sdp` for the sub stream on models like the IK-WD14A. Note that older IK-WB01A/02A/11A and IK-WR01A/02A models do not support RTSP at all.

**Are Toshiba IP cameras still supported?**

No. Toshiba sold its surveillance business and exited the IP camera market. No firmware updates, new models, or official technical support are available. Existing cameras continue to function but will not receive security patches or feature updates.

**Do Toshiba cameras support ONVIF?**

Only newer models in the IK-W14/16/30/70/80 range have limited ONVIF support. Older models (IK-WB01A through WB11A, IK-WR01A/02A) do not support ONVIF. For ONVIF discovery and configuration, use only the supported models.

**Why does my Toshiba camera only provide snapshots, not video streams?**

Early Toshiba IK-W models were designed as network snapshot cameras and do not include an RTSP server. These models (IK-WB01A, WB02A, WB11A, WR01A, WR02A) only support HTTP-based JPEG snapshots and CGI endpoints. To get continuous video, you need a newer model from the IK-W14/16/30/70/80 series.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Sony Connection Guide](../sony/) — Japanese enterprise cameras
- [JVC Connection Guide](../jvc/) — Japanese legacy surveillance brand
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## TP-Link and Tapo IP Camera RTSP URL Guide for C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/tp-link/
**Description:** TP-Link and Tapo C series camera RTSP URL patterns for C# .NET. Integrate TL-SC, NC, and Tapo models with VisioForge Video Capture SDK.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MP4, H.264, H.265, MJPEG, C#

# How to Connect to TP-Link IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**TP-Link** is a global networking equipment manufacturer headquartered in Shenzhen, China. While primarily known for routers and networking gear, TP-Link produces IP cameras under both the **TP-Link** brand (TL-SC series, now discontinued) and the **Tapo** smart home brand (Tapo C series, currently active). The Tapo line has become one of the best-selling consumer camera brands globally due to aggressive pricing and app-based setup.

**Key facts:**

- **Product lines:** TL-SC series (legacy, discontinued), NC series (cloud cameras, discontinued), Tapo C series (current smart home cameras)
- **Protocol support:** RTSP, HTTP/MJPEG, ONVIF (Tapo models with firmware update), proprietary cloud protocol
- **Default RTSP port:** 554
- **Default credentials:** Varies by generation (see below)
- **ONVIF support:** Tapo C series (requires enabling in Tapo app); TL-SC series has no ONVIF
- **Video codecs:** H.264 (all models), H.265 (Tapo C320WS and newer)

### Credentials by Product Line

| Product Line | Default Username | Default Password | Notes |
| --- | --- | --- | --- |
| TL-SC series | admin | admin | Legacy, fixed |
| NC series | admin | admin | Cloud-managed |
| Tapo C series | (set in app) | (set in app) | Must create RTSP credentials in Tapo app |

Tapo camera credentials

Tapo cameras require you to create a separate **camera account** in the Tapo app (Advanced Settings > Camera Account) before RTSP access works. This username/password is different from your TP-Link cloud account.

## RTSP URL Patterns

### Tapo C Series (Current Models)

The Tapo camera line uses a straightforward RTSP URL format:

| Model | RTSP URL | Stream | Audio |
| --- | --- | --- | --- |
| Tapo C100 (indoor) | `rtsp://IP:554/stream1` | Main (1080p) | Yes |
| Tapo C100 (indoor) | `rtsp://IP:554/stream2` | Sub (360p) | Yes |
| Tapo C110 (indoor 3MP) | `rtsp://IP:554/stream1` | Main (2304x1296) | Yes |
| Tapo C110 (indoor 3MP) | `rtsp://IP:554/stream2` | Sub | Yes |
| Tapo C200 (pan/tilt) | `rtsp://IP:554/stream1` | Main (1080p) | Yes |
| Tapo C200 (pan/tilt) | `rtsp://IP:554/stream2` | Sub (360p) | Yes |
| Tapo C210 (pan/tilt 3MP) | `rtsp://IP:554/stream1` | Main (2304x1296) | Yes |
| Tapo C310 (outdoor) | `rtsp://IP:554/stream1` | Main (2048x1296) | Yes |
| Tapo C320WS (outdoor 2K) | `rtsp://IP:554/stream1` | Main (2560x1440) | Yes |
| Tapo C500 (outdoor PTZ) | `rtsp://IP:554/stream1` | Main (1080p) | Yes |
| Tapo C520WS (outdoor 2K PTZ) | `rtsp://IP:554/stream1` | Main (2560x1440) | Yes |

### TL-SC Series (Legacy Models)

The discontinued TL-SC series used different URL formats depending on the model:

| Model | RTSP URL | Codec | Audio |
| --- | --- | --- | --- |
| TL-SC3130 | `rtsp://IP:554/video.mp4` | MPEG-4 | Yes |
| TL-SC3130G | `rtsp://IP:554/video.mp4` | MPEG-4 | Yes |
| TL-SC3171 | `rtsp://IP:554/video.mp4` | MPEG-4 | Yes |
| TL-SC3171G | `rtsp://IP:554/video.mp4` | MPEG-4 | Yes |
| TL-SC3230 | `rtsp://IP:554/video.h264` | H.264 | Yes |
| TL-SC3230N | `rtsp://IP:554/video.h264` | H.264 | Yes |
| TL-SC3430 | `rtsp://IP:554/video.h264` | H.264 | Yes |
| TL-SC3430N | `rtsp://IP:554/video.h264` | H.264 | Yes |
| TL-SC4171G | `rtsp://IP:554/video.mp4` | MPEG-4 | Yes |

### TL-SC Alternative URL Formats

| URL Pattern | Codec | Notes |
| --- | --- | --- |
| `rtsp://IP:554/video.mp4` | MPEG-4 | Primary for SC3xxx models |
| `rtsp://IP:554/video.h264` | H.264 | Primary for newer SC models |
| `rtsp://IP:554/video.mjpg` | MJPEG | Lower quality, wider compatibility |
| `rtsp://IP:554/video.pro2` | MPEG-4 | Alternative profile |
| `rtsp://IP:554/live.sdp` | H.264 | SDP-based stream |
| `rtsp://IP:554/cam1/h264` | H.264 | Channel-based format |
| `rtsp://IP:554/media.amp` | Auto | Axis-compatible firmware |

## Connecting with VisioForge SDK

Use your TP-Link camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// TP-Link Tapo C200, main stream
var uri = new Uri("rtsp://192.168.1.100:554/stream1");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `/stream2` instead.

## Snapshot and MJPEG URLs

### Tapo C Series

| Type | URL Pattern | Notes |
| --- | --- | --- |
| Snapshot | `http://IP/snapshot.jpg` | May require authentication |

### TL-SC Series

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/jpg/image.jpg` | Basic snapshot |
| Sized Snapshot | `http://IP/jpg/image.jpg?size=3` | Predefined size |
| CGI Snapshot | `http://IP/cgi-bin/jpg/image` | CGI-based |
| MJPEG Stream | `http://IP/video.mjpg` | Continuous MJPEG |
| MJPEG (quality) | `http://IP/video.mjpg?q=30&fps=33&id=0.5` | Quality/FPS control |
| Video CGI | `http://IP/video.cgi?resolution=VGA` | Resolution-specific |
| Net Video CGI | `http://IP/cgi-bin/net_video.cgi?channel=1` | Channel-based |
| Axis-compatible | `http://IP/axis-cgi/mjpg/video.cgi` | Emulated Axis API |

## Troubleshooting

### Tapo camera: "Connection refused" or "Unauthorized"

The most common issue with Tapo cameras is not setting up RTSP credentials:

1. Open the **Tapo app** on your phone
2. Go to your camera's settings
3. Navigate to **Advanced Settings > Camera Account**
4. Create a username and password
5. Use these credentials (not your TP-Link account) in RTSP URLs

### Tapo camera: ONVIF not working

ONVIF is disabled by default on Tapo cameras. To enable it:

1. Open the Tapo app
2. Go to camera settings > Advanced Settings
3. Enable **ONVIF** toggle
4. Camera will reboot

### TL-SC models: wrong codec URL

TL-SC cameras are codec-specific in their URLs:

- **SC3130/3171 series:** Use `/video.mp4` (MPEG-4)
- **SC3230/3430 series:** Use `/video.h264` (H.264)
- Using the wrong codec in the URL path will result in no stream

### Stream2 on Tapo cameras shows low resolution

This is by design. `stream2` is the sub stream intended for lower bandwidth. Use `stream1` for full resolution. You can adjust the sub stream resolution in the Tapo app under camera settings.

### TL-SC models: videostream.asf not working

The `videostream.asf` URL format requires URL-embedded credentials: `http://IP/videostream.asf?user=admin&pwd=admin&resolution=64&rate=0`

The `resolution` parameter values: 32 = 320x240, 64 = 640x480.

## FAQ

**What is the default RTSP URL for Tapo cameras?**

The URL is `rtsp://username:password@CAMERA_IP:554/stream1` for the main stream and `stream2` for the sub stream. You must first create RTSP credentials in the Tapo app under Advanced Settings > Camera Account.

**Can I use Tapo cameras without the Tapo cloud service?**

Yes. Once you set up RTSP credentials via the Tapo app, you can access the camera's RTSP stream directly over your local network without any cloud dependency. The Tapo app is only needed for initial setup and credential configuration.

**What's the difference between TL-SC and Tapo cameras?**

The TL-SC series was TP-Link's older IP camera line (discontinued) with traditional web-based management. Tapo is the current smart home camera brand with app-based setup. Both support RTSP but use different URL patterns and authentication methods.

**Do Tapo cameras support H.265?**

Select models like the Tapo C320WS and C520WS support H.265 encoding. Most Tapo cameras use H.264. Check your specific model's specifications for H.265 support.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Reolink Connection Guide](../reolink/) — Consumer alternative with RTSP
- [Mercusys Connection Guide](../mercusys/) — TP-Link sub-brand, same firmware
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## How to Connect to Ubiquiti (UniFi) IP Camera in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/ubiquiti/
**Description:** Ubiquiti UniFi Protect G3, G4, G5, and AI series RTSP URL patterns for C# .NET. Enable RTSP in UniFi and integrate with VisioForge SDK code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, C#

# How to Connect to Ubiquiti (UniFi) IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Ubiquiti Inc.** is an American technology company headquartered in New York City, known for networking equipment under the **UniFi** brand. Ubiquiti's camera line is part of the **UniFi Protect** ecosystem, which includes cameras, NVRs (Network Video Recorders), doorbells, and sensors. UniFi Protect cameras are managed through a central console (Dream Machine, Cloud Key, or NVR) and are popular in prosumer and SMB environments.

**Key facts:**

- **Product lines:** UniFi Protect G3 (1080p), G4 (2K/4MP), G5 (2K/4MP updated), AI series (with onboard AI), UVC (legacy AirCam)
- **Protocol support:** RTSP (must be enabled per camera), ONVIF (limited), proprietary UniFi Protect protocol
- **Default RTSP port:** 7447 (UniFi Protect) or 554 (legacy AirCam)
- **Default credentials:** Set during UniFi Protect setup (RTSP uses separate per-camera credentials)
- **ONVIF support:** Not natively supported; RTSP is the third-party integration method
- **Video codecs:** H.264 (all models)

RTSP must be enabled

UniFi Protect cameras do **not** have RTSP enabled by default. You must enable RTSP for each camera individually through the UniFi Protect web interface or app. Without enabling it, the camera will not respond to RTSP connections.

### Enabling RTSP on UniFi Protect Cameras

1. Open the **UniFi Protect** web interface (via your Dream Machine, Cloud Key, or NVR)
2. Go to **Devices** and select the camera
3. Open **Settings** tab
4. Scroll to **Advanced** section
5. Enable **RTSP** toggle
6. Note the RTSP URL displayed (includes unique token)

## RTSP URL Patterns

### UniFi Protect Cameras (Current)

UniFi Protect cameras expose RTSP on **port 7447** with stream quality selection:

| Stream | RTSP URL | Resolution | Notes |
| --- | --- | --- | --- |
| High quality | `rtsp://IP:7447/STREAM_TOKEN` | Full (up to 2688x1512) | Main stream |
| Medium quality | `rtsp://IP:7447/STREAM_TOKEN` | Reduced | Medium stream |
| Low quality | `rtsp://IP:7447/STREAM_TOKEN` | Low (640x360) | Bandwidth-optimized |

Stream tokens

UniFi Protect generates unique RTSP URLs per camera when you enable RTSP. The URL contains a unique token. You can find the exact URL in the UniFi Protect interface under each camera's Advanced settings.

The RTSP URL format is typically:

```
rtsp://CAMERA_IP:7447/UNIQUE_TOKEN_STRING
```

Where the token is auto-generated and displayed in the UniFi Protect UI.

### UniFi Protect Camera Models

| Model | Resolution | Streams | Form Factor |
| --- | --- | --- | --- |
| G3 Instant | 1920x1080 | High/Low | Indoor mini |
| G3 Flex | 1920x1080 | High/Medium/Low | Indoor/outdoor flex |
| G3 Bullet | 1920x1080 | High/Medium/Low | Outdoor bullet |
| G3 Dome | 1920x1080 | High/Medium/Low | Outdoor dome |
| G4 Instant | 2688x1512 | High/Medium/Low | Indoor mini |
| G4 Bullet | 2688x1512 | High/Medium/Low | Outdoor bullet |
| G4 Dome | 2688x1512 | High/Medium/Low | Outdoor dome |
| G4 Pro | 3840x2160 | High/Medium/Low | Outdoor pro |
| G4 PTZ | 3840x2160 | High/Medium/Low | PTZ |
| G5 Bullet | 2688x1512 | High/Medium/Low | Outdoor bullet |
| G5 Dome | 2688x1512 | High/Medium/Low | Outdoor dome |
| G5 Turret Ultra | 3840x2160 | High/Medium/Low | Outdoor turret |
| AI 360 | 3840x2160 | High/Medium/Low | Fisheye |
| AI Bullet | 3840x2160 | High/Medium/Low | Outdoor bullet |
| AI Pro | 3840x2160 | High/Medium/Low | Outdoor pro |

### Legacy AirCam/AirVision URLs

Older Ubiquiti cameras (AirCam series, before UniFi Protect) used standard port 554:

| Model | RTSP URL | Notes |
| --- | --- | --- |
| AirCam | `rtsp://IP:554/live/ch00_0` | Main stream |
| AirCam Dome | `rtsp://IP:554/live/ch00_0` | Dome variant |
| AirCam Mini | `rtsp://IP:554/live/ch00_0` | Mini variant |
| AirCam (channel) | `rtsp://IP:554/ch0N_0` | N = channel number |

## Connecting with VisioForge SDK

Use your UniFi Protect camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// UniFi Protect camera, token-based auth (no username/password needed)
var uri = new Uri("rtsp://192.168.1.40:7447/YOUR_STREAM_TOKEN");
```

UniFi Protect cameras use token-based authentication -- the unique stream token is provided in the UniFi Protect UI when you enable RTSP. No separate username or password is required. For different quality streams (high/medium/low), select the corresponding stream in the Protect interface to get its token.

For legacy AirCam models, use port 554 with credentials `ubnt`/`ubnt` and path `/live/ch00_0`.

## Snapshot URLs

### Legacy AirCam

| Type | URL Pattern | Notes |
| --- | --- | --- |
| Snapshot | `http://IP/snapshot.cgi` | Basic snapshot |
| Snapshot (auth) | `http://IP/snapshot.cgi?user=USER&pwd=PASS` | With credentials |
| Snapshot (alt) | `http://IP:554/snapshot.cgi?user=USER&pwd=PASS&count=0` | Via RTSP port |

### UniFi Protect

UniFi Protect cameras do not expose HTTP snapshot endpoints directly. Snapshots are accessed through the UniFi Protect API or by capturing frames from the RTSP stream in your application.

## Troubleshooting

### "Connection refused" on port 554

UniFi Protect cameras use **port 7447** for RTSP, not the standard port 554. Port 554 only applies to legacy AirCam models. Make sure you're using the correct port:

- **UniFi Protect cameras:** Port 7447
- **Legacy AirCam:** Port 554

### RTSP not enabled

RTSP is disabled by default on UniFi Protect cameras. You must enable it in the UniFi Protect interface:

1. UniFi Protect > Devices > Select Camera > Settings > Advanced > Enable RTSP

### Stream token changed

The RTSP stream token can change if you: - Disable and re-enable RTSP on the camera - Reset the camera - Update firmware

Always verify the current RTSP URL in the UniFi Protect interface if your connection stops working.

### High latency

UniFi Protect cameras can exhibit 2-5 second latency by default. To reduce latency:

- Set `LowLatencyMode = true` on the `RTSPSourceSettings` passed to VideoCaptureCoreX
- Select the low-quality stream (lower resolution = less buffering)
- Use TCP transport for more reliable delivery

### No ONVIF support

UniFi Protect cameras do not support ONVIF. Use RTSP for third-party integration. If you need ONVIF discovery, it won't work with these cameras.

## FAQ

**What is the default RTSP URL for UniFi Protect cameras?**

The RTSP URL format is `rtsp://CAMERA_IP:7447/UNIQUE_TOKEN`. RTSP must be enabled per-camera in the UniFi Protect interface, which will display the unique URL. There is no universal default URL -- each camera gets a unique stream token.

**Can I use UniFi cameras without UniFi Protect?**

Current UniFi cameras require a UniFi Protect controller (Dream Machine, Cloud Key, or NVR) for initial setup and management. Once RTSP is enabled, you can stream to third-party software. Legacy AirCam models work standalone.

**Do UniFi cameras support H.265?**

As of current firmware, UniFi Protect cameras stream H.264 over RTSP. H.265 support may be available for internal recording but is not typically exposed via RTSP.

**What are the default credentials for AirCam?**

Legacy AirCam cameras use `ubnt` / `ubnt` as default credentials. Current UniFi Protect cameras use token-based RTSP authentication.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Reolink Connection Guide](../reolink/) — Prosumer alternative with RTSP
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## How to Connect to Uniview (UNV) IP Camera in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/uniview/
**Description:** Uniview IPC-B, IPC-T, IPC-D, IPC-E, and NVR RTSP URL patterns for C# .NET. ONVIF-compatible integration with VisioForge SDK code samples.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Decoding, IP Camera, RTSP, ONVIF, H.265, MJPEG, C#

# How to Connect to Uniview (UNV) IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Uniview** (Zhejiang Uniview Technologies Co., Ltd.), also known as **UNV**, is the world's third-largest video surveillance manufacturer by market share, behind Hikvision and Dahua. Founded in 2005 and headquartered in Hangzhou, China, Uniview pioneered IP video surveillance in China and offers a full range of IP cameras, NVRs, VMS software, and access control products for enterprise and government markets.

**Key facts:**

- **Product lines:** IPC-B (bullet), IPC-T (turret), IPC-D (dome), IPC-E (eyeball), IPC-P (PTZ), NVR30x/50x (NVRs)
- **Protocol support:** RTSP, ONVIF Profile S/G/T, HTTP/CGI, SDK (EZStation)
- **Default RTSP port:** 554
- **Default credentials:** admin / 123456 (must be changed on first login with newer firmware)
- **ONVIF support:** Yes (all current models)
- **Video codecs:** H.264, H.265 (U-Code Smart Codec), MJPEG
- **Market position:** #3 globally in video surveillance

Uniview vs UNV Branding

Uniview markets under both the **Uniview** and **UNV** brand names depending on the region. The RTSP URL patterns and firmware are identical regardless of branding. Some OEM partners rebrand Uniview hardware under their own labels.

## RTSP URL Patterns

### Standard URL Format

Uniview cameras use a media profile-based URL structure:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/media/video[STREAM]
```

| Parameter | Value | Description |
| --- | --- | --- |
| `video1` | Main stream | Highest resolution (4K/5MP/4MP/2MP) |
| `video2` | Sub stream | Lower resolution, reduced bandwidth |
| `video3` | Third stream | Mobile-optimized (if supported) |

### Alternative URL Formats

Uniview cameras support multiple RTSP URL patterns:

| URL Pattern | Description |
| --- | --- |
| `rtsp://IP:554/media/video1` | Main stream (recommended) |
| `rtsp://IP:554/media/video2` | Sub stream |
| `rtsp://IP:554/media/video3` | Third stream |
| `rtsp://IP:554/unicast/c1/s0/live` | Unicast main stream (alternative) |
| `rtsp://IP:554/unicast/c1/s1/live` | Unicast sub stream (alternative) |
| `rtsp://IP:554/live/ch00_0` | Legacy format (older firmware) |
| `rtsp://IP:554/live/ch00_1` | Legacy sub stream |

### IP Camera Models

| Model Series | Resolution | Main Stream URL | Audio |
| --- | --- | --- | --- |
| IPC-B112-PF28 (2MP bullet) | 1920x1080 | `rtsp://IP:554/media/video1` | No |
| IPC-B314-APKZ (4MP bullet) | 2688x1520 | `rtsp://IP:554/media/video1` | Yes |
| IPC-B315-APKZ (5MP bullet) | 2880x1620 | `rtsp://IP:554/media/video1` | Yes |
| IPC-T112-PF28 (2MP turret) | 1920x1080 | `rtsp://IP:554/media/video1` | No |
| IPC-T314-APKZ (4MP turret) | 2688x1520 | `rtsp://IP:554/media/video1` | Yes |
| IPC-D312-APKZ (4MP dome) | 2688x1520 | `rtsp://IP:554/media/video1` | Yes |
| IPC-D314-APKZ (4MP dome) | 2688x1520 | `rtsp://IP:554/media/video1` | Yes |
| IPC-E312-APKZ (4MP eyeball) | 2688x1520 | `rtsp://IP:554/media/video1` | Yes |
| IPC-P1E2-I (2MP PTZ) | 1920x1080 | `rtsp://IP:554/media/video1` | Yes |
| IPC-B182-PF28 (4K bullet) | 3840x2160 | `rtsp://IP:554/media/video1` | Yes |

### NVR Channel URLs

For Uniview NVRs (NVR301, NVR302, NVR304, NVR501, NVR516):

| Channel | Main Stream | Sub Stream |
| --- | --- | --- |
| Camera 1 | `rtsp://IP:554/media/video1` | `rtsp://IP:554/media/video2` |
| Camera 2 | `rtsp://IP:554/media/video3` | `rtsp://IP:554/media/video4` |
| Camera 3 | `rtsp://IP:554/media/video5` | `rtsp://IP:554/media/video6` |
| Camera N | `rtsp://IP:554/media/video[2N-1]` | `rtsp://IP:554/media/video[2N]` |

NVR Channel Numbering

On Uniview NVRs, the video stream number encodes both the channel and stream type. Each channel uses two consecutive numbers: odd for main stream, even for sub stream. Camera 1 = video1/video2, Camera 2 = video3/video4, and so on.

## Connecting with VisioForge SDK

Use your Uniview camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Uniview IPC-B314-APKZ, main stream
var uri = new Uri("rtsp://192.168.1.90:554/media/video1");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `/media/video2` instead of `/media/video1`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/snapshot.cgi` | Requires digest authentication |
| ONVIF Snapshot | `http://IP/onvif-http/snapshot?channel=1` | ONVIF HTTP snapshot |

## Troubleshooting

### Default password must be changed

Uniview cameras with current firmware require the default password (`123456`) to be changed during initial setup. If you haven't configured the camera yet:

1. Access the camera at `http://CAMERA_IP` in a browser
2. Complete the activation wizard
3. Set a strong password
4. Use those credentials in your RTSP URL

### "unicast" vs "media" URL format

If `/media/video1` does not work on your camera, try the unicast format: `rtsp://IP:554/unicast/c1/s0/live`. Older Uniview firmware versions may only support the unicast path. Newer firmware supports both formats.

### H.265 stream not playing

Uniview's U-Code smart codec produces standard H.265/HEVC streams. If H.265 playback fails:

1. Install the HEVC decoder redistributable
2. Or switch the camera to H.264 encoding in the web interface: **Setup > Video > Video**
3. Use `rtspSettings.UseGPUDecoder = true` for hardware-accelerated H.265 decoding

### ONVIF discovery issues

ONVIF is enabled by default on Uniview cameras but may require a separate ONVIF password. Check **Setup > Network > ONVIF** in the web interface and ensure the ONVIF user account is configured.

## FAQ

**What is the default RTSP URL for Uniview cameras?**

The standard URL is `rtsp://admin:password@CAMERA_IP:554/media/video1` for the main stream. Use `/media/video2` for the sub stream. Some older models use `rtsp://IP:554/unicast/c1/s0/live` instead.

**Is Uniview the same as UNV?**

Yes. Uniview and UNV are the same company (Zhejiang Uniview Technologies). The branding varies by region. All cameras use identical firmware, RTSP URL formats, and web interfaces regardless of whether they carry the Uniview or UNV label.

**Do Uniview cameras support ONVIF?**

Yes. All current Uniview cameras support ONVIF Profile S and Profile T. ONVIF allows automatic camera discovery and standardized stream access without using brand-specific RTSP URLs.

**How do I access multiple channels on a Uniview NVR?**

Uniview NVRs use sequential video stream numbers: Camera 1 = video1 (main) / video2 (sub), Camera 2 = video3 (main) / video4 (sub), and so on. The formula is: main stream = video[2N-1], sub stream = video[2N] where N is the camera channel number.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Hikvision Connection Guide](../hikvision/) — Global market leader, different URL format
- [Dahua Connection Guide](../dahua/) — Another major Chinese surveillance brand
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Verkada Camera RTSP and C# .NET Integration Options
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/verkada/
**Description:** Verkada camera integration options in C# .NET. Understand cloud-managed architecture, RTSP limitations, and alternative approaches for Verkada cameras.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Webcam, IP Camera, RTSP, ONVIF, C#
**API:** MediaBlocksPipeline, SystemVideoSourceBlock, VideoRendererBlock

# How to Connect to Verkada Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Verkada** is an American cloud-managed security camera company headquartered in San Mateo, California. Founded in 2016, Verkada offers enterprise-grade cameras with a fully cloud-managed architecture. Unlike traditional IP cameras, Verkada cameras are managed exclusively through Verkada's cloud platform — there are no local RTSP streams, ONVIF support, or direct network access to the cameras.

**Key facts:**

- **Product lines:** CD (mini dome), CB (bullet), CE (outdoor dome), CF (fisheye), CM (multi-sensor), CP (PTZ)
- **Architecture:** Cloud-managed — all video processing and access goes through Verkada Command platform
- **RTSP support:** No
- **ONVIF support:** No
- **Local network access:** No direct access — cameras communicate only with Verkada cloud
- **Video codecs:** H.264, H.265 (managed by cloud platform)
- **API access:** Verkada API (cloud-based, requires enterprise subscription)

No RTSP or Local Streaming

Verkada cameras do **not** support RTSP, ONVIF, or any standard local streaming protocol. They are cloud-managed devices that can only be accessed through Verkada's Command platform or API. Direct integration using VisioForge SDK's RTSP source is not possible with Verkada cameras.

## Why Verkada Has No RTSP

Verkada's architecture is fundamentally different from traditional IP cameras:

1. **Cloud-first design:** Video is processed on-camera and streamed to Verkada's cloud
2. **No local network ports:** Cameras do not expose port 554 or any RTSP endpoint
3. **Managed access:** All video access goes through Verkada Command (web/mobile)
4. **Zero-trust security:** No direct camera-to-client connections on the LAN

This architecture provides simplified deployment and centralized management but eliminates direct SDK integration.

## Integration Options

### Option 1: Verkada API (Cloud-Based)

Verkada offers a REST API for enterprise customers that provides:

- Camera listing and status
- Video export/download (clips)
- Thumbnail/snapshot retrieval
- Event and alert data

The API does **not** provide live RTSP or real-time video streams. It is designed for clip retrieval and metadata access.

### Option 2: HDMI Output (Select Models)

Some Verkada models include an HDMI output port for local display. You can capture this output using an HDMI capture card:

```
// Capture HDMI output from Verkada camera via USB capture card
var pipeline = new MediaBlocksPipeline();

// Use system video source (HDMI capture card appears as webcam)
var captureDevice = new SystemVideoSourceBlock(captureDeviceSettings);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(captureDevice.Output, videoRenderer.Input);
await pipeline.StartAsync();
```

This approach provides real-time local video but requires physical HDMI connectivity and a capture card.

### Option 3: Alternative Cameras with RTSP

If you need direct RTSP integration with enterprise-grade cameras, consider these alternatives:

| Alternative | Market Segment | RTSP | ONVIF | Guide |
| --- | --- | --- | --- | --- |
| Axis | Enterprise | Yes | Yes | [Connection Guide](../axis/) |
| Bosch | Enterprise | Yes | Yes | [Connection Guide](../bosch/) |
| Hanwha Vision | Enterprise | Yes | Yes | [Connection Guide](../hanwha/) |
| Avigilon | Enterprise | Yes | Yes | [Connection Guide](../avigilon/) |
| Hikvision | Enterprise | Yes | Yes | [Connection Guide](../hikvision/) |

## FAQ

**Can I connect to Verkada cameras with RTSP?**

No. Verkada cameras do not support RTSP, ONVIF, or any local streaming protocol. They are cloud-managed devices accessible only through Verkada's Command platform or API.

**Does Verkada have an API for video access?**

Yes, but the Verkada API provides clip export and snapshot retrieval, not live video streaming. Real-time video is only available through the Verkada Command web interface or mobile app. Enterprise API access requires a Verkada subscription.

**Can I use VisioForge SDK with Verkada cameras?**

Not directly via RTSP. The only local integration option is capturing the HDMI output of select Verkada models using a capture card with VisioForge SDK's system video source. For cloud-based integration, you would need to use Verkada's API separately.

**What enterprise cameras support RTSP?**

For enterprise cameras with full RTSP and ONVIF support, see our guides for [Axis](../axis/), [Bosch](../bosch/), [Hanwha Vision](../hanwha/), [Avigilon](../avigilon/), and [Hikvision](../hikvision/).

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Axis Connection Guide](../axis/) — Enterprise alternative with RTSP
- [Bosch Connection Guide](../bosch/) — Enterprise alternative with RTSP
- [Rhombus Connection Guide](../rhombus/) — Another cloud-managed platform
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Vivotek IP Camera RTSP URL and C# .NET Connection Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/vivotek/
**Description:** Vivotek FD, IP, SD, and FE fisheye camera RTSP URL patterns for C# .NET. Stream and record using VisioForge Video Capture SDK with ONVIF support.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, IP Camera, RTSP, ONVIF, H.265, MJPEG, C#

# How to Connect to Vivotek IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Vivotek Inc.** is a Taiwanese manufacturer of network surveillance solutions headquartered in New Taipei City. Founded in 2000, Vivotek is one of the world's leading IP camera brands, widely deployed in enterprise, retail, transportation, and city surveillance. Vivotek is known for its wide range of form factors including fisheye, panoramic, speed dome, and specialty cameras.

**Key facts:**

- **Product lines:** FD (fixed dome), IP (box/bullet), IB (bullet), SD (speed dome), FE (fisheye), MD (mobile dome), CC (compact), VS (video servers/encoders)
- **Protocol support:** RTSP, ONVIF (Profile S/G/T), HTTP/CGI, MJPEG
- **Default RTSP port:** 554
- **Default credentials:** root / (empty or set during setup); legacy models: root / root
- **ONVIF support:** Yes (all current models)
- **Video codecs:** H.264, H.265, MJPEG

## RTSP URL Patterns

### Current Models

All current Vivotek cameras use the `live.sdp` URL pattern for RTSP streaming:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Stream 1 (main) | `rtsp://IP:554/live.sdp` | Main stream, H.264/H.265 |
| Stream 2 (sub) | `rtsp://IP:554/live2.sdp` | Sub stream |
| Stream 3 | `rtsp://IP:554/live3.sdp` | Third stream (if supported) |
| Stream 4 | `rtsp://IP:554/live4.sdp` | Fourth stream (some models) |

### Model-Specific URLs

| Model Series | RTSP URL | Form Factor |
| --- | --- | --- |
| FD81xx (fixed dome) | `rtsp://IP:554/live.sdp` | Fixed dome |
| FD83xx (fixed dome) | `rtsp://IP:554/live.sdp` | Fixed dome |
| FD8134/FD8136 | `rtsp://IP:554/live.sdp` | Mini dome |
| FD8161/FD8162/FD8166 | `rtsp://IP:554/live.sdp` | Fixed dome |
| FD8335H | `rtsp://IP:554/live.sdp` | Fixed dome |
| FD8361/FD8362E/FD8372 | `rtsp://IP:554/live.sdp` | Fixed dome |
| FE8171V/FE8172V/FE8174 | `rtsp://IP:554/live.sdp` | Fisheye |
| IP7130/IP7131/IP7132 | `rtsp://IP:554/live.sdp` | Box camera |
| IP7160/IP7161 | `rtsp://IP:554/live.sdp` | Box camera |
| IP7330/IP7361 | `rtsp://IP:554/live.sdp` | Bullet |
| IP8130/IP8133/IP8152 | `rtsp://IP:554/live.sdp` | Box camera |
| IP8331/IP8332/IP8335H | `rtsp://IP:554/live.sdp` | Box camera |
| IP8362/IP8364 | `rtsp://IP:554/live.sdp` | Box camera |
| SD8362E | `rtsp://IP:554/live.sdp` | Speed dome |
| CC8130 | `rtsp://IP:554/live.sdp` | Compact |
| MD7560/MD8562 | `rtsp://IP:554/live.sdp` | Mobile dome |

### Legacy Models

Older Vivotek models (IP3xxx, IP6xxx, PT3xxx, PZ6xxx series) used HTTP-only streaming:

| Model Series | URL | Notes |
| --- | --- | --- |
| IP3121/IP3122/IP3133/IP3135 | `http://IP/cgi-bin/video.jpg?size=2` | JPEG only |
| IP6127 | `http://IP/cgi-bin/video.jpg?size=2` | JPEG only |
| PT3112/PT3122 | `http://IP/cgi-bin/video.jpg?size=2` | Pan/tilt, JPEG |
| PZ6114/PZ6122 | `http://IP/cgi-bin/video.jpg?size=2` | Pan/zoom, JPEG |

### Video Server URLs

Vivotek video servers encode analog camera feeds for IP streaming:

| Model | RTSP URL | Notes |
| --- | --- | --- |
| VS2403 | `rtsp://IP:554/live.sdp` | Video server, multi-channel |
| VS3100P | `http://IP/cgi-bin/video.jpg?size=2` | Legacy encoder |
| VS7100 | `rtsp://IP:554/live.sdp` | Video server |
| VS8102 | `rtsp://IP:554/live.sdp` | Video server |
| VS8401 | `rtsp://IP:554/live.sdp` | 4-channel server |
| VS8801 | `rtsp://IP:554/live.sdp` | 8-channel server |

### NVR URLs

| Model | RTSP URL | Notes |
| --- | --- | --- |
| NR8x01 NVR | `rtsp://IP:554/live.sdp` | Via NVR |

## Connecting with VisioForge SDK

Use your Vivotek camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Vivotek camera, main stream
var uri = new Uri("rtsp://192.168.1.50:554/live.sdp");
var username = "root";
var password = "YourPassword";
```

For sub-stream access, use `/live2.sdp` instead.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/viewer/video.jpg?resolution=640x480` | Current models |
| JPEG Snapshot (channel) | `http://IP/cgi-bin/viewer/video.jpg?channel=1&resolution=640x480` | Multi-channel |
| MJPEG Stream | `http://IP/video.mjpg` | Continuous MJPEG |
| MJPEG Stream (alt) | `http://IP/video2.mjpg` | Second stream |
| MJPEG (params) | `http://IP/video.mjpg?q=30&fps=33&id=0.5` | With quality/fps params |
| Legacy Snapshot | `http://IP/cgi-bin/video.jpg` | Older models |
| Legacy Snapshot (sized) | `http://IP/cgi-bin/video.jpg?size=2` | Older models, VGA |
| Snapshot CGI | `http://IP/snapshot.cgi` | Some models |

## Troubleshooting

### Consistent URL pattern

Unlike many brands, Vivotek uses the same `live.sdp` RTSP URL pattern across virtually all their RTSP-capable models. If `rtsp://IP:554/live.sdp` doesn't work, try:

- `rtsp://IP:554/live2.sdp` (sub stream)
- `rtsp://IP:554/live3.sdp` (third stream)

### Default credentials

- **Current models:** `root` with password set during initial setup
- **Legacy models:** `root` / (empty password) or `root` / `root`
- Some models require setup via the web interface before RTSP is accessible

### Non-standard ports on some models

Some Vivotek cameras may use non-standard RTSP ports (e.g., 1025, 1032) if configured. Check the camera's web interface under Network > RTSP settings if port 554 doesn't respond.

### Legacy HTTP-only cameras

Very old Vivotek cameras (IP31xx, IP61xx, PT31xx, PZ61xx series) only support HTTP JPEG and MJPEG streams, not RTSP. These cameras cannot use the RTSP source -- use HTTP snapshot or MJPEG integration instead.

## FAQ

**What is the default RTSP URL for Vivotek cameras?**

The standard URL is `rtsp://root:password@CAMERA_IP:554/live.sdp` for the main stream. Use `live2.sdp` for the sub stream and `live3.sdp` for the third stream. This pattern works across virtually all RTSP-capable Vivotek models.

**Do Vivotek cameras support H.265?**

Yes. Current Vivotek cameras support H.265 (HEVC). Use the same `live.sdp` URL -- the codec is configured in the camera's web interface, not in the URL.

**What is the difference between live.sdp and live2.sdp?**

`live.sdp` is the main (highest quality) stream, `live2.sdp` is typically a lower-resolution sub stream for bandwidth-constrained viewing, and `live3.sdp` is a third stream often used for mobile viewing.

**Do Vivotek video servers support RTSP?**

Yes. Current Vivotek video servers (VS2403, VS7100, VS8102, VS8401, VS8801) support RTSP using the same `live.sdp` URL pattern as cameras. Legacy servers (VS3100P) only support HTTP JPEG.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [GeoVision Connection Guide](../geovision/) — Taiwanese enterprise cameras
- [ACTi Connection Guide](../acti/) — Taiwanese professional cameras
- [IP Camera Capture to MP4](../../videocapture/video-tutorials/ip-camera-capture-mp4/) — Record Vivotek streams to file
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Wisenet RTSP URL — Connect IP Camera with C# .NET SDK
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/wisenet/
**Description:** Wisenet X, P, Q, L series RTSP URL patterns for C# .NET apps. Hanwha Vision camera and NVR integration with ONVIF support and VisioForge SDK code.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Decoding, IP Camera, RTSP, ONVIF, MJPEG, C#

# How to Connect to Wisenet IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Wisenet** is the product brand name used by **Hanwha Vision** (formerly Hanwha Techwin / Samsung Techwin) for all IP cameras, NVRs, and video management systems. Wisenet is not a separate company but rather the product family name used across Hanwha Vision's full surveillance lineup.

**Key facts:**

- **Manufacturer:** Hanwha Vision (South Korea)
- **Product tiers:** X (premium), P (AI), Q (mainstream), Q mini (compact), L (value), T (thermal)
- **Protocol support:** RTSP, ONVIF Profile S/G/T, SUNAPI (proprietary)
- **Default RTSP port:** 554
- **Default credentials:** admin / (set during activation)
- **ONVIF support:** Yes (all current models)
- **Video codecs:** H.264, H.265, WiseStream III, MJPEG

Wisenet = Hanwha Vision Products

Wisenet is the **product brand**, Hanwha Vision is the **company**. All Wisenet cameras use the same RTSP URL patterns. For detailed connection instructions including NVR channel access and troubleshooting, see our [Hanwha Vision connection guide](../hanwha/). For legacy Samsung-branded cameras, see the [Samsung/Hanwha guide](../samsung/).

## RTSP URL Patterns

### Standard URL Format

All Wisenet cameras share the same profile-based URL structure:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/profile[N]/media.smp
```

### By Product Tier

| Wisenet Tier | Example Models | Main Stream URL | Key Feature |
| --- | --- | --- | --- |
| **X series** (premium) | XNO-6080R, XND-8080RV, XNP-6120H | `rtsp://IP:554/profile2/media.smp` | Best WDR, low-light |
| **P series** (AI) | PNO-A9081R, PND-A9081RV | `rtsp://IP:554/profile2/media.smp` | Deep learning analytics |
| **Q series** (mainstream) | QNO-8080R, QND-8080R, QNE-8021R | `rtsp://IP:554/profile2/media.smp` | Balanced features/price |
| **Q mini** (compact) | QND-8021 | `rtsp://IP:554/profile2/media.smp` | Discreet form factor |
| **L series** (value) | LNO-6032R, LND-6032R | `rtsp://IP:554/profile2/media.smp` | Entry-level |
| **T series** (thermal) | TNO-4030T, TNO-4050T | `rtsp://IP:554/profile2/media.smp` | Thermal + visible |

### Multi-Sensor and Multi-Directional Models

| Model Type | Stream URL | Notes |
| --- | --- | --- |
| Single sensor | `rtsp://IP:554/profile2/media.smp` | Standard |
| Multi-sensor channel 1 | `rtsp://IP:554/profile2/media.smp/trackID=channel1` | First sensor |
| Multi-sensor channel 2 | `rtsp://IP:554/profile2/media.smp/trackID=channel2` | Second sensor |
| Stitched panoramic | `rtsp://IP:554/profile2/media.smp/trackID=channel5` | Combined view |

### NVR / WAVE VMS Access

For Wisenet NVRs (XRN, QRN, LRN series):

| Channel | Main Stream | Sub Stream |
| --- | --- | --- |
| Camera 1 | `rtsp://IP:554/profile2/media.smp/trackID=channel1` | `rtsp://IP:554/profile3/media.smp/trackID=channel1` |
| Camera 2 | `rtsp://IP:554/profile2/media.smp/trackID=channel2` | `rtsp://IP:554/profile3/media.smp/trackID=channel2` |
| Camera N | `rtsp://IP:554/profile2/media.smp/trackID=channelN` | `rtsp://IP:554/profile3/media.smp/trackID=channelN` |

## Connecting with VisioForge SDK

Use your Wisenet camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Wisenet QNO-8080R (Q series 5MP), main stream
var uri = new Uri("rtsp://192.168.1.90:554/profile2/media.smp");
var username = "admin";
var password = "YourPassword";
```

For sub-stream access, use `/profile3/media.smp` instead of `/profile2/media.smp`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| JPEG Snapshot | `http://IP/cgi-bin/video.cgi?msubmenu=jpg&action=view&Resolution=1920x1080&Quality=5&Channel=0` | Requires digest auth |
| MJPEG Stream | `http://IP/cgi-bin/video.cgi?msubmenu=mjpeg&action=view&Channel=0&Stream=0` | Continuous MJPEG |

## Troubleshooting

### Which profile number is the main stream?

Wisenet cameras typically use `profile2` as the main (highest quality) stream. This is different from most other brands. If you get unexpected results, check the profile configuration in the camera's web interface (**Setup > Video/Audio > Video Profile**).

### WiseStream III bandwidth savings

WiseStream III dynamically adjusts encoding per region in the frame. The output is standard H.265 or H.264 -- no special decoder is needed. WiseStream settings can be configured in the camera's web interface.

### Camera activation

New Wisenet cameras require activation (setting a password) before use. Use the Wisenet Installation Wizard utility, web browser, or Wisenet mobile app for initial setup.

## FAQ

**What is the default RTSP URL for Wisenet cameras?**

All Wisenet cameras use `rtsp://admin:password@CAMERA_IP:554/profile2/media.smp` for the main stream. Use `profile3` for the sub stream.

**What is the difference between Wisenet X, P, Q, and L?**

**X** = premium enterprise. **P** = AI-powered analytics. **Q** = mainstream business. **L** = value/entry-level. **T** = thermal. All tiers use the same RTSP URL format.

**Is Wisenet the same as Samsung security cameras?**

Wisenet is the current product brand from Hanwha Vision, which acquired Samsung's security division in 2015. Legacy Samsung Techwin cameras may use different URL formats. See our [Samsung/Hanwha guide](../samsung/) for older models.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Hanwha Vision Connection Guide](../hanwha/) — Detailed Hanwha Vision integration
- [Samsung/Hanwha Legacy Guide](../samsung/) — Older Samsung Techwin models
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## How to Connect to Wyze Camera in C# .NET - RTSP Workarounds
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/wyze/
**Description:** Connect to Wyze cameras in C# .NET using RTSP firmware or Docker RTSP bridge. RTSP limitations, workarounds, and alternative approaches explained.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, C#

# How to Connect to Wyze Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Wyze Labs** is an American consumer electronics company based in Kirkland, Washington. Known for extremely affordable smart home cameras, Wyze became one of the best-selling camera brands in North America. However, Wyze cameras are **cloud-first devices** with very limited RTSP support, making direct integration challenging.

**Key facts:**

- **Product lines:** Cam v3/v4 (indoor/outdoor), Cam Pan v3 (PTZ), Cam OG (compact), Doorbell, Floodlight
- **Protocol support:** Wyze Cloud (primary), RTSP (limited — requires special firmware on select models)
- **Default RTSP port:** 8554 (when using RTSP firmware)
- **ONVIF support:** No
- **Video codecs:** H.264
- **Cloud dependency:** High — most features require Wyze app and cloud

Very Limited RTSP Support

Wyze cameras do **not** natively support RTSP. Official RTSP firmware was released only for the **Wyze Cam v2** and original **Wyze Cam Pan**, and these firmware builds are no longer actively maintained. For newer models (v3, v4, OG, Pan v3), RTSP requires third-party solutions like custom firmware.

## RTSP Support by Model

| Model | Native RTSP | RTSP Firmware | Third-Party RTSP | Notes |
| --- | --- | --- | --- | --- |
| Wyze Cam v2 | No | Yes (beta) | Yes | Official RTSP firmware available |
| Wyze Cam Pan v1 | No | Yes (beta) | Yes | Official RTSP firmware available |
| Wyze Cam v3 | No | No | Yes (docker-wyze-bridge) | Community workaround |
| Wyze Cam v4 | No | No | Yes (docker-wyze-bridge) | Community workaround |
| Wyze Cam Pan v3 | No | No | Yes (docker-wyze-bridge) | Community workaround |
| Wyze Cam OG | No | No | Yes (docker-wyze-bridge) | Community workaround |
| Wyze Doorbell v2 | No | No | Limited | May work with bridge |
| Wyze Cam Floodlight v2 | No | No | Yes (docker-wyze-bridge) | Community workaround |

## Option 1: Official RTSP Firmware (Cam v2 / Pan v1 Only)

Wyze released beta RTSP firmware for the Cam v2 and original Cam Pan. When flashed:

### RTSP URL Format

```
rtsp://[IP]:8554/live
```

Non-Standard Port

Wyze RTSP firmware uses port **8554**, not the standard 554.

### Setup Steps

1. Download the RTSP firmware from Wyze support (search "Wyze RTSP firmware")
2. Flash the firmware to the camera via microSD card
3. In the Wyze app, go to camera settings and enable RTSP
4. Note the RTSP URL shown in the app (usually `rtsp://CAMERA_IP:8554/live`)

### Connecting with VisioForge SDK

```
// Wyze Cam v2 with RTSP firmware
var uri = new Uri("rtsp://192.168.1.90:8554/live");
var username = ""; // no authentication on Wyze RTSP firmware
var password = "";
```

Use your Wyze camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code).

## Option 2: Docker Wyze Bridge (All Models)

For Wyze Cam v3, v4, Pan v3, OG, and other newer models, the community-developed **docker-wyze-bridge** project creates an RTSP proxy that converts Wyze cloud streams to local RTSP:

### How It Works

1. Docker Wyze Bridge authenticates with your Wyze account
2. It connects to the camera through the Wyze cloud API
3. It re-streams the video as a local RTSP stream
4. Your application connects to the bridge, not directly to the camera

### RTSP URL Format (via Bridge)

```
rtsp://[BRIDGE_IP]:8554/[CAMERA_NAME]
```

Where `CAMERA_NAME` is the name you assigned in the Wyze app (spaces replaced with dashes, lowercased).

### Connecting via Bridge with VisioForge SDK

```
// Wyze Cam v3 via docker-wyze-bridge
var uri = new Uri("rtsp://192.168.1.50:8554/front-door");
var username = ""; // bridge handles auth
var password = "";
```

Bridge Limitations

Docker Wyze Bridge introduces additional latency (typically 3-10 seconds) since the video passes through the Wyze cloud before reaching your local RTSP stream. It also requires your Wyze account credentials and an active internet connection.

## Troubleshooting

### No RTSP option in Wyze app

The RTSP toggle only appears on Wyze Cam v2 and Pan v1 when flashed with the RTSP firmware. It is not available on newer models. For v3/v4/OG/Pan v3, use the Docker Wyze Bridge approach.

### RTSP firmware not connecting

After flashing RTSP firmware on the Cam v2:

1. Wait 2-3 minutes for the camera to fully boot
2. Verify the camera is on the same network as your application
3. Try `rtsp://CAMERA_IP:8554/live` in VLC first to confirm the stream works
4. The stream has no authentication -- leave username/password empty

### High latency with Docker Wyze Bridge

The bridge routes video through Wyze's cloud servers, adding latency. For low-latency requirements, Wyze cameras may not be suitable. Consider cameras with native RTSP support like [Reolink](../reolink/), [Amcrest](../amcrest/), or [TP-Link Tapo](../tp-link/).

### Stream quality

Wyze cameras typically output 1080p H.264 streams. The RTSP firmware does not support changing resolution or codec. What the camera captures is what the RTSP stream provides.

## FAQ

**Do Wyze cameras support RTSP natively?**

No. Wyze cameras are cloud-first devices. The Wyze Cam v2 and original Cam Pan have official beta RTSP firmware, but it is no longer actively maintained. Newer models (v3, v4, OG, Pan v3) do not have RTSP firmware and require third-party bridges.

**Can I use Wyze cameras without the cloud?**

Very limited. Even with RTSP firmware, the initial setup requires the Wyze app and cloud account. The RTSP firmware for Cam v2/Pan v1 disables some cloud features. For newer models, the Docker Wyze Bridge still routes through the cloud.

**What cameras should I use instead of Wyze for RTSP?**

For affordable cameras with native RTSP support, consider [Reolink](../reolink/) (consumer), [Amcrest](../amcrest/) (consumer/SMB), [TP-Link Tapo](../tp-link/) (consumer), or [EZVIZ](../ezviz/) (smart home). All of these provide direct RTSP access without workarounds.

**Do Wyze cameras support ONVIF?**

No. Wyze cameras do not support ONVIF in any firmware version.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Reolink Connection Guide](../reolink/) — Affordable alternative with native RTSP
- [Amcrest Connection Guide](../amcrest/) — Consumer cameras with full RTSP
- [TP-Link Connection Guide](../tp-link/) — Budget cameras with RTSP support
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Zavio IP Camera RTSP URL Guide for C# .NET Integration
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/zavio/
**Description:** Zavio bullet, dome, and PTZ camera RTSP URL patterns for C# .NET. ONVIF-compatible integration with VisioForge SDK code for all Zavio models.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, MP4, H.264, MJPEG, C#

# How to Connect to Zavio IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Zavio** (Zavio Inc.) is a Taiwanese IP camera manufacturer headquartered in Hsinchu, Taiwan. Zavio is known for professional-grade network cameras with distinctive URL patterns that include both direct stream paths and profile-based paths. The company targets SMB and professional security markets with a range of bullet, dome, fixed, mini, and PTZ camera models.

**Key facts:**

- **Product lines:** B (bullet), D (dome), F (fixed/box), M (mini), P (PTZ/pan-tilt), V (vandal-proof)
- **Protocol support:** RTSP, ONVIF, HTTP/CGI, MJPEG
- **Default RTSP port:** 554
- **Default credentials:** admin / admin
- **ONVIF support:** Yes (most models)
- **Video codecs:** H.264, MPEG-4, MJPEG
- **Dual URL patterns:** Some models use `/video.mp4`, others use `/video.proN` (profile-based)

Profile-Based URLs

Zavio cameras support profile-based URLs. Use `/video.pro1` for the primary profile and `/video.pro2` for the secondary profile. The available profiles depend on your camera's configuration.

## RTSP URL Patterns

### Standard URL Format

Zavio cameras support two primary RTSP URL patterns:

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554/video.mp4
```

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:554//video.pro1
```

| URL Path | Description |
| --- | --- |
| `/video.mp4` | MP4 main stream (most common format) |
| `//video.pro1` | Profile 1 / primary stream (double-slash prefix) |
| `//video.pro2` | Profile 2 / sub stream (double-slash prefix) |
| `//video.h264` | Direct H.264 stream (some models) |

### Camera Models

| Model | Type | Main Stream URL | Notes |
| --- | --- | --- | --- |
| B5110 (bullet) | Bullet | `rtsp://IP//video.pro1` | Profile-based, also supports `//video.h264` |
| B5210 (bullet) | Bullet | `rtsp://IP//video.pro1` | Profile-based |
| B7110 (bullet) | Bullet | `rtsp://IP:554/video.mp4` | MP4 main stream |
| B7210 (bullet) | Bullet | `rtsp://IP:554/video.mp4` | MP4 main stream |
| D3100 (dome) | Dome | `rtsp://IP//video.pro1` | Profile-based |
| D3200 (dome) | Dome | `rtsp://IP:554/video.mp4` | MP4 main stream |
| D4210 (dome) | Dome | `rtsp://IP:554/video.mp4` | MP4 main stream |
| D50E (dome) | Dome | `rtsp://IP:554/video.mp4` | MP4 main stream |
| D510E (dome) | Dome | `rtsp://IP:554/video.mp4` | MP4 main stream |
| D520E (dome) | Dome | `rtsp://IP:554/video.mp4` | MP4 main stream |
| D7111 (dome) | Dome | `rtsp://IP:554//video.pro2` | Profile 2 sub stream |
| D7210 (dome) | Dome | `rtsp://IP:554//video.pro2` | Profile 2 sub stream |
| F1100 (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F1105 (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F1150 (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F210A (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F3100 (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F3102 (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F3110 (fixed) | Fixed | `rtsp://IP:554//video.pro2` | Profile 2 sub stream |
| F3115 (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F312A (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F3201 (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F3206 (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F3210 (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F3215 (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F511E (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F520IE (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F521E (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| F731E (fixed) | Fixed | `rtsp://IP:554/video.mp4` | MP4 main stream |
| M510W (mini) | Mini | `rtsp://IP:554/video.mp4` | Wireless mini camera |
| M511E (mini) | Mini | `rtsp://IP:554/video.mp4` | Mini camera |
| P5110 (PTZ) | PTZ | `rtsp://IP:554/video.mp4` | Pan-tilt-zoom |
| P5115 (PTZ) | PTZ | `rtsp://IP:554/video.mp4` | Pan-tilt-zoom |
| P5210 (PTZ) | PTZ | `rtsp://IP:554/video.mp4` | Pan-tilt-zoom |

### Alternative URL Formats

Some Zavio models support these alternative URLs:

| URL Pattern | Notes |
| --- | --- |
| `rtsp://IP:554/video.mp4` | MP4 stream (recommended for most models) |
| `rtsp://IP//video.pro1` | Profile 1, primary stream |
| `rtsp://IP:554//video.pro2` | Profile 2, sub stream |
| `rtsp://IP//video.h264` | Direct H.264 stream (B5110 and similar) |

## Connecting with VisioForge SDK

Use your Zavio camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Zavio B7110, MP4 main stream
var uri = new Uri("rtsp://192.168.1.90:554/video.mp4");
var username = "admin";
var password = "admin";
```

For profile-based cameras, use `//video.pro1` for the primary stream or `//video.pro2` for the sub stream.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| Profile Snapshot | `http://IP/cgi-bin/view/image?pro_CHANNEL` | Snapshot by profile number |
| JPEG Snapshot | `http://IP/jpg/image.jpg` | Standard JPEG snapshot |
| Sized JPEG | `http://IP/jpg/image.jpg?size=3` | JPEG with size parameter |
| CGI JPEG | `http://IP/cgi-bin/jpg/image` | CGI-based JPEG snapshot |
| MJPEG Stream | `http://IP/video.mjpg` | Continuous MJPEG stream |
| MJPEG (quality/FPS) | `http://IP/video.mjpg?q=30&fps=33&id=0.5` | MJPEG with quality and FPS control |
| Profile HTTP Stream | `http://IP/stream?uri=video.proN` | Profile-based HTTP stream |

## Troubleshooting

### "401 Unauthorized" error

Zavio cameras ship with default credentials of `admin` / `admin`. If the camera has been configured with different credentials:

1. Access the camera at `http://CAMERA_IP` in a browser
2. Log in and check **Network > RTSP** settings
3. Verify that RTSP authentication is enabled and your credentials are correct

### Choosing between /video.mp4 and /video.proN

Zavio cameras have two URL families. The correct choice depends on your model:

- **Most models** (B7110, F210A, F312A, F520IE, F521E, F731E, etc.): Use `/video.mp4`
- **Older or profile-based models** (B5110, B5210, D3100): Use `//video.pro1`
- If one format fails, try the other

### Double-slash in profile URLs

Profile-based Zavio URLs require a double-slash (`//`) before `video.proN`. This is intentional:

- Correct: `rtsp://IP//video.pro1`
- Incorrect: `rtsp://IP/video.pro1`

If you omit the double-slash on a profile-based model, the connection may fail.

### No video with MPEG-4 codec

Some older Zavio models default to MPEG-4 encoding. If you experience codec issues:

- Log in to the camera web interface
- Change the video codec to **H.264** under the stream configuration
- Use the `/video.mp4` or `//video.pro1` URL after changing the setting

### Port 554 connection refused

Verify that RTSP is enabled on the camera:

- Web interface: Check **Network > RTSP** settings
- Confirm port 554 is not blocked by a firewall
- Default RTSP port is 554

## FAQ

**What is the default RTSP URL for Zavio cameras?**

The most common URL is `rtsp://admin:admin@CAMERA_IP:554/video.mp4` for the MP4 main stream. For profile-based models, use `rtsp://admin:admin@CAMERA_IP//video.pro1` instead.

**Do Zavio cameras support ONVIF?**

Yes. Most Zavio models support ONVIF, which provides a standardized method for camera discovery and streaming without needing brand-specific URL patterns.

**What is the difference between /video.mp4 and /video.pro1?**

`/video.mp4` is a direct stream path used by most newer Zavio models. `//video.pro1` and `//video.pro2` are profile-based paths that reference stream profiles configured in the camera's web interface. Profile 1 is typically the main (high-resolution) stream, and Profile 2 is typically the sub (lower-resolution) stream.

**What are the default login credentials for Zavio cameras?**

The default username is `admin` and the default password is `admin`. It is strongly recommended to change these credentials after initial setup.

**Can I control MJPEG quality and frame rate?**

Yes. Zavio cameras support MJPEG parameters in the URL. Use `http://IP/video.mjpg?q=30&fps=33&id=0.5` to specify quality (`q`), frames per second (`fps`), and stream identifier (`id`).

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Edimax Connection Guide](../edimax/) — Taiwanese SMB cameras
- [ONVIF Capture with Postprocessing](../../mediablocks/Guides/onvif-capture-with-postprocessing/) — Zavio ONVIF capture pipeline
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## Zmodo RTSP URL Guide — Connect IP Cameras in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/camera-brands/zmodo/
**Description:** Zmodo ZH Wi-Fi, ZP PoE, and DVR/NVR RTSP URL patterns for C# .NET. Stream and record Zmodo cameras with VisioForge Video Capture SDK integration.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, IP Camera, RTSP, ONVIF, H.264, MJPEG, C#

# How to Connect to Zmodo IP Camera in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Brand Overview

**Zmodo Technology** is a consumer security camera brand headquartered in Shenzhen, China. Zmodo is known for affordable Wi-Fi and wired IP cameras, DVR/NVR systems, and smart home security products. The brand targets the budget consumer market and is widely available through online retailers.

**Key facts:**

- **Product lines:** ZH-IXx (Wi-Fi cameras), ZP-IBH/IBI (PoE cameras), CM-I (legacy IP cameras), ZMD-ISV (DVR systems), Greet (smart doorbell)
- **Protocol support:** RTSP, HTTP/MJPEG (legacy), Zmodo Zink (proprietary), ONVIF (limited, some ZP models)
- **Default RTSP port:** 10554 (Wi-Fi cameras), 554 (standard/DVR models)
- **Default credentials:** admin / admin or admin / (empty password)
- **ONVIF support:** Limited (some newer ZP-series PoE models only)
- **Video codecs:** H.264, MPEG-4 (legacy DVR)

Zmodo Zink cameras

Zmodo cameras that use the proprietary **Zink** protocol do **not** support RTSP at all. These cameras can only be accessed through the Zmodo app. Check your camera's specifications before attempting RTSP connections.

## RTSP URL Patterns

Zmodo cameras use different RTSP ports and URL formats depending on the product line.

### Wi-Fi Cameras (ZH-Series) -- Port 10554

```
rtsp://[USERNAME]:[PASSWORD]@[IP]:10554//tcp/av0_0
```

Non-standard port 10554

Zmodo Wi-Fi cameras (ZH-series) use **port 10554**, not the standard 554. This is the most common connection issue with Zmodo cameras.

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| Main stream | `rtsp://IP:10554//tcp/av0_0` | Full resolution |
| Sub stream | `rtsp://IP:10554//tcp/av0_1` | Lower resolution |

### Model-Specific URLs (Wi-Fi / PoE)

| Model | RTSP URL | Type |
| --- | --- | --- |
| ZH-IXA15-WC | `rtsp://IP:10554//tcp/av0_0` | Wi-Fi indoor |
| ZH-IXB15-WC | `rtsp://IP:10554//tcp/av0_0` | Wi-Fi indoor |
| ZH-IXC15-WC | `rtsp://IP:10554//tcp/av0_0` | Wi-Fi indoor |
| ZH-IXD15-WC | `rtsp://IP:10554//tcp/av0_0` | Wi-Fi indoor |
| ZH-IBH13-W | `rtsp://IP:10554//tcp/av0_0` | Wi-Fi bullet |
| ZP-IBH13-P | `rtsp://IP:10554//tcp/av0_0` | PoE bullet |
| ZP-IBI13-W | `rtsp://IP:10554//tcp/av0_0` | PoE indoor |

### Standard H.264 Cameras -- Port 554

Some Zmodo cameras use the standard RTSP port:

| Stream | RTSP URL | Notes |
| --- | --- | --- |
| H.264 direct | `rtsp://IP:554/h264` | Standard port |
| Channel stream | `rtsp://IP:554/VideoInput/1/h264/1` | Channel-based |
| Channel number | `rtsp://IP:554/[CHANNEL]` | Direct channel |

### Legacy CM-I Series

| Model | RTSP URL | Alt URL | Notes |
| --- | --- | --- | --- |
| CM-I11123BK | `rtsp://IP:554/VideoInput/1/h264/1` | `http://IP/videostream.asf` | HTTP fallback |
| CM-I12316GY | `rtsp://IP:554/VideoInput/1/h264/1` | `http://IP/videostream.asf` | HTTP fallback |

### DVR/NVR Systems

| Model | RTSP URL | Notes |
| --- | --- | --- |
| ZMD-ISV-BFS23NM | `rtsp://IP:554/VideoInput/1/h264/1` | Channel 1 |
| DVR (MPEG-4) | `rtsp://IP:554/mpeg4` | Legacy format |
| DVR (auth in URL) | `rtsp://IP:554/0/USERNAME:PASSWORD/main` | Auth in path |

## Connecting with VisioForge SDK

Use your Zmodo camera's RTSP URL with any of the three SDK approaches shown in the [Quick Start Guide](../#quick-start-code):

```
// Zmodo ZH-series Wi-Fi camera, main stream -- note port 10554!
var uri = new Uri("rtsp://192.168.1.60:10554//tcp/av0_0");
var username = "admin";
var password = "admin";
```

For sub-stream access, use `//tcp/av0_1` instead of `//tcp/av0_0`.

## Snapshot and MJPEG URLs

| Type | URL Pattern | Notes |
| --- | --- | --- |
| Snapshot | `http://IP/snapshot.cgi?user=USER&pwd=PASS` | Standard models |
| Snapshot (camera) | `http://IP/snapshot.cgi?camera=1` | Camera selection |
| DVR Snapshot | `http://IP/cgi-bin/snapshot.cgi?loginuse=USER&loginpas=PASS` | DVR systems |
| ASF Stream | `http://IP/videostream.asf?user=USER&pwd=PASS&resolution=64&rate=0` | Legacy CM-I |
| MJPEG Stream | `http://IP/videostream.cgi?rate=11` | Legacy models |

## Troubleshooting

### Must use port 10554 for Wi-Fi cameras

The most common Zmodo connection issue is using port 554 when the camera requires **port 10554**. All ZH-series Wi-Fi cameras and many ZP-series PoE cameras use port 10554. If your connection times out on port 554, switch to 10554.

### TCP transport in URL path

The `//tcp/av0_0` path explicitly specifies TCP transport. This is built into the Zmodo URL format and is not optional. Do not remove the `//tcp/` prefix from the path.

### Zmodo app required for initial setup

Some Zmodo cameras require the Zmodo mobile app for initial Wi-Fi setup and activation. RTSP access may not be available until the camera has been set up through the app at least once. Complete the initial setup before attempting RTSP connections.

### Zink protocol cameras do not support RTSP

Zmodo cameras that use the proprietary **Zink** protocol are designed exclusively for the Zmodo ecosystem and do not support RTSP, ONVIF, or any third-party streaming protocol. Check the camera specifications or packaging for "Zink" branding. If your camera uses Zink, it cannot be accessed via RTSP.

### Legacy CM-I cameras use HTTP streaming

Older CM-I series cameras may have limited or unreliable RTSP support. If RTSP fails on a CM-I model, fall back to the HTTP ASF or MJPEG streaming URLs: `http://IP/videostream.asf?user=USER&pwd=PASS`.

### DVR authentication format

Some Zmodo DVRs embed credentials in the RTSP path rather than using standard RTSP authentication: `rtsp://IP:554/0/USERNAME:PASSWORD/main`. If standard authentication fails, try this URL format.

## FAQ

**What is the default RTSP URL for Zmodo Wi-Fi cameras?**

For ZH-series Wi-Fi cameras, the URL is `rtsp://admin:admin@CAMERA_IP:10554//tcp/av0_0`. Note the non-standard port 10554 and the `//tcp/` prefix in the path.

**Why does my Zmodo camera use port 10554 instead of 554?**

Zmodo chose port 10554 for their Wi-Fi camera line. This is a fixed port in the camera firmware. Some standard (non-Wi-Fi) Zmodo cameras and DVR systems use the standard port 554.

**Do all Zmodo cameras support RTSP?**

No. Zmodo cameras that use the proprietary Zink protocol do not support RTSP. These cameras are limited to the Zmodo app and cloud service. Most ZH-series, ZP-series, and CM-I series cameras do support RTSP.

**Does Zmodo support ONVIF?**

ONVIF support on Zmodo cameras is limited. Some newer ZP-series PoE models include ONVIF support, but most consumer Wi-Fi models (ZH-series) do not. Check your specific model's specifications for ONVIF compatibility.

**What is the difference between av0\_0 and av0\_1?**

In the Zmodo RTSP URL, `av0_0` is the main (highest quality) stream and `av0_1` is the sub (lower resolution) stream. Use `av0_1` when you need lower bandwidth consumption for remote viewing.

## Related Resources

- [All Camera Brands — RTSP URL Directory](../)
- [Foscam Connection Guide](../foscam/) — Budget consumer IP cameras
- [IP Camera Preview Tutorial](../../videocapture/video-tutorials/ip-camera-preview/)
- [SDK Installation & Samples](../#get-started)

---END OF PAGE---


## VisioForge .NET SDKs — Changelog and Release Notes
**URL:** https://www.visioforge.com/help/docs/dotnet/changelog/
**Description:** Version history for Video Capture, Media Player, Video Edit, and Media Blocks SDKs. New features, bug fixes, API changes, and platform updates.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, DirectShow, Windows, Capture, Playback, Streaming, Editing
**API:** VideoCaptureCore, VideoCaptureCoreX, VideoView, MediaPlayerCoreX, DeviceEnumerator

# Changelog

Changes and updates for all .Net SDKs.

## 2026.9.1

- [Video Capture SDK .Net] **Removed: the RTSP X network streaming output.** `NetworkStreamingFormat.RTSP_X` and the `RTSPXOutput` settings class are gone from `VideoCaptureCore`, and the `VisioForge.DotNet.Core.Redist.RTSPX.x64` package is no longer published - it carried its own GStreamer runtime that had not been refreshed since 2024 and loaded alongside the current one. Use `VideoCaptureCoreX` with `RTSPServerOutput`/`RTSPServerSettings`, which serves RTSP from the maintained runtime and needs no extra package. `NetworkStreamingFormat.RTSP_H264_AAC_SW` remains available on `VideoCaptureCore` (#1262).
- [Media Blocks SDK .Net] **Fixed: on Windows, stopping an SRT pipeline never returned when the receiving peer had gone away.** `StopAsync` blocked indefinitely on `SRTSinkBlock` and `SRTMPEGTSSinkBlock`, and the pipeline could never be disposed - the bundled SRT plugin kept closing and reopening the connection, and End-Of-Stream could not be delivered while the sink's streaming thread was inside that loop. The Windows redistributable now carries the corrected SRT plugin macOS has shipped since 2026.8.5, so a stop against an unreachable or flapping peer completes in about a second (#1190).
- [Core] **The RAV1E AV1 encoder now encodes across CPU cores.** `rav1enc` splits work by tiles and the SDK never set that property, so it ran the whole frame as a single tile and encoded at the same speed on 4 cores as on 32. The new `RAV1EEncoderSettings.Tiles` defaults to 16: measured on 720p30, 8 seconds of content now takes about 29 seconds instead of 84, for roughly 1% more bitrate at the same `Quantizer`. Set `Tiles = 0` for the previous single-tile output (#1345).
- [Media Blocks SDK .Net] **Fixed: a Basler camera was opened by its position in the device list, not by the camera you named.** `BaslerCameraInfo` read only `DeviceIndex`, so an instance built with `new BaslerCameraInfo(name)` - which leaves that index at 0 - read its sensor size from, and streamed, the first Basler device on the machine whatever the name said. The camera is now found by its serial number, full name, user-defined name or name, and `pylonsrc` is pointed at it by identity rather than by index; a named camera that is not present is now reported and the capture fails to start, instead of quietly streaming another one (#1344).

## 2026.8.31

- [Media Blocks SDK .Net] **Fixed: a video mixer could save a source that would not load back, and a restored Basler source could report zero frame rate.** A mixer source whose camera name had been cleared was written into the document without it, the snapshot reported success, and loading that document failed - it is refused at save time now, naming the block. And a Basler camera whose frame rate could not be read when the document was saved kept a zero frame rate on every later load, which reached the recording's frame info; it is re-read now, as the sensor size already was.
- [Media Blocks SDK .Net] **Fixed: a Spinnaker source could open a different camera than the one it was told to, without saying so.** The camera was addressed by its position in the enumerated list rather than by its own index, so one camera failing to initialize - held by another process, for instance - shifted every camera after it, and the source silently opened its neighbour. A name matching no camera at all, or matching two identical bodies (the name is the model name, which they share), was equally silent. The index is now the camera's own, `SpinnakerCameraInfo` carries the serial number, and all three cases are reported. two handles leaked during enumeration are released; one camera failing to answer no longer hides every other camera on the rig, and no longer leaves a truncated list cached; a camera whose model name cannot be read is listed under its serial number instead of under a name every unreadable camera shares; and a camera index the element cannot address fails the source instead of quietly opening a different camera - the element accepts 0-7, so on a rig with nine or more cameras the ninth and beyond now report an error at build time rather than streaming a neighbour.
- [X-engines] **Fixed: an SDK error killed the process when the application had not subscribed `OnError`.** `VideoEditCoreX` reported such an error by logging it, and the log is what raises the error event, so every error re-entered the reporting path and recursed until the stack overflowed - the process died with no exception and no message. A render that could not build its encoder was the common way in. The error is now reported once, and shown on the video view exactly as the other engines do. `MediaBlocksPipeline` had the same loop on its two "VisioForge\_MFP.dll not found" messages, which recursed whenever a debugger was attached (#1173).
- [Media Blocks SDK .Net] **Fixed: a virtual camera sink with an input that was created but never connected wedged the pipeline.** `VirtualCameraSinkBlock` built the chain for a pad that exists rather than for one that is connected, so an unconnected input left a branch with nothing feeding it - a branch that can neither preroll nor reach End-Of-Stream, leaving either `StartAsync` or `StopAsync` never returning. Two connected inputs of the same type are now reported as an error too - only one of them was ever linked (#1288).
- [Media Blocks SDK .Net] **`NDISinkBlock.IsAvailable()` now reports `false` when the NDI runtime is missing.** It answered from the GStreamer element alone, so on a machine carrying the plugin but no NDI runtime it reported the sink as available and the pipeline then failed to start (#1288).
- [Media Blocks SDK .Net] **Fixed: stopping a pipeline whose `NDISinkBlock` had only a video input never returned.** `StopAsync` blocked forever and the pipeline could never be disposed; adding an audio input was the only workaround. The sink built its audio chain even when no audio was connected, and the unfed combiner pad stalled the End-Of-Stream a graceful stop sends. A video-only NDI sink now stops normally. An NDI sink with no video input, which cannot produce an NDI stream at all, is now reported as a build error instead of hanging the same way (#1288).
- [Media Blocks SDK .Net] **Fixed: nothing decoded when a decoder was connected to `UniversalDemuxBlock`.** The demuxer hands out encoded data, so a decoder behind it is the normal way to use it - and that graph delivered no frames at all, while the pipeline reported a successful start and put nothing on the bus. A stream the demuxer was told not to render was sent to a plain null sink, which stalled the demuxer until the pipeline reached playing, and the pipeline could not reach playing because the decoder branch was starved of the frames it needed. This affects `UniversalDemuxBlock` and `UniversalAutoDemuxerBlock` with `renderVideo` or `renderAudio` turned off, and every decoder behind them, `UniversalDecoderBlock`, `DecodeBinBlock` and the codec-specific decoder blocks alike. A demuxer also no longer throws when the file turns out to hold more streams of a type than its media info reported, and `UniversalDemuxBlock` can now output a metadata stream (#836).
- [Media Blocks SDK .Net] **`UniversalDemuxSettings.Type` can now be set.** It was declared without a setter, so that settings class always meant automatic container detection whatever was assigned to it; the per-format settings classes were the only way to pick a specific demuxer. The default is unchanged (#836).
- [Media Blocks SDK .Net] **Pipeline documents now write enum settings by name instead of by number.** Many of the SDK's enums declare their members per platform, so the same ordinal meant a different member elsewhere - `1` was `WASAPI` on Windows and `Decklink` on macOS - and a document moved between platforms silently restored the wrong device API, encoder or format. A saved pipeline now reads `"api": "WASAPI"`. Documents written before this still load; a document written by this build cannot be opened by an earlier one (#1322).
- [Media Blocks SDK .Net] **A pipeline document now restores the audio device a block was using.** `AudioRendererBlock`, `SystemAudioSourceBlock` and the WASAPI, WASAPI2, DirectSound, loopback and PulseAudio audio sources hold an `AudioOutputDeviceInfo` or `AudioCaptureDeviceInfo`, and neither could be written to a document and read back - so a saved pipeline came back either refusing to load or holding no device at all. A document now stores what identifies the device (its name, path, API and, on macOS, the stable CoreAudio `unique-id`), and materialization matches that against the devices the machine actually has, handing the block a live device again. This also fixes a saved configuration opening the wrong speaker or microphone: the numeric CoreAudio id and the WASAPI path are both reassigned between runs, and the match now re-reads the current ones. When the named device is gone, the pipeline still builds on a system device of the same API and materialization reports it as the new `MBS063` warning naming both devices. `AlliedVisionSourceSettings` restores from the camera's identity the same way, without opening the camera (#1322).
- [Media Blocks SDK .Net] **Fixed: a pipeline document silently lost mandatory block settings and restored a block wired to the wrong thing.** A setting exposed as a read-only property - the bridge `Channel` above all, but also `CustomMediaBlockSettings.ElementName`, `GLOverlaySettings.Filename`, `GLEquirectangularViewSettings.VideoWidth`/`VideoHeight`, `AlliedVisionSourceSettings.Camera` and the GenICam region, frame rate and pixel format - was never written into a saved document, and came back as `null` or `0` with validation, deserialization and materialization all reporting success. Two app bridges saved on different channels reloaded onto the same one. Those settings now round-trip, a document missing one is reported as `MBS043` naming the property instead of restoring a mis-wired block, and `MediaBlockDescriptor.Properties` lists them (with the new `IsRequired` and `IsReadOnly` flags) so an editor can author them. Eight settings types could not be restored at all, because a constructor parameter matched no property and the serializer refuses to bind such a constructor - every document holding a `BridgeAudioSource`, `HTTPSource`, `AudioRenderer`, `OpenCVTemplateMatch`, `LiveSourceSwitch`, `LiveSourceSwitchDynamic`, `AlliedVisionSource` or `VideoAspectRatioCrop` block failed to load. All of them now restore. The parameters are renamed to match their properties: `BridgeAudioSourceSettings(channel, info)`, `HTTPSourceSettings(location, isLive)`, `AudioRendererSettings(info)`, `CVTemplateMatchSettings(templateImage)` and `LiveSourceSwitchSettings(videoWidth, videoHeight, videoFrameRate)`. Positional calls are unaffected; code passing these by name must be updated (#1322).
- [Media Blocks SDK .Net] **Fixed: a pipeline document holding a `SpinnakerSource` block could not be loaded, and a mixer holding a Spinnaker source could not be saved.** The constructor's first parameter matched no property, which the serializer refuses outright, and the region, frame rate and pixel format were never written into the document. All four settings now round-trip. The parameter is renamed to match its property: `SpinnakerSourceSettings(name, region, frameRate, pixelFormat)`. Positional calls are unaffected; code passing the first argument by name must be updated (#1338).
- [Media Blocks SDK .Net] **Fixed: a pipeline document holding a `GenICamSource` or `BaslerSource` block came back without its camera.** `GenICamSourceSettings` declares two constructors and no parameterless one, which the serializer refuses outright, so no document holding the block loaded at all - while its region, frame rate and pixel format were written into the document regardless. `BaslerSourceSettings.Camera` was never written, so the block restored with no camera while saving, validation and loading all reported success. Both now round-trip from the identity the document carries, and a Basler document that carries the sensor size no longer opens the camera to re-read it. The first parameter of both `GenICamSourceSettings` constructors is renamed `deviceName` -> `name` to match its property; positional calls are unaffected. A `SpinnakerSource` or `GenICamSource` document carrying no camera name, or an empty one, is now reported as `MBS043` instead of silently opening the first camera on the machine (#1338).
- [Media Blocks SDK .Net] **Fixed: a video mixer holding an Allied Vision or GenICam camera could not be saved.** The mixer wrote a source only when it could read it back, and that check looked at public constructors alone - so it refused a settings class whose deserialization constructor is private, with an `MBS060`, even though loading a document restores it correctly. Both cameras now save and reload as mixer sources. A mixer source missing a mandatory setting - the region above all - is reported now too, where it used to load as a camera with no region and then fail when the pipeline started (#1338).
- [Core] **Fixed: a capture device whose sample rate range lies outside 22050-96000 Hz disappeared from the device's format list.** A narrow-band device publishing, say, `rate=(int)[ 8000, 16000 ]` matched none of the rates the enumeration samples a range at, so it produced no entries at all. Its own bounds are published instead (#1317).
- [Core] **Fixed: a capture device publishing its sample rate or channel count as a list disappeared from the device's format list entirely.** `AudioCaptureDeviceInfo.Formats` read only the single-value and range forms, so a caps structure written as `rate=(int){ 44100, 48000 }` produced no entries at all rather than one per combination (#1317).
- [Core] **Fixed: audio frames delivered as 24-bit-in-32 or as 20-/18-bit reported the wrong bytes per sample.** `AudioFrame.Info.BPS` carried the number of significant bits rather than the container width, so a consumer of `BufferSinkBlock` or `AudioSampleGrabberBlock` read 3 bytes per sample where the buffer holds 4 (`S24_32*`) - a 25% undercount that garbles the audio - and 2 bytes where 20- and 18-bit formats hold 3. `S24BE` reported 0. Unchanged for 8-, 16-, 32- and 64-bit formats, which is everything the SDK produces by default (#1317).
- [Core] **Fixed: 24-bit-in-32 audio formats were dropped from capture-device format lists and could not be requested.** GStreamer writes these as `S24_32LE`/`S24_32BE`/`U24_32LE`/`U24_32BE` while the `AudioFormatX` enum spells them without the underscore, and the SDK converted between the two by name. A device offering one of them lost it from `AudioCaptureDeviceInfo.Formats`, and asking for it anywhere a format is applied - audio capture, the audio mixer, WAV output, a push source, the iOS/Mac audio renderer - produced a format name no element accepts. Both directions are now translated (#1317).
- [Core] **On macOS and Mac Catalyst the default audio capture format now follows the device's own sample rate.** `AudioCaptureDeviceInfo.GetDefaultFormat()` preferred 44100 Hz and, when a device published no 16-bit stereo combination at all, fell back to whichever entry sorted first alphabetically. Since the capture format is applied to the capture device itself, that could ask CoreAudio to run an input at a rate it does not use - CoreAudio cannot resample an input, so the hardware's nominal rate was changed instead. The rate now comes from the format the device reports as its own; 16-bit stereo is still preferred for the sample format and channel count, which CoreAudio does convert. Devices publishing 16-bit stereo at 44100 or 48000 Hz - the common case - keep the format they had (#1317).
- [Media Blocks SDK .Net] **`IsAvailable()` on the video and audio encoders and decoders no longer reports a codec that cannot actually be created.** It answered from the GStreamer registry alone, and the registry caches a plugin's element list while the elements a plugin registers are decided when it loads — the Media Foundation plugin names its encoders by hardware-MFT enumeration index, and the NVIDIA, Intel and Direct3D plugins register their elements only for the hardware present at scan time. After a driver, GPU or Windows-codec change the registry could still list an element the plugin no longer provides; `IsAvailable()` returned `true` and the pipeline then failed to build with an unrelated-looking error. The check now also loads the element's plugin and asks it again, which refreshes the registry's list for that plugin. The first `IsAvailable()` call for a given backend is correspondingly slower, since it now loads that backend's plugin — around 0.3 s for NVIDIA and 0.7 s for Media Foundation on the measured host, once per plugin per process — and that plugin's vendor libraries are loaded into the process even if the pipeline ends up encoding in software (#1175).
- [Media Blocks SDK .Net] **`MFH264EncoderSettings.GetDeviceIDs()` and `MFHEVCEncoderSettings.GetDeviceIDs()` no longer list a Media Foundation device that cannot be created**, and they identify each device from the loaded MFT rather than from the cached registry metadata, which could name a different encoder. Two consequences on a host where such a stale entry existed: a device that used to appear and then fail is now absent, and `DeviceID` — a position in this list — can shift, so an application that persisted a `DeviceID` should re-resolve it against `GetDeviceIDs()` rather than assume last run's number (#1175).
- [Media Blocks SDK .Net] **Windows: using a Media Foundation encoder no longer permanently breaks every later NVIDIA NVENC encode in the process.** GStreamer eagerly activated NVIDIA's Media Foundation H.264 and HEVC MFTs while registering the plugin, even when the pipeline only requested the Microsoft AAC encoder. If the public NVENC API had already been initialized, the next `nvh264enc`/`nvh265enc` session failed with `NV_ENC_ERR_INVALID_VERSION` (`0xf`) and no later session could recover. The bundled Media Foundation plugin now excludes NVIDIA's video MFTs before `IMFActivate::ActivateObject`. Microsoft, Intel, AMD, software Media Foundation video encoders, all Media Foundation audio codecs, video capture (`mfvideosrc`) and device enumeration remain available. **What changes on an NVIDIA machine:** NVIDIA's Media Foundation *video* encoders are no longer registered by the plugin. `MFH264EncoderSettings` and `MFHEVCEncoderSettings` keep selecting the same encoder and the same `DeviceID` numbering as before — they already excluded NVIDIA entries when enumerating — **with one exception: a host whose only Media Foundation HEVC encoder was NVIDIA's.** There the settings class enumerated nothing and fell back to the bare `mfh265enc` element, which used to be the NVIDIA one; nothing registers that name now, so `HEVCEncoderBlock.IsAvailable(new MFHEVCEncoderSettings())` returns `false` and `HEVCEncoderType.MF_HEVC` is unavailable. Install the Microsoft HEVC Video Extensions, or encode HEVC through `NVENCHEVCEncoderSettings`. H.264 is not affected in the same way: Windows always registers the Microsoft software H.264 MFT. What changes is the plain GStreamer element: `mfh264enc` and `mfh265enc` are now backed by the next non-NVIDIA MFT on the host — Intel or AMD hardware where present, otherwise the Microsoft software H.264 MFT and the HEVC Video Extension — so a hand-written pipeline string naming them gets a different encoder. Use `NVENCH264EncoderSettings`, `NVENCHEVCEncoderSettings` or `NVENCAV1EncoderSettings` for NVIDIA hardware encoding; they are unaffected and are the faster path in any case (#842).
- [Media Blocks SDK .Net] **`MFAACEncoderSettings` is no longer deprecated.** It was marked obsolete because using it broke NVENC later in the same process; that was never the AAC encoder's doing — requesting it loads the Media Foundation plugin, whose video-MFT registration was the real cause, and that is fixed above. Code using it no longer produces a compiler warning. `AVENCAACEncoderSettings` stays the Windows default for `MP4Output`; prefer `MFAACEncoderSettings` for `VideoEditCoreX` render paths, where libav AAC does not round-trip the GstPreset (#842).
- [Media Blocks SDK .Net] **Fixed: `AudioRendererBlock.Mute` could not turn audio back on on iOS and Mac Catalyst.** Setting it to `false` wrote volume 0 again, leaving the renderer silent and reporting itself muted. Muting now preserves the configured volume, and unmuting restores audible output (#1318).
- [Core] **Fixed: HTTPS and RTSPS connections on Mac Catalyst could not initialize TLS.** The GStreamer runtime was searched for in a `lib` subfolder that Mac Catalyst app bundles do not contain, so its OpenSSL TLS backend and certificate database were never loaded. The SDK now finds the bundled runtime and verifies TLS peers as on macOS (#1327).
- [Core] **On macOS and Mac Catalyst an application no longer re-scans the whole GStreamer plugin set on every launch.** The scan is now cached in the application's own Caches directory (`Library/Caches/VisioForge/<bundle-id>/gstreamer/`, inside the sandbox container for a sandboxed app) and paid once - on the first start after installing or updating the application, and after that only for plugins whose files changed. Nothing needs to be deployed or configured; deleting the cache folder costs one more scan (#1299).
- [Core] **On macOS and Mac Catalyst `GST_PLUGIN_PATH` is no longer set in the .NET environment.** It is published to the process environment GStreamer itself reads, which the .NET one on Unix never was - so `Environment.GetEnvironmentVariable("GST_PLUGIN_PATH")` now returns nothing on these platforms, and a child process started by the application no longer inherits the application's own plugin directory. Pass it explicitly to a child that needs it (#1299).

## 2026.8.30

- [Media Blocks SDK .Net] **Fixed: a chroma key saved into a pipeline document lost its source video resolution, and restored as a block that never worked.** `ChromaKeySettingsX.SourceVideoResolution` is the one setting the keying filter cannot do without - it builds its video format from it - and it was read-only, so it was never written into a saved document and every restored chroma key came back with no resolution at all. Materialization reported success, and the failure showed up only when the pipeline was started: the block could not be built, and a block that cannot be built stops the whole pipeline from starting, with nothing in the diagnostics to say why. The property is now settable and round-trips, and `ChromaKeyBlock` refuses settings whose resolution is missing or has a zero extent, so such a document is reported as failing with `MBS040` naming the property instead of restoring a dead block (#1319).
- [Media Blocks SDK .Net] **The OpenCV blocks now work on macOS.** All sixteen blocks in the `VisioForge.Core.MediaBlocks.OpenCV` namespace, `VideoStabilizationBlock` among them, were documented as cross-platform but their GStreamer plugin shipped for Windows only, so on macOS every one of them reported `IsAvailable()` as `false`. Add the new [VisioForge.CrossPlatform.OpenCV.macOS](https://www.nuget.org/packages/VisioForge.CrossPlatform.OpenCV.macOS) redistributable alongside `VisioForge.CrossPlatform.Core.macOS` and they work as they do on Windows. The package is one universal (x64 + ARM64) plugin with OpenCV 4.14.0 linked into it, so there are no separate OpenCV libraries to deploy. Linux, iOS, Mac Catalyst, Android and Windows arm64 still have no OpenCV redistributable and the blocks stay unavailable there (#1283).
- [Media Blocks SDK .Net] **Fixed: on macOS `CVFaceDetectBlock`, `CVFaceBlurBlock` and `CVHandDetectBlock` never found their default Haar cascade files.** The default cascade names were resolved against an `x64` or `x86` subfolder of the application directory and nowhere else - a layout only the Windows redistributables create. Detection silently produced no results, with the cause visible only in the GStreamer log. The cascades are now looked up in the redistributable's own layout on every platform. Setting a cascade property to a full path is unaffected (#1283).
- [Core] **Fixed: reading or writing a GStreamer property whose type is `glong` or `gulong` threw `EntryPointNotFoundException` on Windows.** Those two value types were read and written through four native functions that no shipped GStreamer build has ever exported, so every access to such a property failed on x86, x64 and ARM64 alike. They now go through the standard GLib accessors, and a value too large for the 32-bit Windows `glong` is reported as an overflow rather than stored as a different number (#1160).
- [Demos] **Fixed: restarting the Bridge Demo no longer leaves an MP4 recorder running in the background.** Starting another recording now finalizes and releases the preceding recorder first, whether Start is pressed again directly or after Stop. The output file is no longer held open by an abandoned muxer, and completed recordings retain their MP4 index.
- [Demos] **Fixed: several demos started an operation and moved on without waiting for it.** The Bridge, Bridge Source Switch, Audio Extractor and all three PreEventRecording demos (WPF and both Avalonia heads) destroyed the SDK, or let the process go, while engine teardown was still running - a recording being closed with the window could be left unfinalized, and the Media Blocks Avalonia one disposed its pipeline without stopping it first. Those window-close handlers now cancel the close, finish stopping and disposing, and then close for real; a second close request during teardown no longer slips past. The RTSP MultiViewSync demo's Stop button returned before the three pipelines had stopped, and the Video Edit Main Demo's Join button reported completion immediately; both now wait. The macOS Simple Media Player closed its window without blocking the main thread on player teardown, and the two Avalonia PreEventRecording motion handlers no longer block an SDK callback thread on the UI thread.
- [Media Blocks SDK .Net] **`OSXAudioSourceBlock` has been removed - use `SystemAudioSourceBlock` with `OSXAudioSourceSettings`.** It was a leftover second macOS audio capture block: it built the same `osxaudiosrc`, but ignored the requested audio format and offered no volume or mute control, and nothing in the SDK, the demos or the documentation samples that actually ran ever created it - `OSXAudioSourceSettings.CreateBlock()`, `DeviceEnumerator` and every macOS demo have built a `SystemAudioSourceBlock` for years. Replace `new OSXAudioSourceBlock(settings)` with `new SystemAudioSourceBlock(settings)`; the settings class, the device selection and the captured audio are unchanged. A pipeline JSON document saved with that block in it names a block type the SDK no longer has, so it is reported as unknown at validation and restores without its audio source - rebuild and re-save such a document (#1290).
- [Media Blocks SDK .Net] **Fixed: on macOS and Mac Catalyst the audio format requested through `OSXAudioSourceSettings.Format` was silently ignored.** The capture device negotiated whatever it preferred - typically 32-bit float - so an application asking for 16-bit stereo got something else without any warning. The requested sample format, sample rate and channel count now reach `osxaudiosrc`. `Format` no longer defaults to a hardcoded 16-bit 44100 Hz stereo, because that value is now enforced and no longer a placeholder: leave it null to let the device choose, or take a real one from the enumeration with `AudioCaptureDeviceInfo.GetDefaultFormat()`, which is what `CreateSourceSettings()` already does (#1290).
- [Media Blocks SDK .Net] **The Metal video processing blocks now work on an iOS device.** `MetalVideoCompositorBlock`, `MetalConvertScaleBlock`, `MetalTransformBlock`, `MetalDeinterlaceBlock`, `MetalOverlayBlock` and `MetalVideoFilterBlock` were documented as available on iOS and compiled there, but the Metal plugin behind them was never loaded, so every one of them reported `IsAvailable()` as `false` and could not be built into a pipeline. The plugin is now part of the iOS runtime, and it is the same current build the macOS and Mac Catalyst packages carry - so `MetalVideoCompositorBlock` also composes onto an output of any size, rather than failing negotiation whenever something downstream asked for a size other than the size of its inputs. Two limits remain, both unchanged: the Metal renderer (`MetalVideoRendererSettings`) is macOS only, and the blocks are unavailable in the iOS Simulator, where `IsAvailable()` still returns `false` (#1296).
- [Media Blocks SDK .Net] **Fixed: a pipeline document naming `VideoMixerSource` passed validation and then failed to build, and the mixer's sources were never saved in the first place.** `MediaBlocksPipelineValidator` reported the block as constructible while `MediaBlocksPipelineMaterializer` threw `MBS040: ... The method or operation is not implemented` and discarded the whole pipeline, because `VideoMixerSourceSettings.CreateBlock()` was not implemented. It now builds the block, so a document restores it. The settings also **persist their inputs**: the sources, their rectangles and their chroma keys were held in a private list that was silently left out of every saved document and every `ToDocument()` snapshot, so a two-camera mixer came back as an empty canvas. They are now the public `VideoMixerSourceSettings.Sources` list of `VideoMixerSourceStream`, written and read with the source's own settings class named in the JSON; a source class this build does not contain - several are platform-specific - is reported rather than restored as an empty input. Capturing a live pipeline now also warns (`MBS060`) about any block the document cannot rebuild, instead of reporting the snapshot complete. **API change:** `VideoMixerSourceBlock` now derives from `SuperMediaBlock` rather than `SourceMediaBlock`, which is what lets a block built from `VideoMixerSourceSettings.CreateBlock()` wire itself up when you connect only its output - previously that produced a pipeline that stalled at start with no error. It keeps behaving as a source; the only members it no longer inherits are `Stop()`, which did nothing, and `IsSubtitlesAvailable()`, which it still provides. **Renamed arguments:** `VideoMixerSourceSettings.Add(source, left, top, width, height)` never took a width and a height - the last two arguments went straight into `Rect(left, top, right, bottom)`, so `Add(src, 960, 0, 960, 1080)` produced a zero-width input, not a 960-wide one. The parameters are now named `right` and `bottom`. Behaviour is unchanged, so positional calls keep working; a call that passed the arguments **by name** (`width:` / `height:`) no longer compiles, and it was producing the rectangle the new names describe all along (#1230).
- [Core] **The Windows GStreamer plugin cache is now kept per SDK version, and a rebuilt plugin of the same size is no longer ignored.** On Windows the SDK mirrors an application's `x64` / `x86` native folder into a shared folder under `%PUBLIC%\.gstreamer` and loads from there, so that every VisioForge application on the machine shares one warm GStreamer plugin registry instead of each paying a full cold scan. That folder was shared by every SDK version ever run on the machine and was only ever added to, so a native library a newer release no longer ships stayed on the load path indefinitely - an application could keep working on a machine that had run an older release and fail on a clean one. It is now `%PUBLIC%\.gstreamer\<sdk-version>-<native-set>\<arch>`, keyed to the SDK version together with a stamp of the core and Libav redistributables the application actually deployed, so deployments on different natives no longer overwrite each other's files on every start; a cache the SDK created and nothing has started for 30 days is removed, while a folder left by an older SDK that still uses the previous shared layout is left alone. Whether a cached file is up to date is decided by its size **and** its timestamp, rather than by size alone - a rebuilt library of the same size used to be kept forever. The first start after an SDK upgrade repopulates the cache and rebuilds the registry once. `VisioForgeX.CacheFolder` still overrides the location: point it at the application's own native folder before `InitSDK` to skip the shared cache entirely and load exactly what the application deployed (#1289).
- [Core] **Fixed: an ARM64 Windows application could not find the SDK's native libraries.** The runtime looked for them in an `x64` subfolder whatever the process architecture, while the ARM64 redistributable packages deploy to `arm64`, so initialization failed with "GStreamer libraries not found. Check the deployment and add required NuGet packages." x86, x64 and ARM64 processes now each use their own folder (#1289).
- [Media Blocks SDK .Net] **Fixed: `AOMAV1EncoderSettings` can now create and configure the AOM AV1 encoder on macOS, Mac Catalyst, and Linux.** The settings are applied for both Media Blocks pipelines and Video Capture / Video Edit output; the required AOM runtime is bundled for the Apple packages. Two defaults changed so that rate control actually works: **`MaxQuantizer` now defaults to 63** - at its previous 0 the quantizer was pinned, the encoder ignored `TargetBitrate`, the buffer sizes and the overshoot/undershoot values, and a 720p clip asked for 1500 kbits/sec was written at about 66 Mbits/sec - and **`TargetBitrate` now defaults to 0**, meaning the encoder scales its own default to the frame size (256 kbits/sec at 320x240, about 6900 kbits/sec at 1920x1080) instead of applying 256 kbits/sec at every resolution. Any value the encoder would refuse - `CPUUsed` outside 0-9, `DropFrame`, `OvershootPCT` or `UndershootPCT` above 100, `TileColumns` or `TileRows` above 6, a resize or super-resolution denominator outside 8-16, a super-resolution threshold outside 1-63, a `TargetBitrate` above 2000000 kbits/sec, a quantizer above 63 or a minimum above the maximum - is now **left unapplied and reported as a warning** rather than dropped in silence or failing the whole pipeline inside the encoder; a refused quantizer pair encodes at 0-63 rather than at the element's own 0, which would have disabled rate control. **`Threads` is now always resolved by the SDK**: 0 and any value above the 64 threads the encoder accepts both become this machine's processor count, clamped to 1-64, because the encoder's own automatic count is not clamped and fails to initialize on a host wider than that. `TileColumns` and `TileRows` are log2 counts (0 = one, 1 = two, 2 = four), as the encoder takes them. AOM is intended for quality-focused offline encoding; prefer SVT-AV1 for general software encoding because it is substantially faster. On Windows, iOS and Android the `av1enc` element is still not part of the runtime, so `AOMAV1EncoderSettings.IsAvailable()` stays `false` there (#1286).
- [Core] **The OpenCV redistributable packages are rebuilt on OpenCV 4.14.0 and are much smaller.** `VisioForge.CrossPlatform.OpenCV.Windows.x64` and `.x86` shipped OpenCV 4.7.0 from February 2023 together with 42 OpenCV libraries the GStreamer OpenCV elements never load. They now carry OpenCV 4.14.0 and only the libraries those elements need, so the x86 package drops from 94 MB to 44 MB and the x64 package from 113 MB to 64 MB. Part of what the x86 package shed is a 26 MB 64-bit `opencv_videoio_ffmpeg470_64.dll` that no 32-bit application could ever load. All 23 OpenCV elements are unchanged. **The plugin now requires GStreamer 1.28 or newer** - the version it is built against, and the version the matching `VisioForge.CrossPlatform.Core.Windows.*` packages ship; it previously declared 1.22. An application that puts an older GStreamer ahead of the SDK's own on `PATH` will find the plugin refused, and GStreamer reports that as a single warning, so the OpenCV elements would simply be missing (#1276).
- [Media Blocks SDK .Net] **Fixed: `AV1EncoderBlock` ignored every SVT-AV1 setting, and several of them did nothing on the other engines too.** In Media Blocks the encoder was built and then never configured, so `Preset`, `TargetBitrate`, `MaxBitrate`, `CQP`, `CRF` and `IntraPeriodLength` were all dropped and the encoder ran at its own defaults (preset 10, CRF 35). On every engine, `Threads`, `Tier`, `TileColumns` and `TileRows` were written to element properties `svtav1enc` does not have, which GStreamer answers with a warning and no effect; they now reach the encoder the way SVT-AV1 takes them, and **`TileColumns` and `TileRows` are log2 counts** (0 = one, 1 = two, 2 = four) - up to 4 for columns, up to 6 for rows, and at most 128 tiles between them. Values above that are clamped rather than passed through: SVT-AV1 rejects such a configuration outright ("MaxTiles is 128 and MaxTileCols is 16") and the encoder can take the process down with it. Every other setting the encoder would refuse - a `Preset` outside 0-13, a bitrate outside 1-100000 kbits/sec, a `CQP` or `CRF` outside 1-63, an `IntraPeriodLength` below -2 - is now **left unapplied and reported as a warning** instead of being dropped in silence, and so is any setting a different rate-control mode makes irrelevant. The encoder keeps its own working default in each case rather than being handed a value it cannot use. `CQP` never took effect either, on any engine: the encoder picks its rate-control mode in the order bitrate, CRF, CQP, and CRF has a non-zero default, so a CQP-only configuration encoded in CRF mode - setting `CQP` now disables CRF as it always claimed to. **Behavior change:** an application that set SVT-AV1 properties through Media Blocks and tuned around them being ignored will now get the encoder it asked for. (#835)
- [Media Blocks SDK .Net] **Fixed: the default SVT-AV1 configuration produced a stream with no keyframes after the first.** `IntraPeriodLength` defaulted to `-1`, which this encoder reads as *insert no further intra frames* rather than *automatic* - so a recording was hard to seek, and a client joining an SRT or RIST stream mid-flight never received a keyframe and never rendered. The default is now `-2`, the encoder's own automatic setting; pass `-1` explicitly if a single-keyframe stream is what you want. This affected the VideoCaptureCoreX / VideoEditCoreX render path, where the value was applied; Media Blocks left the encoder at its own `-2` default because it applied nothing at all (#835).
- [Media Blocks SDK .Net] **The SVT-AV1 encoder (`SVTAV1EncoderSettings`) is now available on macOS and Mac Catalyst.** The `svtav1enc` element and its library ship in the additional runtime package - `VisioForge.CrossPlatform.Core.macOS.Adds` and `VisioForge.CrossPlatform.Core.macCatalyst.Adds` - the same way `gstsvtav1.dll` has always shipped in the Windows `.Adds` packages. Reference the `.Adds` package for your platform beside the core one - `VisioForge.CrossPlatform.Core.macOS.Adds` 2026.8.25 or newer, `VisioForge.CrossPlatform.Core.macCatalyst.Adds` 2026.8.26 or newer; without it `AV1EncoderBlock.IsAvailable(new SVTAV1EncoderSettings())` returns `false` and the rav1e encoder (`RAV1EEncoderSettings`) remains the software AV1 option. On iOS no AV1 encoder is available at all (#835).
- [Core] **Fixed: AV1 files did not play on iOS.** No AV1 decoder was registered at all, and GStreamer's FFmpeg wrapper deliberately does not provide one, so playback worked only on the chips whose VideoToolbox decodes AV1 (A17 Pro and later) and produced nothing anywhere else. The `dav1d` software decoder is now registered on iOS, so AV1 plays on every supported device; VideoToolbox is still preferred where the hardware has it. AV1 *encoding* remains unavailable on iOS - Apple ships no AV1 hardware encoder, and the software AV1 encoders are not part of the iOS redistributable, so `SVTAV1EncoderSettings` and `RAV1EEncoderSettings` report unavailable there (#1287).
- [Core] **Fixed: several Apple VideoToolbox encoder settings did nothing on iOS.** `ForceHWUsage` was ignored, `PreserveAlpha` was not offered at all, `AppleMediaHEVCProfile.Main10` warned that it could not negotiate, and `RateControl` / `DataRateLimitBitrate` / `DataRateLimitDuration` were dropped with a warning - all because the SDK still assumed the iOS runtime was the old GStreamer 1.24.9 build. iOS has shipped 1.28.6 for some time, so the HEVC alpha encoder (`vtenc_h265a`), 10-bit HEVC and the CBR/capped-ABR rate control now work there exactly as they do on macOS and Mac Catalyst. `AppleMediaH264EncoderSettings.ForceHWUsage`, `AppleMediaHEVCEncoderSettings.ForceHWUsage` and `AppleMediaHEVCEncoderSettings.PreserveAlpha` are now present in the iOS build; `ForceHWUsage` has no effect there, because every VideoToolbox encoder on iOS is hardware and GStreamer registers no separate hardware-only element (#1287).
- [Core] **Fixed: VP8 and VP9 were unavailable in the iOS Simulator.** The `vpx` plugin was registered only on a physical device, although the simulator framework contains it (#1287).
- [Core] **Fixed: on Mac Catalyst no GStreamer log message ever reached the SDK.** Every GStreamer debug line was routed to a static shim meant for iOS devices instead of to the SDK's own handler, so nothing appeared in the log context or in `Trace`, and the DeckLink "Signal lost" notification - which is raised from that handler - never fired on this platform. `Gst.GstDebug.RemoveLogFunction` also always reported that it had removed nothing, so a host's own log handler installed through `Gst.GstDebug.AddLogFunction` could not be taken down again. Mac Catalyst now behaves exactly as macOS does: log messages are delivered to managed handlers and removing a handler works. Real iOS is unchanged (#1259).
- [Media Blocks SDK .Net] **Fixed: an RTSP RAW or NDI source restored from a pipeline document validated clean, built clean and then refused to start.** `StartAsync` returned `false` with "Media info is not available" or "Unable to get NDISource info.", because a document carries a source's endpoint but never its media information, and those two sources pick their elements from it - the depayloader and parser for RTSP RAW, the converters for NDI on desktop. `MediaBlocksPipeline.StartAsync` now probes such a source once, before it builds the graph, so a restored pipeline starts the way a hand-built one does - as does one whose settings you construct with the public constructor and configure by hand. `VideoCaptureCoreX` and `MediaPlayerCoreX` build their graph through the synchronous `Start`, so an NDI or RTSP RAW source there still needs `NDISourceSettings.CreateAsync` / `RTSPRAWSourceSettings.CreateAsync`, as before. The endpoint has to be reachable at that moment, and a source that cannot be read is reported by name. The synchronous `Start` has nowhere to await a probe and is unchanged - use `RTSPRAWSourceSettings.CreateAsync` / `NDISourceSettings.CreateAsync` there. `NDISourceSettings` gains a `ReadInfoAsync` method for probing an existing instance. **Behavior change:** `MediaBlocksPipeline.Connect` now returns `false` when a block it would have to add is refused - it reported success and left the block out of the pipeline before, so the graph was built without it and nothing said so. That happens when the pipeline is not stopped: use `AddBlockLive` / `ConnectLive` to change a running graph (#1229).

## 2026.8.29

- [Core] **Fixed: Mac Catalyst reported one placeholder audio device and never asked for camera or microphone permission.** `AudioSources`/`AudioSourcesAsync` and `AudioOutputs`/`AudioOutputsAsync` answered every Catalyst caller with a single "Default" entry carrying no CoreAudio identity, the audio device monitors refused to start (so `OnDeviceEnumerationCompleted` never fired for them), and the permission request was skipped outright. All three are lifted: Catalyst now enumerates the real CoreAudio inputs and outputs, its audio monitors run, and camera and microphone access is requested the same way as on macOS. The behaviour was introduced against a deadlock that turned out to belong to a test host launched as a bare executable rather than to Mac Catalyst itself. **Action required for Mac Catalyst apps:** the bundle's `Info.plist` must now declare `NSCameraUsageDescription` and `NSMicrophoneUsageDescription` - the system terminates a process that requests access without them, rather than denying it - and prefer `AudioSourcesAsync`/`AudioOutputsAsync` over the synchronous overloads there, since starting the CoreAudio device provider waits behind the permission prompt (#1242).
- [Media Blocks SDK .Net] **Fixed: a pipeline that was stopped and disposed still held every block it contained, so memory grew with each pipeline an application built.** Each block's input and output pads carry an end-of-stream probe whose callback is pinned for the life of the underlying GStreamer pad, and nothing released it - the pad, the block, its settings and its encoder or renderer element all stayed alive for the rest of the process. Disposing a pipeline now releases the pads of every block it owns, and a block disposed on its own releases its own; restarting a stopped pipeline is unaffected (#827).
- [Core] **New: `Gst.Context` is now part of the SDK, and `Element.GetContexts()` hands back real contexts instead of unusable list wrappers.** The generated type had been left out of the build and, as generated, was unusable - a structure with no fields at all, so every one of its members was commented out because it would have handed GStreamer a one-byte buffer where a context pointer belongs. It now carries the native context handle and its members work: constructing a context from its type, reading the context type, the payload structure (read-only and writable) and the persistent and writable flags, testing the type, taking a writable copy with `MakeWritable()`, and `Ref`/`Unref`. `Gst.Element.SetContext` is new, and the `Gst.Element.Contexts` property is replaced by a `Gst.Element.GetContexts()` method returning `Gst.Context[]` - a breaking change against the previous release, where it was `GLib.List[]`. It is a method because every call takes a reference on every context that is yours to give back: call it once into a local, release each context with its own `Unref()`, and do not touch the array afterwards. That replaces the previously documented release step, `Gst.Global.ContextReplace(ref handle)`. A struct has no finalizer, so release a long-lived context once, on the owning instance, since `Context` copies share the handle; after that release, and on the empty value `Gst.Context.Zero`, its members throw `ObjectDisposedException` and `InvalidOperationException` rather than handing `NULL` to GStreamer, and `IsEmpty` is the empty-state discriminator. In the same spirit, three calls that GStreamer would have answered with a log line and a plausible-looking result now say what is wrong: `WritableStructure()` throws `InvalidOperationException` on a context something else already holds a reference to (only an unshared context is writable, so write before setting it on an element, not after), `Element.SetContext` throws `ArgumentException` on an empty or released context instead of silently doing nothing, and a null context type is refused rather than turned into an empty context or a false type match. The struct also carries an internal released flag next to the handle, so pass `Gst.Context` values to native code by their `handle` field, not by marshaling the struct itself. `Gst.Uri.Zero` and the new `Gst.Context.Zero` are `static readonly` rather than plain static fields: now that both structs carry a handle, assigning to the shared empty value would have poisoned it process-wide, so code that wrote to `Gst.Uri.Zero` no longer compiles. `Gst.Toc` and `Gst.TocEntry` had the same field-less defect and are covered by their own entry below (#1257).
- [Core] **New: `Gst.Toc` and `Gst.TocEntry` are now part of the SDK, so chapters can be read from a file and written into one.** Both generated types had been left out of the build and, as generated, were unusable - structures with no fields at all, so every member handed GStreamer a one-byte buffer where a table-of-contents pointer belongs. They now carry the native handle and their members work: building a table of contents and nesting entries under it, reading and writing entry tags (the chapter title lives there), start/stop times and loops, finding an entry by UID at any depth, and `Ref`/`Unref`/`Copy`. `Toc.GetEntries()` and `TocEntry.GetSubEntries()` return `Gst.TocEntry[]` and replace the `Toc.Entries` / `TocEntry.SubEntries` properties, which handed back raw handles. Everything a table of contents is actually reached through came back with them: `Message.ParseToc` / `Message.NewToc`, `Event.ParseToc` / `Event.NewToc`, `DiscovererInfo.Toc`, `DiscovererStreamInfo.Toc`, and `TocSetterAdapter.GetToc()` / `SetToc()` - so a TOC can be pulled off the pipeline bus or the discoverer and set on a muxer such as `matroskamux` - chapters written into a Matroska file this way read back out of it with their titles and start/stop times, nested under the edition Matroska wraps them in. The table of contents on a `Gst.ITocSetter` is a `GetToc()`/`SetToc()` pair rather than a `Toc` property, because the two halves have opposite ownership: reading takes a reference that is yours to release, writing leaves the reference with you. `Toc.AppendEntry` and `TocEntry.AppendSubEntry` take their argument by `ref`: the call takes the entry's reference over, and passing by reference is what lets the binding mark the caller's value released so a later `Unref()` cannot corrupt GStreamer's reference count. Values that come from a getter GStreamer does not transfer - the entries of a TOC, an entry's parent or sub-entries, a discoverer's TOC - are borrowed: they are readable and editable but refuse `Unref()`, and `IsBorrowed` reports which is which; take `Ref()` or `Copy()` to keep one past its owner. Calls GStreamer would have answered with a log line and a plausible-looking result now say what is wrong: writing tags to or appending an entry to something else already holds a reference to, appending an entry that already belongs to a table of contents, parsing a TOC out of a message or event that is not a TOC one, and null or out-of-range arguments are all refused with an exception. A struct has no finalizer, so release a long-lived value once, on the owning instance; after that release, and on the empty values `Gst.Toc.Zero` / `Gst.TocEntry.Zero`, members throw rather than handing `NULL` to GStreamer, and `IsEmpty` is the empty-state discriminator - it is also how a missed `FindEntry` and a top-level entry's absent parent report themselves. As with `Gst.Context`, pass these values to native code by their `handle` field, not by marshaling the struct itself (#1257).
- [Core] **Fixed: `GES.Global.ListAssets()` could hand out freed assets and leaked a native list on every call.** GES lends out the assets its cache owns and asks the caller to free only the list holding them, but the binding did the opposite - it kept the list and released every asset, spending the reference the cache still relies on. An asset could then be finalized while still registered, so a later request for the same asset returned freed memory. The assets are now left alone and the list is released (#1231).
- [Core] **Fixed: overriding a gio or GES virtual method that returns a list could corrupt memory or crash.** `FileEnumerator.OnNextFilesFinish`, the four `Resolver` lookups, the three `VolumeMonitor` collections, `GES.Container.OnUngroup` and the GES track-element creation callback each built two native lists over the same result and released neither, referencing every element twice and then walking the already-freed list from the finalizer, which crashes the process. Every callback that returns a list now hands the caller exactly one, with the ownership its documented transfer mode calls for, and gives up its own claim on it - so a list an override built and still holds is no longer freed twice (`Resolver.OnLookupRecords`, `OnLookupRecordsFinish`, `TlsDatabase.OnLookupCertificatesIssuedBy`, `OnLookupCertificatesIssuedByFinish`). `Resolver.OnLookupService` and `OnLookupServiceFinish` additionally threw on every call and could not be overridden at all; they now work (#1248, #1247).
- [Media Blocks SDK .Net] **Windows: the bundled GStreamer runtime moves from 1.28.2 to 1.28.6, on x64, x86 and ARM64.** 1.28.3 through 1.28.6 are bug-fix and security-fix releases - nvcodec, RTP/RTCP, `h264parse`/`h265parse` duration handling, a compositor regression and HLS live seekable ranges among them - and Windows now matches the runtime macOS, Mac Catalyst and iOS already ship. The WASAPI capture buffer size restored in 2026.8.1 is unaffected: the patched `wasapi2src`/`wasapi2sink` were rebuilt against 1.28.6 and re-measured, since the upstream defect is still present in this release. **New elements, on x64 and x86:** `objectdetectionoverlay` and `segmentationoverlay` for drawing detection and segmentation results, `onvifmeta2relationmeta`/`relationmeta2onvifmeta` for moving analytics metadata to and from ONVIF, `burn-yoloxinference` for YOLOX inference, `demucs` for audio source separation, `msesrc`, the curl sinks and source (`curlhttpsink`, `curlfilesink`, `curlftpsink`, `curlsmtpsink`, `curlhttpsrc`), and `originalbuffersave`/`originalbufferrestore`. `rsvgdec` and `rsvgoverlay` reach x86, which did not have them; x64 already did. **ARM64 gains no elements** in this release and **loses `dvdreadsrc` and `rsndvdbin`** - upstream no longer builds the DVD plugins for that architecture. No bundled library changes file name on x64 or x86, so an incremental rebuild needs nothing special there.
- [Media Blocks SDK .Net] **Windows ARM64: `VisioForge.CrossPlatform.Core.Windows.Adds.arm64` is an add-on package now, not a second copy of the runtime.** It used to mirror the whole GStreamer install, so installing it next to `VisioForge.CrossPlatform.Core.Windows.arm64` downloaded 55 MB twice and wrote every file into the output folder twice, with no way to tell which copy won. It now carries only the additional plugins and their private dependencies, exactly as the x64 and x86 Adds packages do, and declares a dependency on the ARM64 Core package - referencing the Adds package alone is enough, NuGet brings the Core package with it. Nothing is lost: the two packages together still ship every element ARM64 had before. `rsvgdec` and `rsvgoverlay` also move from the x86 Adds package into the x86 Core package, so the SVG elements come from the same package on all three architectures (#1261).
- [Media Blocks SDK .Net] **Windows ARM64: three x64 DLLs that could never load are no longer shipped in the ARM64 runtime.** `libgcc_s_seh-1.dll`, `libstdc++-6.dll` and `libwinpthread-1.dll` came straight from the upstream ARM64 GStreamer installer, which ships the x64 MinGW runtime under its ARM64 tree; nothing in the ARM64 packages referenced them. Removing them makes the package about 8 MB smaller to download (27 MB on disk) with no element lost (#1261).
- [Media Blocks SDK .Net] **Windows x64 and x86: the unused MinGW C++ runtime is no longer shipped.** The GStreamer build drops `libstdc++-6.dll` and friends into an otherwise MSVC runtime, and on x64 nothing referenced any of them - `libgcc_s_seh-1.dll`, `libstdc++-6.dll` and `libwinpthread-1.dll` are all gone, about 8 MB less to download (27.9 MB on disk). On x86 only `libstdc++-6.dll` goes, about 7.5 MB less (23.9 MB on disk): the rest of that runtime is really used there, by the mp3 decoder. Every plugin still loads on both architectures - verified with `gst-inspect-1.0` against the package files alone, 192 plugins and none blacklisted (#1277).
- [Core] **Fixed: `GLib.List` and `GLib.SList` leaked the string copies they allocate.** Building a list from managed strings with `elementsOwned: false` duplicated every string into glib memory and freed nothing on dispose, leaking each copy for the life of the process. The wrapper now releases the storage it allocated itself on `Dispose()` / `Empty()`, while elements a native list lent it stay untouched - a list mixing borrowed and managed elements frees exactly what it allocated. A borrowed wrapper that released element storage refuses further use: reads and appends throw `ObjectDisposedException` instead of touching freed memory, while an owned list survives `Empty()` as an empty list whose later string appends are released on the next `Empty()`. `Clone()` of a string list frees its copies on the clone instead of the source (#1232).
- [Core] **Fixed: six more list-returning GStreamer properties handed back unreadable elements and leaked.** `VideoDecoder.Frames`, `VideoEncoder.Frames`, `Toc.Entries`, `TocEntry.SubEntries`, `Adapter.GetList` and `Adapter.TakeList` all typed their elements as the list container itself, so every element was a wrapper over a pointer that is not a list node and read as garbage. Where GStreamer transfers ownership of the elements, disposing that array also released each of them as if it were a GObject - which GStreamer silently ignores, leaking a reference per element on every call. Each property now returns its real element type with the ownership GStreamer documents: `Gst.Buffer[]` for the two `Adapter` methods, which release themselves, and raw handles for `VideoDecoder.Frames` / `VideoEncoder.Frames`, whose element type cannot carry a native pointer. Note where GStreamer transfers ownership, the reference is now **yours to release**: each handle from those two with the new `Gst.Video.VideoCodecFrame.Unref(IntPtr)`. The two table-of-contents properties are covered by the `Gst.Toc` entry above. The old `GLib.List[]` signatures are removed. The element contexts carried the same defect and are covered by the `Gst.Element.GetContexts()` entry above (#1240).
- [Core] **Fixed: native text in GStreamer binding structures was decoded with the system ANSI codepage instead of UTF-8.** Names, descriptions, hosts, credentials and addresses read through `ElementFactory.StaticPadTemplates`, `Gst.Video.VideoFormatInfo`, `Gst.Audio.AudioFormatInfo`, `Gst.FormatDefinition`, `Gst.PluginDesc`, `Gst.Rtp.RTPPayloadInfo`, the RTSP (`RTSPUrl`, `RTSPTransport`, `RTSPAuthParam`, `RTSPAuthCredential`, `RTSPAddress`), SDP, WebRTC, gio and Pango structures all came back as mojibake on any Windows codepage that is not UTF-8. They now decode as UTF-8. `ElementFactory.StaticPadTemplates` additionally leaked a string copy on every access to a template's `Get()` or `Caps` and handed GStreamer a re-encoded copy of its own text in place of the original; that leak is gone. Two consequences there, both breaking: `Gst.StaticPadTemplate.NameTemplate` and `Gst.StaticCaps.String` are now read-only properties rather than settable fields (they carry the native pointer, and code that assigned one, took it by `ref`/`out`, or reflected over it as a field will not compile), and comparing two `StaticPadTemplate` or `StaticCaps` values now compares the native text identity rather than the decoded characters (#1240).

## 2026.8.28

- [Core] **Fixed: GStreamer wrapper members silently did nothing after `Dispose()`.** Calling any member of a disposed `Gst.Caps`, `Buffer`, `BufferList`, `TagList`, `Structure`, `Message`, `Event`, `Query`, `Sample`, `Memory`, `MiniObject`, `DateTime`, `Iterator`, `Promise` or `DebugMessage` handed a NULL handle to GStreamer, which logged a silent critical and carried on — or returned a quiet default that looked like real data; the struct-field accessors (`Buffer.Pts`, `Caps`/`Structure` field reads) read through a NULL pointer outright. Those members now throw `ObjectDisposedException` naming the type, so the misuse surfaces at the call site. `Dispose()` stays idempotent, and `Handle`, `Owned`, `Equals` and `GetHashCode` keep working on a disposed wrapper, so release-once code and comparisons are unaffected. Also fixed here, the same defect in three places: `new Gst.Sample(buffer, caps, segment, null)`, `Message.AddRedirectEntry(location)` — which threw on every call — and `Buffer.ReplaceMemory`/`ReplaceAllMemory`/`ReplaceMemoryRange` with a null memory (the way to drop memory blocks without inserting a replacement) all threw `NullReferenceException`, because the optional argument was dereferenced before its own null check (#1241).
- [Core] **Fixed: `Gst.GstDebug.GetAllCategories()` returned unusable data.** Its elements were typed as `GLib.SList` while GStreamer actually hands back debug categories, so reading an element produced garbage values or a crash, and a category's name and description were unreachable. The method now returns `Gst.DebugCategory[]` - a value-copy struct exposing the category name, description, color and current threshold, decoded as UTF-8. Two members that silently did nothing now throw `NotSupportedException` and are marked `[Obsolete]`: `DebugCategory.Free()` (deprecated upstream no-op) and `DebugCategory.ResetThreshold()` (wrote into a temporary copy, never into the live category). `DebugCategory` equality now compares the category's native identity plus the copy's threshold and color, instead of comparing decoded strings. The old `GLib.SList[]` signature is removed (#1233).
- [Core] **Fixed: starting or stopping audio on iOS could hang the app.** The bundled iOS GStreamer held the audio ring-buffer lock across the CoreAudio start/stop calls that wait for the render callback to finish; the render callback takes the same lock. The start path was already fixed upstream for iOS 17+, and the same fix now covers the stop path and the pre-1.28 render-callback teardown (#1131).
- [Core] **The iOS bundled GStreamer runtime moved from 1.24.9 to 1.28.6**, matching macOS and macCatalyst. Brings the 1.26/1.28 plugin set to iOS (the reworked direct-rendering decode path, `io_proc_dropping` audio teardown, the VideoToolbox rate-control properties and the alpha encoder variant) and ends the divergence where iOS alone shipped a runtime without the deadlock fixes above. The Metal compositor plugin (`vfmetalcompositor`) is now part of the iOS framework. The official 1.28.6 iOS package no longer carries `frei0r`, and it replaces `y4mdec`/`y4menc` with the single `y4m` plugin.
- [Media Blocks SDK .Net] **Fixed: stopping a capture session after a source error could crash the process.** A microphone or other live source that failed during the session no longer access-violates on `StopAsync`; a recording that was still producing video is still finalized (#825).
- [Media Player SDK .Net] **Fixed: switching audio on a multi-track file jumped the picture back to the first video track, and switching video silenced the playing audio.** `Audio_Stream_Select` / `Video_Stream_Select` on `MediaPlayerCoreX` and `SimplePlayerCoreX` now keep the streams they are not switching. `SimplePlayerCoreX.Audio_Streams_Current` reports the active audio index instead of a hardcoded `1` (#1216).
- [Core] **`Gst.Uri` members now throw on a released or empty instance instead of failing silently.** Reading a property, converting to a string or mutating a `Gst.Uri` after its `Unref()` — or on the empty value `Gst.Uri.Zero` — used to hand `NULL` to GStreamer, which logged a silent critical or quietly returned an empty result indistinguishable from a real one. These members now throw `ObjectDisposedException` after release and `InvalidOperationException` on the empty handle; managed comparison (`Equals`/`GetHashCode`), a repeated `Unref()` and `ToString()` on the empty value (it renders as an empty string) keep working. The new `IsEmpty` property is the parse-failure discriminator. Struct copies taken before the release still share the handle and stay unreusable after it — release once, on the owning instance. The struct also carries an internal released flag next to the handle, so pass `Gst.Uri` values by their `handle` field to native code, not by marshaling the struct itself (16 bytes on 64-bit) (#1236).
- [Core] **New: `Gst.Uri` is now part of the SDK.** The generated type had been left out of the build and, as generated, was unusable. It now carries the native URI handle and its members work: constructing from parts or parsing a string, reading scheme, host, path, fragment, the query table and the query keys, joining a reference against a base. The handles the constructors return own a reference and a struct has no finalizer, so release a long-lived one with its `Unref()` method - once, on the owning instance, since `Uri` copies share the handle. Also, `GLib.PtrArray.Clone()` on an elements-owned array whose element type is not a GObject now throws `ArgumentException` instead of silently sharing element storage that dies with the source (#1205).
- [Core] **Fixed: `GES.TrackElement.AllControlBindings` returned garbage on every read.** GStreamer hands back a hash table there, not a list, and the binding read the hash table's memory as a list. The property now returns the control-binding property names through `g_hash_table_get_keys` and frees the temporary list it builds; the list marshaller refuses any non-list native return with a clear exception, and a `NULL` return still reads as an empty array (#1205).
- [Core] **Fixed: `Gst.GstDebug.GetAllCategories()` leaked the native category list on every call.** GStreamer hands back a copy of the process-static debug categories that the caller must free, but the `GLib.SList` wrapper discarded its ownership flags, so disposing the wrapper freed neither that list nor - on any other `SList`-based API - the elements it claimed to own. The flags are now honoured: an owned SList frees its container and takes a reference per GObject element, a borrowed one releases nothing; ownership of element storage it cannot release (boxed handles, raw ints, value-type copies) is refused with `ArgumentException`, `Clone()` on both list wrappers now owns and frees its copy instead of leaking it and enumerating through a lost element type - and copies the elements themselves, so a clone survives its source's disposal - and every read of a disposed wrapper throws `ObjectDisposedException` instead of reading freed memory (#1205).

## 2026.8.27

- [Core] **Fixed: device enumeration could hang forever on Mac Catalyst.** `AudioOutputsAsync`, `AudioSourcesAsync` and camera/microphone permission requests relied on CoreAudio/AVFoundation calls that never return in some macabi processes; the permission ask is now bounded — skipped with a warning only where the query is measured to never answer — and audio enumeration falls back to a safe single default device, so Catalyst apps no longer wedge on startup-time enumeration (#1150).
- [Core] **Fixed: macOS startup logged hundreds of GIO module-load failures and a duplicate OpenSSL TLS backend registration.** SSL initialization now loads only the intended GIO TLS module, once, instead of treating every dylib in the app bundle as a GIO module (#1200).
- [Core] **Fixed: reading `Video_Streams`, `Audio_Streams` or `Subtitle_Streams` while a stream switch was in progress could throw `InvalidOperationException`.** The bus thread used to empty and refill those lists in place; a property read that landed in the middle of that update now sees a complete snapshot (#1219).
- [Video Edit SDK .Net] **Fixed: audio settings changed between two renders on one `VideoEditCoreX` were silently ignored by the second render.** `Output_AudioChannels` and `Output_AudioSampleRate` written after a render had finished never reached the rebuilt timeline's audio track, so the next output kept the previous render's channel count and sample rate. The output settings are now applied to the tracks of the pipeline being started (#850).
- [Video Edit SDK .Net] **Fixed: `Input_AddVideoLayer` and `Input_AddTestClip` threw `NullReferenceException` when used after a render had finished.** Both now rebuild the timeline first, as `Input_Clear_List` and the file inputs already did, so a second editing session on one instance works (#850).
- [Video Edit SDK .Net] **Fixed: `Debug_Mode` did not enable the SDK's debug-level diagnostics.** The engine configured a debug logger but left its context in non-debug mode, so debug entries were dropped before reaching the log file (#850).
- [Video Edit SDK .Net] **Fixed: memory grew across renders that use fade transitions.** Each `FadeIn` / `FadeOut` on a clip leaked a GStreamer control source per render, so a long editing session or a batch of renders accumulated them (#850).
- [Core] **`GLib.List` now refuses to build an element-owning list it cannot honour instead of corrupting reference counts.** Passing `elementsOwned: true` while appending wrapped objects used to store their borrowed handles and release them on `Dispose()`, spending references the list never took; it now takes a reference of its own for a GObject element, and throws `ArgumentException` for an element it cannot reference at all - an `Opaque`, an element that does not match the declared element type, or a disposed wrapper (#839).
- [Core] **Fixed: switching audio or video streams leaked a small amount of native memory on every switch.** `Audio_Stream_Select` / `Video_Stream_Select` on `MediaPlayerCoreX` and `SimplePlayerCoreX` built the SELECT\_STREAMS stream-id list without ownership flags, so its disposal freed neither the list nodes nor the copied stream-ID strings; the list is now built owned and freed after the event is sent. A stream with no ID is now rejected with a log entry and `false`, where `SimplePlayerCoreX` used to throw on a null stream and both engines silently sent an event that changed nothing (#1208).
- [Core] **Fixed: `Gst.Event.ParseSelectStreams` leaked the returned list.** The C builds a fresh list of copied stream IDs and hands the ownership over, but the binding wrapped it without ownership flags, so disposing the wrapper freed neither the list nodes nor the strings (#1208).
- [Core] **New: `DeviceEnumerator.OnDeviceEnumerationCompleted`** reports when the first enumeration of a device list has finished, so an application can start a device monitor without waiting for it and show its own "enumerating..." state while the list fills through `OnVideoSourceAdded` / `OnAudioSourceAdded` / `OnAudioSinkAdded`. `DeviceEnumerationCompletedEventArgs` names the list: `VideoSources`, `AudioSources` or `AudioOutputs` (#1108).
- [Core] **Starting a device monitor no longer reads the device list while holding a lock shared by every `DeviceEnumerator` in the process.** The monitor now waits for GStreamer to report that its device providers are up - they start on their own thread from GStreamer 1.28 on - and reads the list afterwards, when that read no longer blocks. On macOS the wait covers the camera or microphone permission dialog, so a dialog left on screen no longer holds up unrelated enumerations for as long as it is up (#1108).
- [Media Blocks SDK .Net] **Fixed: a recording or streaming branch could stop reporting end-of-stream, and a source could hand out a video or audio pad that was already dead.** Across the output blocks (MP4, MKV, AVI, WebM, FLV, WMV, MP3, M4A, FLAC, Ogg, YouTube, Facebook Live), the RTMP/RTSP/NDI/UDP sources, the demuxers, the audio and video effects blocks and the overlay managers, a GStreamer pad was released while the block that owned it was still using it. Nothing failed visibly at the time - the next call on that pad simply did nothing - so the symptoms were downstream: end-of-stream never firing, a recording left unfinalized, or a pad handed to an `OnVideoPadAdded` / `OnAudioPadAdded` subscriber going inert as soon as the handler returned (#850).
- [Media Blocks SDK .Net] **Fixed: `InterPipeSinkBlock.IsAvailable()` and `InterPipeSourceBlock.IsAvailable()` could report that InterPipe was installed when only the unrelated proxy elements were present.** The probes now check the actual `interpipesink` and `interpipesrc` elements, so platform and deployment availability is reported accurately (#1193).
- [Core] **Reading a queue's fill level no longer enumerates the element's whole property list.** `QueueBlock.CurrentLevelBuffers`, `CurrentLevelBytes` and `CurrentLevelTime` are meant to be polled per frame, and each read used to build a managed descriptor for every property the element declares; a poll of all three now allocates about a fifth of what it did. The same applies to any element property probed through `PipelineHelper.ElementHasProperty`, which additionally reports `false` for an element that has already been released instead of answering from the base element type.
- [Media Blocks SDK .Net] **A live pipeline can now be saved as a JSON document.** `MediaBlocksPipeline.ToDocument()` captures the running graph - blocks, their identities and their connections - and `ToJson()` / `SaveJsonAsync(path)` write it out; the capture is safe while the pipeline is playing, which makes it the save-during-Run path. A block that does not expose its settings contributes its position but not its configuration, and says so through a diagnostic rather than producing a document that would rebuild it on defaults - check `MediaBlocksPipelineSnapshotResult.Complete` before treating a capture as a faithful copy.
- [Media Blocks SDK .Net] **A relative file path named by a `*Location` setting now resolves against the document base directory**, which is what the HLS sink calls its segments, its playlist and its init segment.
- [Core] **Fixed: reading or animating a video mixer input that has no sink pad crashed instead of reporting no such input.** A stream added to the mixer settings after the block was built never gets a pad of its own, and reading it back or starting a fade or move on it walked off the end of the pad list. Such a call now returns `null` / does nothing and reports it through the log, on `VideoMixerBlock` and `GLVideoMixerBlock` on every platform and on the D3D11 compositor on Windows; the Metal compositor on macOS and iOS already behaved this way and now logs it too. A fade or move whose input pad is released while it is running also stops cleanly instead of leaving the input part-way through the animation (#1191).
- [Core] **Fixed: constructing a `GLib.PtrArray` threw `EntryPointNotFoundException` on Windows.** The type declared its `g_ptr_array_*` entry points against libgobject and its `g_object_unref` against libglib - exactly backwards - so the first call into the type failed on Windows, while Linux and macOS resolved the symbols through library dependencies by accident. Each import now names the library that actually owns its symbol (#1207).
- [Core] **Fixed: cloning a `GLib.PtrArray` crashed the process, and every clone leaked the native container.** `Clone()` called `g_ptr_array_copy` through a one-argument declaration, while the native function takes three (`array`, copy function, user data) - the missing arguments arrived as garbage and were called as a function pointer. It now declares the real signature and passes NULL for a shallow copy, as the C API allows, the clone owns its copied container so `Dispose()` actually frees it, and cloning a disposed array throws `ObjectDisposedException` instead of crashing later (#1207).
- [Media Blocks SDK .Net] **New: `VideoMixerBlock.RemoveInputPadLive` removes an input that was added with `AddInputPadLive` and hands the mixer's input back to it.** A live-added input used to occupy a mixer input permanently - the only way to reclaim it was to tear the pipeline down. Removal is safe against a running graph: the input is stopped and unlinked first, then the mixer reclaims its pad. Only live-added inputs can be removed; the inputs configured at build stay index-aligned with the mixer's stream settings. Also fixed: the tee helper and the muxer sinks' `ConnectVideo` (MP4, MKV, AVI, MOV, WebM, OGG, FLV, MPEG-TS) kept a requested pad when a connection failed instead of handing it back (#1210).
- [Media Blocks SDK .Net] **Fixed: the video and audio effect blocks could not be restored from a pipeline JSON document.** `VideoBalance`, `VideoResize`, `VideoCrop`, `VideoBox`, the OpenGL effects, the audio effects and thirty-odd of their siblings all failed with "no construction path", because their settings class is named after the effect - `ResizeVideoEffect`, `CropVideoEffect` - rather than ending in `Settings`. The block catalog now also reads a block's own `Settings` property. Across its 387 blocks, and counting the correction below, the number a document can restore went from 314 to 329 and the number a caller holding only a descriptor can create from 216 to 288 - `TextOverlay`, `ImageOverlay`, `VideoMixer`, `HLSSink` and the OpenCV filters among them.
- [Media Blocks SDK .Net] **Fixed: a crop or a video box restored from a document came back cropping nothing.** `CropVideoEffect` and `BoxVideoEffect` kept their four edges behind a private setter, so the margins were dropped in both directions of the serializer and the stage became a passthrough while reporting success. The edges are now settable.
- [Media Blocks SDK .Net] **Three blocks that took their whole configuration as a bare value gained a settings class**: `FlipRotateSettings`, `WAVSinkSettings` and `BarcodeDetectorSettings`. A rotation, a WAV recording destination and a barcode detector mode can now be stored in a pipeline document and edited through the block catalog's property metadata. The existing constructors are unchanged.
- [Media Blocks SDK .Net] **`ResizeVideoEffect`, `CropVideoEffect`, `BoxVideoEffect`, `GLResizeVideoEffect`, `ImageOverlaySettings` and `TextOverlaySettings` gained a public parameterless constructor**, which is what JSON deserialization needs; the crop and the box default to a passthrough and the two resizes to 1920x1080.
- [Media Blocks SDK .Net] **Fixed: seven network sources could not be restored from a pipeline JSON document.** `HTTPMJPEGSource`, `NDISource`, `NDISourceX`, `RTMPSource`, `RTSPRAWSource`, `SRTSource` and `SRTRAWSource` passed preflight validation and then failed halfway through materialization, because the only constructor on their settings class was private - an async `CreateAsync` probes the endpoint before handing one back. Each of those settings classes now has a public parameterless constructor for the persistence path; `CreateAsync` is unchanged and remains the way to probe a reachable endpoint up front. A source built from a document does not contact its endpoint until the pipeline opens it.
- [Media Blocks SDK .Net] **Fixed: a document naming `SRTSource` or `NDISourceX` built the wrong block.** `SRTSourceSettings` is shared by the decoding and the raw SRT source and `NDISourceSettings` by the NDI and the Windows-only NDI X source, while `CreateBlock()` on each names only one of the pair - so the other came up as its sibling, with different pads, and the document's own connections then failed to resolve. A settings class shared by two blocks now reaches its block through the block's own constructor.
- [Media Blocks SDK .Net] **`RTSPRAWSourceSettings.Uri` and `.AudioEnabled` are now settable.** Both were read-only outside `CreateAsync`, so a document's endpoint and audio flag were dropped in both directions of the serializer and the source came up pointing nowhere while reporting success.
- [Media Blocks SDK .Net] **Fixed: nineteen block types built a different block than the one you asked for.** `MediaBlockCatalog.Get(MediaBlockType.MP4Output).CreateBlock()` returned an `MP4SinkBlock` - a bare muxer instead of the whole encode-and-mux stage - and so did a document naming one. `PlayBinSource` came back as a `UniversalSourceBlock`, `SeparateOutput` as a `BridgeVideoSourceBlock`, `UniversalSourceMini` as a `UniversalSourceBlock`, `SRTSink` as an `SRTMPEGTSSinkBlock`. The cause: several blocks share one settings class, whose `CreateBlock()` names only one of them, and the catalog called it for all of them. A shared settings class now reaches its block through the block's own constructor.
- [Media Blocks SDK .Net] **A block whose settings alone cannot build it is now refused up front instead of failing halfway through loading a document.** Twenty-four block types name a settings class but also require a second one the document cannot carry - the `*Output` blocks want encoder settings, `DecklinkVideoAudioSink` a second sink settings, `SeparateOutput` a live pipeline. They reported themselves constructible, passed preflight validation, and then failed during materialization, which discards the whole pipeline over one entry. Preflight now reports `MBS032` naming the block, and `MediaBlockDescriptor.CanConstruct` answers what the loader can actually do.
- [Media Blocks SDK .Net] **Fixed: `RTSPSource`, `RTSPRAWSource` and `RTMPSource` threw `NullReferenceException` instead of reporting an empty URL.** The "URL is empty" check dereferenced the URI it was testing, so a source built without one crashed rather than logging and refusing to build.
- [Media Blocks SDK .Net] **Fixed: `AudioMixer` was configured through the wrong settings class.** The block catalog bound it to `AudioMixerSourceSettings`, which needs a live pipeline and cannot be created at all, instead of `AudioMixerSettings` - so the mixer offered the wrong properties to edit, a pipeline document could not carry its output format, and `IgnoreInactivePads` was unreachable from a document. The catalog now prefers a constructor that can actually be called when a block has several.
- [Demos] **Media Blocks Studio: the Player and picture-in-picture scenarios now carry the effect stages they describe** - colour balance, a mirror and an upscale on the player, a crop and a resize on the picture-in-picture camera branch.

## 2026.8.26

- [Demos] **Media Blocks Studio: nine bundled scenarios that run offline.** The startup screen shows nine curated pipelines - player and live effects, camera capture, screen+camera picture-in-picture, live mixer, transcoding, multi-output streaming, AI vision, audio lab and RTSP - each with a still captured from its own output, an outcome line, media tags and platform/requirement chips. Every scenario is an ordinary JSON document under `Assets/Scenarios` that the app reads at runtime, so the file you open, edit and save is the file the gallery runs. The baseline needs no camera, network or media file: five scenarios generate their own video and audio and three read a bundled clip. "Run Demo" opens the graph and starts it; two scenarios first ask for what the bundle cannot carry - an RTSP endpoint and a path to an ONNX detection model.
- [Demos] **Fixed: the Media Blocks Studio editor came up empty.** Opening a pipeline showed the toolbar over a blank area with no canvas, block catalog, inspector or panels, and the block catalog reported no blocks at all. The application did not include the Dock and Nodify control themes, presented its panels with the wrong data, and never initialized the SDK. Connections between blocks are now drawn as well: a node was previously built with one input and one output regardless of the block, so anything wired to an indexed pad - a mixer input, a source's audio output - was dropped silently.
- [Media Blocks SDK .Net] **Fixed: several blocks could not be restored from a pipeline JSON document.** `RTSPSource`, `VideoMixer` and `Tee` entries failed to materialize, and `Volume` and `Equalizer10` could not carry their gain, mute or band values at all, because those settings types had no constructor the persistence layer could call and, for the two audio blocks, no settings type at all. `VolumeSettings` and `Equalizer10Settings` are new; `RTSPSourceSettings` and `VideoMixerBaseSettings` gained a public parameterless constructor; `TeeBlock` gained constructor defaults. Settings whose only constructor takes all-optional parameters - `VirtualAudioSource` among them - are now accepted too.
- [Media Blocks SDK .Net] **A relative file path in a pipeline document now resolves against the document base directory even when the setting is a URI**, which is the shape `UniversalSourceSettings` uses, so a document can reference an asset shipped beside it.
- [Media Blocks SDK .Net] **Preflight validation now reports an input asset that does not exist** - a detection or OCR model path, or a local file URI - as an error instead of letting the pipeline materialize into a stage that silently does nothing. A sink filename is an output and is still not required to exist.
- [Core] **Fixed: `ElementX.ReadProperties()` returned structure-typed element properties (for example `rtspsrc` `sdes`) whose native memory was already freed**, so reading such an entry afterwards could crash or return garbage. Boxed values are now kept as a deep copy (#1184).
- [Core] **Fixed: `ElementX.ReadProperties()` aborted with an exception on elements holding properties without a managed representation (for example `gltransformation`)** instead of skipping them; unreadable properties are now skipped, and calling the method again refreshes existing entries instead of failing (#1184).
- [Core] **Fixed: `ElementX.ReadProperties()` raised a GLib critical for every write-only element property (for example `playbin` `subtitle-font-desc`)** by trying to read a value such a property cannot have. Those properties are still listed, with a `null` value, and are no longer read (#1184).
- [Demos] **Media Blocks Studio: generated Inspector, Help, runtime controls and crash recovery.** The editor now generates the Inspector form from each block's descriptor property metadata (typed parsing with min/max clamping; live-safe properties apply to the running pipeline without a rebuild) and a Help card from the block descriptor. The workspace gained Run/Pause/Resume/Stop over `MediaBlocksPipelineMaterializer` with error/stop event logging, position polling, structured diagnostics navigation and a single-slot live video preview. Pipelines autosave to %AppData% on a 10 s debounce with a restore prompt on the next start, and unsaved changes are confirmed before New/Open/close.
- [Media Blocks SDK .Net] **Local file sources are now JSON-serializable.** `UniversalSourceSettings` and `DemuxerSourceSettings` had only a private constructor and private setters for their file/URI properties, so a pipeline document carrying a local file could not be loaded or materialized. Both now expose a public constructor and settable URI/Filename/render flags, so file-based pipelines round-trip through the versioned JSON document format.
- [Core] **Fixed: the LUT (color lookup table) video effect silently did nothing on Intel Macs.** The native processor library shipped in the macOS and Mac Catalyst packages was built for Apple Silicon only, so on an x86\_64 Mac it could not be loaded at all and every LUT-based effect was a no-op. The library is now a universal x86\_64+arm64 binary (#1101).
- [Core] **Fixed: calling `VProcessor.UpdateFilterParameters` threw `EntryPointNotFoundException` on macOS/macCatalyst.** The shipped native library predated the managed wrapper and did not export the entry point; it now does (#1157).
- [Core] **The GStreamer log callback no longer claims ownership of logged objects.** The SDK's log handler built a managed wrapper around the subject object of every log line GStreamer emitted, including plugin-internal GObjects the SDK never created; for an object that logs while still floating (any `GstObject` logging before its owner sinks it) the wrapper adopted the floating reference, so the owner's later unref finalized the object while the binding still held a toggle reference on it — surfacing as `[VisioForge-Lifetime] toggle ref outlived its object` and, in Release, as a use-after-free risk whenever debug logging was enabled (#1165). Handlers registered through `Gst.LogFunction` now receive `_object = null` unless a managed wrapper for the logged object already exists.
- [Core] **Fixed: custom GStreamer log handlers could never be detached on desktop platforms.** `Gst.GstDebug.RemoveLogFunction` compared against a freshly built native function pointer instead of the one recorded at registration time and therefore matched nothing; every handler stayed installed for the life of the process. Removal now unregisters by the handle captured when the handler was added — the same scheme already used on Unity. As a consequence, removing without an argument detaches only the handlers this assembly registered rather than every log function in the process, so third-party and default GStreamer logging survives SDK teardown (#1165).
- [Core] **Fixed: native memory grew steadily while reading GStreamer element properties.** Long-running pipelines leaked a small native allocation on every property read: `QueueBlock` level properties (`CurrentLevelBuffers`/`CurrentLevelBytes`/`CurrentLevelTime`, typically polled per frame), video mixer and compositor input reads, OpenGL shader and 360-view settings updates (a whole structure copy per update, so dragging a slider accumulated allocations for the process lifetime), file sink filename reads, and the volume/mute getters of the system and PulseAudio audio sources and of the audio renderer (#1185).
- [Core] **Fixed: `InterPipeSinkBlock.GetNumListeners()` always returned 0**, whatever the number of connected InterPipe sources (#1185).
- [Core] Fixed a slow native memory leak in device enumeration: every probed device property leaked one boxed GValue per enumeration pass (#1174).
- [Core] Fixed: one audio device losing a property-probe race (device removed mid-enumeration) aborted the whole output-enumeration pass, hiding every device enumerated after it; the pass now continues, with the failure contained to that single entry.

## 2026.8.25

- [Demos] **New: Media Blocks Studio, the cross-platform Avalonia showcase and pipeline editor for Media Blocks SDK.** The first stage ships the application shell under `_DEMOS/Media Blocks SDK/Avalonia/Media Blocks Studio` (Windows `net10.0-windows`, macOS `net10.0-macos`, Linux `net10.0`): a dark broadcast-style startup gallery with New/Open/Recent projects, an IDE-style workspace built on Nodify.Avalonia 2.0.0 (infinite node canvas with pan, zoom, selection and connection dragging) and Dock.Avalonia 12.0.0.2 (catalog on the left, Inspector/Help tabs on the right, Preview/Metrics/Diagnostics/Logs docked at the bottom). The searchable block list reads the SDK's read-only block catalog directly; pipelines are created, edited, validated against `MediaBlocksPipelineValidator`, saved to and loaded from the versioned JSON document format with undo/redo.
- [Media Blocks SDK .Net] **New: document-to-live materialization and preflight validation.** A pipeline JSON document can now be turned into a running-ready `MediaBlocksPipeline`: `MediaBlocksPipelineMaterializer.Materialize` builds every block through the block catalog, binds settings from their JSON payloads (including all-optional-parameter constructors), resolves host resources through `IMediaBlockResourceResolver`, restores connections using the documented `input`/`output`/`input:N`/`output:N` pad id convention, and returns a document-block-id to live-block mapping with full diagnostics. Blocks that cannot be created - unknown type, missing factory, unavailable on this platform - stay in the document as placeholders with an error diagnostic; they never discard the rest of the pipeline. `MediaBlocksPipelineValidator.Validate` performs the complete preflight check: structure, known blocks, construction paths, availability probes, pad reference shape, resource resolver presence and unsupported feedback cycles; errors block materialization and run, warnings do not. Relative file paths inside settings resolve against the document directory when one is given (`baseDirectory`). New convenience: `MediaBlocksPipeline.LoadJsonAsync` replaces the contents of a stopped pipeline from JSON in one call.
- [Media Blocks SDK .Net] **Metal-accelerated video elements are now available on Intel Macs.** The `vfmetal*` plugin shipped in the macOS and Mac Catalyst runtime packages was built for Apple Silicon only, so on an Intel Mac it could not be loaded at all and every element it provides - the Metal compositor, video sink, filter, converter/scaler, transform, deinterlacer and overlay - was simply absent from the GStreamer registry. It is now a universal x86\_64+arm64 binary (#1101).
- [Video Capture SDK .Net] **Fixed: video frames could silently stop flowing after live video effects were removed or cleared during capture (`Video_Effects_Remove` by instance or name, and `Video_Effects_Clear`).** The pause issued before the filters are unplugged and the resume after are asynchronous GStreamer state changes, but the resume was not waited out - a PAUSED to PLAYING transition that never completes stops frames with no error raised anywhere. Both operations now wait (bounded) for the resume to settle and report through `OnError` if the pipeline fails to return to the playing state (#1152). Behavior change: removing or clearing effects while capture is paused no longer resumes playback - a deliberate pause is preserved, matching what live effect addition has always done.
- [Media Blocks SDK .Net] **Fixed: stopping an SRT pipeline could hang `StopAsync` forever on macOS when the peer was unreachable or kept dropping the connection, and a test or app that gave up mid-stream could then die with a SIGSEGV at process exit.** The native SRT sink captures the auto-reconnect setting once per write/read call, so turning reconnect off while the streaming thread was already inside its reconnect loop did not end the loop - EOS could never reach the sink and teardown blocked indefinitely. Both SRT sink blocks now receive an early stop signal (`RequestStop`) that disables auto-reconnect before EOS, and the macOS native package's `libgstsrt.dylib` honors a mid-flight reconnect switch-off instead of reopening forever (#879).
- [Media Blocks SDK .Net] **Fixed: the raw `MPEGTSSinkBlock` → `SRTSinkBlock` path published streams that carried bytes but no playable video.** The muxer emitted one buffer per 188-byte TS packet and the SRT sink sent each as its own SRT message - seven times the message rate for the same payload, which starved video on the transport. The muxer output is now aligned to 7 TS packets (1316 bytes) per buffer, matching what the combined SRT MPEG-TS sink has always done. The alignment applies to every raw `MPEGTSSinkBlock` output, including default `.ts` file recordings; the multiplexed stream itself is unchanged and stays spec-legal (#879).
- [Media Blocks SDK .Net] **Fixed: MPEG-1 video produced no video output through `UniversalDemuxDecoderBlock` (and could not decode through `UniversalSourceBlockV2` in the rare no-parser path).** The by-name decoder selectors asked for an element gst-libav never registers - it builds decoder names at runtime and explicitly skips `mpeg1video`, so `avdec_mpeg1video` does not exist and element creation failed silently, dropping the video stream. MPEG-1 is now handed to `avdec_mpeg2video`, which decodes both generations. MPEG audio Layer 1 and Layer 2 hit the same defect family: `UniversalSourceBlockV2` routed them to `avdec_mp2` and `UniversalDecoderBlock`'s Layer 1/2 ladders listed only names gst-libav does not register (`mp1`/`mp2` are in its audio skip list), so that audio silently got no decoder; both now decode through `avdec_mp3`, which handles every MPEG audio layer (#1132).
- [Media Blocks SDK .Net] **Fixed: a live element could be stopped while a buffer was still passing through it, which could freeze the pipeline.** Updating `GLShaderBlock` settings on a running pipeline, and removing an `AudioMixerBlock` input from one, both blocked the surrounding pads and then took the element to the NULL state - but installing a pad block does not wait for a streaming thread already inside it to leave, and stopping an element under that thread deadlocks against it. Both paths now wait for the element to be out of the data flow first, and report a failure instead of stopping it if that wait does not complete (#1143). **Breaking: `GLShaderBlock.Update()` returns `bool` instead of `void`**, so a caller can see when the new shader did not go live - which is what a paused pipeline gives back, since a sink holding a buffer in preroll keeps a streaming thread inside the chain. Push the settings again after resuming.
- [Core] **macOS: audio capture/render devices are selected by their stable CoreAudio unique ID, not by the numeric device ID.** The numeric AudioDeviceID CoreAudio assigns is reassigned on replug, on other devices being added, and across reboots, so a saved configuration could silently open a different device. `AudioCaptureDeviceInfo` and `AudioOutputDeviceInfo` now publish the provider's stable `UniqueID` (plus `IsDefault`), and `OSXAudioSourceSettings` / `OSXAudioSinkSettings` accept it; the pipeline prefers the unique ID and falls back to the recorded numeric ID for configurations saved before this change. A saved unique ID that no longer exists now fails the pipeline start with a diagnostic instead of opening whatever sits at the old numeric ID (#1106).
- [Core] **Fixed: selecting a specific macOS audio input device through `DeviceEnumerator` never worked** - the enumerated `AudioCaptureDeviceInfo.DeviceID` was never populated and stayed 0, so every capture built from a picked device opened the default input instead (#1106).
- [Media Blocks SDK .Net] **New: a public block catalog.** `MediaBlockCatalog` enumerates every built-in Media Block the loaded SDK assemblies carry - over 400 blocks across VisioForge.Core and the AI/OpenGL satellites - with one descriptor per block: stable type, concrete and settings CLR types, human-readable name, visual category, keywords for search, an availability probe (wired to each block's own `IsAvailable()`), factory support, and property metadata generated from the settings type (display name, default value, editor kind, enum values). Blocks whose settings are built by factories rather than edited as POCOs - device sources, demuxers created through async `Create` methods - are classified as runtime-configured instead of pretending to have an editable surface. New types: `MediaBlockCatalog`, `MediaBlockDescriptor`, `MediaBlockPropertyDescriptor`, `MediaBlockAvailabilityResult`, `IMediaBlockResourceResolver`.
- [Media Blocks SDK .Net] **Settings JSON now survives round trips for media value objects.** `VideoFrameRate` is persisted as its num/den pair, `Size` as width/height, and colors (`SKColor`) as RGBA bytes; previously these either could not be deserialized at all or came back zeroed. Read-only computed members of settings objects no longer enter the payload at all - they cannot be read back and silently corrupted document round trips. The DVB source's native tuning handle is excluded from serialization like every other native pointer.
- [Media Blocks SDK .Net] **MAUI: `VideoViewX` gains `SetIPhotography` and `SetCamera2Controls` on Android**, matching the Uno and Avalonia video views. They forward to the native view, so camera photography controls can be configured on the MAUI control itself; outside Android the methods do not exist (#311).
- [Media Blocks SDK .Net] **Fixed: the built-in RTSP server could fail to start with a Media Foundation H264 or HEVC encoder selected.** The pipeline string for the RTSP media factory carried every MF encoder property unconditionally, but GStreamer installs those properties only when the Media Foundation transform advertises them - on a host where the MFT exposes less, `gst_parse_launch` rejected the whole string (`no property "qp" in element "mfh264enc"`) and the server never came up. The launch string now carries the element name and bitrate only, and the remaining settings are applied to the real element after the factory builds the pipeline, skipping any property the MFT does not advertise (#858).
- [Media Blocks SDK .Net] **Breaking: the unused `MPEG2VideoEncoderSettings.Profile` property and the `MPEG2VideoEncoderProfile` enum have been removed.** The FFmpeg MPEG-2 encoder these settings drive (`avenc_mpeg2video`) cannot apply an MPEG-2 profile or level at all - gst-libav deliberately skips the codec's profile/level options when exposing element properties and never maps them from caps either - so the property silently did nothing and every stream was written with the libav defaults (Main profile). Verified against GStreamer 1.28.2; a regression test now pins the stream profile the encoder actually produces (#259).
- [Media Blocks SDK .Net] **Breaking: four more dead `MPEG2VideoEncoderSettings` properties removed - `ForceDuplicatedMatrix`, `IntraQuantBias`, `InterQuantBias` and `MPEGQuant`.** None of them exists as a property on `avenc_mpeg2video`, so every pipeline logged a GLib critical per property and silently ignored the value; no caller could have observed any effect. Also fixed `FrameSkipCompare` being rejected at runtime with a type-mismatch critical - the value is boxed as an integer now, like every other enum setting on this encoder.
- [Core] **Mac Catalyst builds no longer silently lose macOS behaviour behind `#if !__IOS__` guards.** The `__IOS__` define is set for `net10.0-maccatalyst` too, so code guarded only against iOS was compiled out of every Catalyst build with no warning: the video overlay sink never had `force-aspect-ratio` set, opening or playing media could switch audio off while additional audio streams or audio processing blocks were queued, a `file://` URI passed to `Audio_AdditionalStreams_AddAsync` failed where a plain path worked, and the Video FingerPrinting log context stayed unwired so its diagnostics fell back to raw trace output instead of the SDK logger. All twenty-two affected sites now use the guard shape the rest of the SDK already used, which lets Mac Catalyst through wherever macOS is let through (#1141).
- [Core] **Blu-ray and DVB source types are declared on Mac Catalyst, matching the macOS API surface.** Blu-ray playback needs only playbin, tsdemux and h264parse, all of which ship in the macCatalyst GStreamer runtime, so `BluRaySourceSettings` and `BluRaySourceBlock` work there exactly as they do on macOS. `dvbsrc` ships in neither Apple desktop runtime, so the DVB types now exist for API parity alone and their availability check reports false at runtime - the same answer macOS gives (#1141).
- [Core] **`Pango.CoreTextFont` is now declared on Mac Catalyst**, matching the macOS API surface. The file was hidden behind a bare `#if !__IOS__`, which compiles out of Catalyst as well because `__IOS__` is defined for it too (#1142); its DllImport now names the library that actually exports the symbol on the Apple builds (`libpangocairo`, not `libpango`).
- [Media Blocks SDK .Net] **The unused public type `RemoveSilenceSettings` has been removed.** No API in the SDK ever accepted it, so code holding an instance could not pass it anywhere; silence removal is configured through `RemoveSilenceAudioEffect` (for `AudioEffectsBlock` / `MediaPlayerCoreX`) or directly on `RemoveSilenceBlock`, which expose the same `Threshold` and `Squash` properties (#1117).
- [Media Blocks SDK .Net] **New: versioned JSON persistence for pipelines and blocks.** A pipeline can now be saved to and restored from a human-readable `.json` document that carries the pipeline settings, every block with its settings, the connections between blocks, and an optional opaque editor section. The integer `MediaBlockType` value is the authoritative discriminator, so a document restores to exactly the blocks it was written with; unknown properties, unknown sections and blocks this SDK does not know about are preserved without loss, so newer files still load on older SDKs. New public API: `MediaBlocksPipelineDocument`, `MediaBlockDocument`, `MediaBlocksPipelineJsonSerializer`, `MediaBlockJsonSerializer`, `MediaBlocksDiagnostic`, and a schema-migration registry (`IMediaBlocksPipelineDocumentMigration`) for future format versions. Materializing a document into a live pipeline arrives in the next stage.
- [Media Blocks SDK .Net] **Every `MediaBlockType` member now carries an explicit integer value, identical on every platform and build flavor.** The values were previously implicit except for a few anchors, which made them differ between Windows and non-Windows builds around the platform-gated members - any integer-serialized block type crossing a flavor boundary was ambiguous. The numbering follows the existing Windows order, so existing explicit pins (251, 277, 400+) are unchanged. Two members that silently carried duplicate numbers move to fresh unique ones: `UDPRAWMPEGTSSource` from 400 (collided with `ONNXInference`) to 443, and `WebView2Source` from 401 on Windows (collided with `YOLOObjectDetector`) to 444 - the old numbers were ambiguous by construction, so no working code can have relied on them.
- [Media Blocks SDK .Net] **Blocks that shared a `MediaBlockType` value now have their own: `UniversalAutoDemux`, `UniversalSourceMini`, `FallbackSwitchSource`, `ImageOverlayCairo`, `FrameDoubler`, `CustomColorspaceX`, `SqueezebackBlockV2`, `PreEventSeparateOutput`, `TextOverlaySource`, `ImageVideoSourceCairo`, `UniversalTransform`, `UniversalDecoder`, `UniversalDemuxDecoder`, `AppBridgeAudioSink`/`Source`/`VideoSink`/`VideoSource`, `StreamSourceWithDecoder` and `LiveSourceSwitchDynamic` (424-442).** The primary class of each pair keeps the historical value; the variants listed here are new members appended at the end, so nothing is renumbered. Affected classes: `UniversalAutoDemuxerBlock`, `UniversalSourceBlockMini`, `FallbackSwitchSourceBlock`, `ImageOverlayCairoBlock`, `FrameDoublerBlock`, `CustomColorspaceXBlock`, `SqueezebackBlockV2`, `PreEventSeparateOutputBlock`, `TextOverlaySourceBlock`, `ImageVideoSourceCairoBlock`, the `AppBridge*Block` quartet, `StreamSourceBlockWithDecoder`, `LiveSourceSwitchBlockDynamic`, and `IOSVideoSourceBlock`, which now correctly reports the existing `IOSVideoSource` instead of `SystemVideoSource`. Code that switched on these types may need the new members added to its cases.
- [Media Blocks SDK .Net] **Breaking: the unfinished YAML persistence API is removed.** `YAMLBlock`, the commented-out `YAMLConfig`, `IMediaBlock.ToYAMLBlock()` and `MediaBlock.ToYAMLBlock()` are gone; none of them ever produced output (`ToYAMLBlock` threw `NotImplementedException`). JSON is the only supported Media Blocks persistence format.
- [Media Blocks SDK .Net] **macOS and Mac Catalyst: the Metal video renderer no longer hangs a process that has no window, and the Metal elements are no longer picked automatically.** Two defects in the bundled `vfmetal` plugin, both of which a customer could reach without ever naming a Metal element. `vfmetalvideosink` created its own window through a blocking call onto the main thread; in a process whose main thread is not running a Cocoa event loop - a console tool, a service, a test host - that call never returned and the pipeline sat in preroll forever, with nothing on the bus to say why. Worse, the same call could deadlock an ordinary windowed application: an app that starts a pipeline and then waits for it on its UI thread was blocking the very thread the sink needed. The sink no longer waits at all - it asks for the window and drops frames until it appears, which lets the pipeline preroll and frees the UI thread to create it. The first frame is kept rather than discarded, so a pipeline that is only paused - a preview, a scrub, a thumbnail - still shows its picture the moment the window appears. If fifteen seconds pass with no window the pipeline reports an error saying whether a window handle was missing or simply never acted on, and a pipeline that finishes without ever displaying anything says so on the bus when it stops. `vfmetalcompositor` and `vfmetalvideosink` also registered at ranks high enough to be auto-selected, so the Metal compositor silently became the mixer inside every `VideoEditCoreX` timeline and the Metal sink was what `autovideosink` chose; both now register at rank none, like the other five Metal elements, and are used only when you ask for them by name. Separately, `MetalVideoCompositorBlock` failed negotiation whenever anything downstream asked for an output size other than the size of its inputs; it now accepts the requested size and composes onto a canvas of that size, as the software compositor does - each input still sits where its pad properties put it rather than being stretched to fill. The plugin is also rebuilt against the 1.28.6 runtime the rest of the package ships (#878).
- [Media Blocks SDK .Net] **macOS: three further fixes in the Metal video renderer, found while fixing the above.** Resizing the video window could briefly show the picture offset or stretched: the frame's position was computed against the new window size while the picture itself was still being drawn at the old one. A second defect could crash the process during teardown - the thread delivering frames read the render view at the moment the window was being closed, and could be left holding memory that had just been released. And `IVideoView`-style re-parenting now works: handing the renderer a second, different window used to be ignored silently, so it kept drawing into the first one; it now detaches and attaches to the new one (#878).
- [Media Blocks SDK .Net] **GStreamer pipelines and reported codecs are built identically on every system locale.** Six places wrote or compared locale-sensitive text where GStreamer only ever accepts invariant text. The Apple H.264 encoder writes its `quality` parameter into the pipeline string - fractional **0.5 by default**, so with no property ever set - and on every comma-decimal locale (German, Russian, French and most of continental Europe) it produced `quality=0,5`, which the parser rejects: an RTSP server built on those settings handed every connecting client an error instead of a stream. The MP3 encoder had the same defect in its VBR quality parameter, reachable by selecting the Quality rate control with a fractional quality such as 2.5; the NVIDIA H.264 and HEVC encoders in their `const-quality` parameter, reachable with any fractional quality value; and the VP8/VP9 encoders in their three buffer-size parameters - the element takes whole milliseconds there, so on those locales the comma form broke every duration, and a sub-millisecond duration is now truncated to the whole millisecond instead of being written as an unparsable fraction. And under the Turkish and Azerbaijani casing rules a codec name reported by stream discovery came back as `VİDEO/H264` instead of `H264` - silently, with no error anywhere. gst-launch strings and codec identifiers are invariant by construction and are now written as such, on every platform (#1133).
- [Media Blocks SDK .Net] **macOS and Mac Catalyst: a new AAC encoder, `AppleAACEncoderSettings`, backed by the AudioToolbox encoder built into the operating system.** It is the same encoder the rest of macOS produces AAC with, it handles up to **8 channels** where the existing AAC backends stop at six, and it offers four rate control modes including true VBR - set `RateControl` to `Variable` and drive the rate with `VBRQuality` instead of `Bitrate`, which the two variable modes ignore. It appears in every output's `GetAudioEncoders()` list as "Apple AAC". **It is not the default**, and that was a measurement rather than a preference: against a lossless source on Apple Silicon the two encoders trade places with the bitrate - behind `avenc_aac` at 96 kbps, level at 128 kbps, ahead at 192 kbps - while their CPU cost is indistinguishable, since AAC encoding runs well over a hundred times faster than realtime either way. `AVENCAACEncoderSettings` therefore stays the default and nothing changes unless you select the new one. Not available on iOS: the GStreamer runtime shipped for iOS does not carry the element yet, so check `AppleAACEncoderSettings.IsAvailable()` rather than the platform (#1110).
- [Media Blocks SDK .Net] **DV and DVCPRO files no longer fail to open at random with "Cannot access memory for read and write operation".** Roughly one attempt in twenty - measured 1 in 30 on macOS - the file never reached PLAYING and the pipeline reported that error from `avdec_dvvideo`. The libav decoder in GStreamer 1.28 can decode straight into the video renderer's own buffer pool, but it describes the frame with its own, more strongly aligned layout - for 720x480 DV that puts the second colour plane 768 bytes past what the renderer allocated - and reading the frame back then fails. **This is not macOS-specific and the change is not platform-gated:** the defect is in the runtime both platforms now ship (1.28.6 on macOS, 1.28.2 on Windows); macOS is simply where it was measured. The libav video decoders that take that path now decode into their own memory and copy the finished frame out. That is every libav decoder except H.264, H.265 and H.266, so **expect one extra frame copy per frame wherever an `avdec_` decoder handles DV, DVCPRO, MPEG-1/2, MPEG-4, DivX/Xvid, WMV, MS-MPEG4 or ProRes** - formats that are software-decoded anyway. Hardware decoders and every non-libav element are unchanged. The fix reaches both the blocks that pick a decoder by name - `UniversalSourceBlockV2`, `UniversalDecoderBlock`, `UniversalDemuxDecoderBlock` - and the decoders `decodebin`, `uridecodebin`, `playbin` and GES build for themselves inside `MediaBlocksPipeline`, `VideoEditCoreX` and `SimplePlayerCoreX`. A pipeline you assemble yourself out of raw GStreamer elements is not covered, and neither is the internal media-info discovery graph, which cannot hit this (#1121).
- [Media Blocks SDK .Net] **New: `AppleMediaHEVCEncoderSettings` - HEVC encoding through Apple VideoToolbox, including 10-bit and an alpha channel.** There was no VideoToolbox HEVC encoder in the SDK at all, so on a Mac `HEVCEncoderBlock.GetDefaultSettings()` found no hardware encoder and HEVC output was unavailable. It now returns this one. `Profile` selects Main or Main 10 (10-bit), and `PreserveAlpha` switches to the alpha-capable encoder; both need the GStreamer 1.28.6 runtime, which ships in the macOS and Mac Catalyst packages - the iOS package still bundles 1.24.9, where neither is available.
- [Media Blocks SDK .Net] **New: constant-bitrate rate control on the VideoToolbox encoders.** `AppleMediaH264EncoderSettings` and `AppleMediaHEVCEncoderSettings` gain `RateControl` (`ABR`, the default, or `CBR`) plus `DataRateLimitBitrate` / `DataRateLimitDuration`, a bitrate ceiling averaged over a sliding window - what a fixed-bandwidth endpoint needs on top of a target bitrate. The two are alternatives, not complements: with `CBR` selected VideoToolbox ignores the data rate limits outright, because constant bitrate is already a ceiling; the limits apply in `ABR` mode. Two caveats worth planning around: truly constant bitrate requires macOS 13+ or iOS 16+ on Apple Silicon - elsewhere VideoToolbox emulates it through limits of its own and says so in its log, and the output is near-constant rather than constant; and on iOS the properties do not exist in the bundled runtime at all, so the setting is discarded with a warning (#1109).
- [Media Blocks SDK .Net] **macOS and Mac Catalyst: the bundled GStreamer runtime moves from 1.24.12 to 1.28.6, and the audio output no longer hangs on shutdown.** Stopping a pipeline whose audio went to the system output could wedge the process: pausing tore the CoreAudio render callback down from inside the audio device's own IO thread, and that inverted two locks against each other. Measured on this machine before the upgrade, one run in five of the audio processing suite hung and had to be killed after 15 minutes; after it, none. Three things come with the new runtime that are worth knowing about. **VideoToolbox gains hardware decoding of VP9 and AV1 and 10-bit HEVC encoding**, and the H.264/HEVC encoders gain real rate control (constant-bitrate, and a hard data-rate cap) - availability depends on the Mac, so ask the SDK rather than assuming. **Vulkan-based elements work on Apple Silicon for the first time**: the library we shipped was built for Intel only, so on an M-series Mac none of them loaded at all. And the **iSAC speech codec is gone** - GStreamer dropped it upstream, and there is no replacement in the runtime; pipelines that asked for it by name will report a missing element. Everything else the SDK creates was checked element by element against the old runtime and is unchanged. **Delete `bin` and `obj` once after taking this update.** Several bundled libraries change file name in this release - OpenSSL, libsoup and the FFmpeg libraries all move to a new major version - and an incremental rebuild leaves the previous ones in the output directory beside the new ones.
- [Media Blocks SDK .Net] [Video Edit SDK .Net] **DV output now pins the video format to PAL SD (720x576, 25 fps) instead of failing negotiation on any non-SD source.** The DV encoding profile carried no restriction caps, so the encoder was handed the source's native resolution and framerate and negotiation failed. Note that DV encoding is currently blocked by an upstream gst-libav defect (#1126); this fix makes the profile correct for when it is unblocked.
- [Media Blocks SDK .Net] **macOS and Mac Catalyst: the bundled CoreAudio plugin carries one fix on top of upstream 1.28.6.** Stopping a CoreAudio device holds a lock that the device's own audio callback needs, and the thread doing the stopping sits inside CoreAudio holding it for milliseconds - measured on an Apple Silicon Mac at a median of 1.6 ms and as long as 240 ms. Upstream removed that inversion where the device is *started* and never where it is stopped. In practice 1.28.6 is very hard to hang this way, because the callback now stands down before it touches that lock whenever the pipeline is paused first - which every shutdown does; the case it leaves open is an audio capture source renegotiating its format, which stops the device with no pause in front of it. The bundled `libgstosxaudio.dylib` is therefore built from upstream 1.28.6 sources with the stop side removed too. Everything else in the runtime is unchanged upstream bytes.
- [Media Blocks SDK .Net] **macOS and Mac Catalyst: barcode detection through `BarcodeDetectorBlock` (the GStreamer `zbar` element) no longer crashes the whole process on the first frame.** The bundled `libzbar` was built by a compiler that exploits undefined behaviour in zbar's backward image scan: the scan's row-step arithmetic wraps to an invalid pointer value, and the compiled code materializes that wrapped pointer literally instead of decrementing the pointer, so scanning any image wider than two pixels dereferences address 0xffffffffffffffff and dies with SIGSEGV - deterministically, in every host process, on both Apple Silicon and Intel. The two instructions are corrected in place; QR detection verified working after the fix (#1168).
- [Media Blocks SDK .Net] **A branch of a running pipeline could stop delivering data for good after a dynamic add or remove.** Blocking a pad that was already blocked installed a second block the SDK had no handle on - it remembered only the first - so unblocking the pad left the second one in place for the life of the process, and the branch went silent or froze with nothing in the log. Reachable wherever two block scopes could overlap on one pad: the live audio and video mixers, `LiveVideoCompositorV2`, and element removal or replacement in a running pipeline. The same bookkeeping was a shared static table with no locking, and it never released the pads of removed inputs - one pad object pinned in memory per removed mixer or compositor input, permanently. It is gone: each block now carries its own handle. `MediaBlockPad.BlockPadLive()` changes with it in two visible ways: blocking an already-blocked pad is now a no-op that reports success rather than a second block nobody can lift, and a block that could not be installed reports `false` instead of reporting success (#1115).
- [Media Blocks SDK .Net] **Updating an OpenGL shader's settings on a running pipeline no longer leaves the block half-connected.** `GLShaderBlock.Update()` swaps the `glshader` element for a freshly configured one, and the block kept holding the pads of the element that was removed - every later connection, pad block or end-of-stream notification through that block then went to an element nothing feeds. The block now re-reads both pads after the swap. The element replacement underneath it was also reporting success over a pipeline it had cut in half: a replacement element that has only one of the two pads the position needs threw or silently linked against nothing, and a link the SDK could not make was logged and then reported as a completed replacement. Both are refused now, with the old element left running (#1136).
- [Core] **Media analysis no longer fails on a rotated video when the system locale writes its negative sign with a non-ASCII character.** ffprobe reports a portrait phone recording as `rotate=-90`, and the rotation was read through the machine's current locale. On the 57 cultures whose negative sign is not a plain hyphen - every Arabic locale, which prefixes it with U+061C, and the Persian ones, which use U+200E U+2212 - that parse threw and the file could not be analysed at all. ffprobe output is invariant by construction and is now parsed as such, along with the container bitrate and every duration (#1104).
- [Core] **ONVIF: authenticated requests carry a valid timestamp on any system locale.** The `Created` value of the WS-Security UsernameToken was rendered through the machine's calendar, so a Thai machine sent the year 2569, a Persian one 1405 and a Saudi one 1447 and the camera rejected the request. In the legacy ONVIF client the same string is also what the password digest is computed over, so both were wrong. `xs:duration` values had the matching defect in both directions: written with a comma on any comma-decimal locale, and read back either failing outright (Russian, French) or silently taken as five seconds instead of half a second (German) (#1104).
- [Core] **ONVIF: a device's log timestamps are read in the right era.** The log reader picked out date fields using the machine's locale, so under the Umm al-Qura calendar (`ar-SA`) a plain ISO timestamp was not recognised at all, and under the Persian and Thai Buddhist calendars it was read into the wrong era - 2026-05-12 became 2647 or 1483. The invariant form is now tried first, with the machine's locale kept only as a fallback for a device that formats its log the same way (#1104).

## 2026.8.24

- [Core] **macOS: enumerating video sources no longer logs a warning for capture devices that are not AVFoundation cameras.** `VideoCaptureDeviceInfo` read the AVFoundation-only `device-index` property from every device it was given, and any other device class - a Decklink card, an ATEM surfaced through the Decklink provider - has no such property, so building its entry failed part-way and logged a warning. The property is now read only for AVFoundation devices (#1091).
- [Core] **Breaking: `Gst.Rtsp.RTSPConnection.Receive`, `ReceiveUsec`, `ConnectWithResponse` and `ConnectWithResponseUsec` take their message by `ref`, and now actually hand it back.** All four marshalled the message into a temporary block, let GStreamer write the parsed message into that block, and then threw the block away - so every successful receive returned `Ok` with the caller's message unchanged - a fresh one still `RTSPMsgType.Invalid`, carrying no headers and no body, and everything C had allocated into it leaked. Worse on the failure path: GStreamer releases the message's contents before returning an error, so the caller was left holding freed pointers and a later `Unset()` released them a second time. The message is read back on every path now, so a read that reached the socket and then failed leaves it empty rather than dangling. A call rejected by GStreamer's own argument checks - a closed connection, which answers `Einval` - still returns the message untouched and owned by the caller (#1096).
- [Media Blocks SDK .Net] **Stopping or disposing a pipeline no longer waits without a time limit for it to reach the NULL state.** A pipeline that reported the change as asynchronous and then never completed it left `StopAsync()` and `Dispose()` blocked for good. The wait is bounded now, matching the rest of the stop path: it logs a warning and the teardown carries on (#849).
- [Media Blocks SDK .Net] **`AudioMixerBlock.CreateNewInputLive()` returns `null` when the input could not be added,** instead of a pad that was never wired to anything. Check the result before linking: the previous pad produced a GLib critical out of `gst_pad_link` and a link result that looked like an ordinary refusal.
- [Media Blocks SDK .Net] **`RemoveSilenceBlock` and the `RemoveSilence` audio effect now actually remove silence.** The underlying element's `remove` property defaults to off and was never set, so the filter detected silence and then passed every buffer through unchanged - the block was a no-op whatever it was configured with. It is enabled now. **Check your `Threshold` before upgrading:** it is a linear amplitude, and the documentation used to have its direction backwards - it claimed 1.0 meant "no silence detection", where 1.0 is in fact full scale and classifies every sample as silence. That was harmless while nothing was ever dropped; now a threshold near 1.0 removes the whole stream. Two defaults move with it, both onto the element's own: `Threshold` from 0.05 (-26 dB, which would have cut ordinary quiet speech) to 0.001 (-60 dB), and `Squash` from `true` to `false`. Neither default breaks existing code - nothing was ever dropped, so neither had any effect to change; they are what the block does now that it works. One thing does: `Threshold` is validated against its documented 0.0-1.0 range now, the way the compressor's already was, so a value outside it throws `ArgumentOutOfRangeException` where it used to be accepted and ignored. With the block actually removing audio, an out-of-range threshold empties the track instead. `Squash = true` pulls every buffer after a removed passage back by its duration, so the audio track ends up shorter than the video of the same recording - set it yourself when you want the gapless, shortened output and nothing has to stay in sync with it. The `Squash` documentation was describing the missing `remove` property rather than what `Squash` does: silence is always dropped, and `Squash` decides whether the surviving buffers are pulled back to close the gap or keep their original timestamps (the default).
- [Media Blocks SDK .Net] **`RemoveSilenceBlock.Threshold` and `RemoveSilenceAudioEffect.Threshold` now reach the silence detector.** The linear value was passed straight to an element property that is measured in decibels, and the conversion GLib applied silently turned the default 0.05 into 0 dB - full scale, where practically every sample counts as silence. The linear value is converted properly now; the public API is unchanged.
- [Core] **`Gst.Sdp.SDPMessage`'s property setters now actually set what they say.** All seven wrote directly into the native struct at a computed field offset instead of calling GStreamer's own setter. For `Version`, `SessionName`, `Information` and `Uri` that stored a fresh copy over the old string without releasing it, leaking on every assignment. For `Origin`, `Connection` and `Key` it was worse: those fields are C structs embedded **by value** - `GstSDPOrigin` is six strings in a row - and the setter wrote a *pointer* to a temporary block into the first eight bytes of one, so `msg.Origin = o;` corrupted the username field, left the other five untouched, and leaked the block, while `msg.Connection = c;` never wrote `Ttl` or `AddrNumber` at all. All seven now go through `gst_sdp_message_set_*`, which replaces every field properly (#1086).
- [Core] **Breaking: several `Gst.Sdp` members change shape, and the GStreamer binding's `Free()`, `Unset()` and `Clear()` methods no longer corrupt the heap.** `SDPMedia.Media`/`Proto`/`Information`/`Key` and `SDPTime.Start`/`Stop` become read-only properties; `SDPMessage.AddMedia`, `InsertTime` and `ReplaceTime` take their value by `ref` because C moves it into the message and the caller must not release it again; and the setters on `SDPMedia.Fmts`/`Connections`/`Bandwidths`/`Attributes` and `SDPTime.Repeat` are removed - they stored a plain pointer array in a field C keeps a `GArray*` in, so any call to one guaranteed a crash on the next release (use `AddFormat`, `AddConnection`, `AddBandwidth`, `AddAttribute` and `SDPTime.Set`). Those methods marshalled a copy of the value into a temporary native block and released *that*, which went wrong three ways at once: the marshaller allocates every `string` field with `CoTaskMemAlloc` and C frees it with `g_free`, the block itself was allocated with `AllocHGlobal` and freed with `g_free`, and the wrapper then freed the same pointer a second time - so `Gst.Rtsp.RTSPTransport.Free()`, `Gst.Rtsp.RTSPRange.Free()`, `Gst.Rtsp.Global.RtspRangeFree()`, `Gst.Sdp.SDPMedia.Free()`/`Uninit()` and the `Gst.Sdp.SDPAttribute`/`SDPBandwidth`/`SDPConnection`/`SDPTime`/`SDPZone` `Clear()` methods aborted the process instead of releasing anything. Values whose fields the binding copies - `RTSPTransport`, `RTSPTimeRange`, `SDPAttribute`, `SDPBandwidth`, `SDPConnection`, `SDPZone` - own no native memory at all, their factory already released it, so releasing one now clears the value and makes no native call. `SDPMedia` and `SDPTime` are the exceptions: they wrap live native memory, so their string fields become raw pointers behind **read-only properties** (`SDPMedia.Media`/`Proto`/`Information`/`Key`, `SDPTime.Start`/`Stop`), which is what makes `SetMedia`, `SetProto`, `SetInformation`, `SetKey`, `SDPTime.Set`, `Uninit()`, `Free()` and `SDPTime.Clear()` work; write through those methods rather than the properties, and only on a value you own - on one borrowed from `SDPMessage.GetMedia` the setter frees a string the message still points at. One thing to know about that: those properties now read native memory on every access, so a value obtained from `SDPMessage.GetMedia`/`GetTime` must not be read after the message is disposed - copy what you need out while it is alive. `Equals` and `GetHashCode` on those two structs consequently compare by pointer rather than by string content, the way they already did for the array fields - two medias with the same text are no longer equal, and a value's hash changes after a `SetMedia`. And the release methods on those two now really do release: call `Free()`/`Uninit()`/`Clear()` **only on a value you created** (`New`, `Init`, `Copy`, `SetMediaFromCaps`, `SDPTime.Set`), never on one borrowed from `SDPMessage.GetMedia`/`GetTime` - that one is a window onto memory the message owns, and releasing it leaves the message dangling until its own teardown trips over it. A borrowed value is also only valid until the message is next modified: `RemoveMedia`, `ReplaceTime` and their siblings release the element they drop, so read what you need out of a `GetMedia`/`GetTime` result before changing the message, not after. The same allocator mismatch is gone from the `Insert`/`Replace` overloads that take an `SDPAttribute`, `SDPBandwidth`, `SDPConnection` or `SDPZone`: C copies the struct into the message or media by shallow `memcpy` and frees its strings with `g_free`, and the binding was handing it CLR-allocated ones - no signature changed, the strings are now GLib-allocated at the boundary. `SDPMessage.AddMedia` takes `ref` because C moves the media into the message and empties the source. The matching leaks are gone with them: `Gst.Rtsp.Global.RtspMessageNew`/`NewData`/`NewRequest`/`NewResponse` leaked an 88-byte message plus its header array on every call, and `SDPMedia.New`/`Init`/`Copy`/`SetMediaFromCaps` leaked a media plus four arrays, because the only documented release path was one of the broken methods (#1086).
- [Core] **Breaking: `Gst.Sdp.SDPMedia.Fmts`, `Connections`, `Bandwidths`, `Attributes` and `Gst.Sdp.SDPTime.Repeat` return typed arrays and finally read what they describe.** All five threw `ArgumentException` on any value that held something: they walked their field as a NULL-terminated array of pointers, and the helper doing the walking called `Marshal.PtrToStructure` in a form that refuses a value type - which is the only reason it did not hang instead, because its loop compared the walking address against zero while incrementing that same address and so had no exit at all. In C these fields are `GArray *`, not pointer arrays, so repairing the walk would still have taken the array's length field for an element pointer. `Fmts` and `Repeat` are `string[]` now, `Connections` is `SDPConnection[]`, `Bandwidths` is `SDPBandwidth[]` and `Attributes` is `SDPAttribute[]`, read through GStreamer's own indexed accessors - all but `Repeat`, for which C exports none, so that one reads the array directly; they were `IntPtr[]`. Reading one on an empty or already-released value returns an empty array rather than crashing. Unlike `Media`, `Proto`, `Information`, `Key`, `Start` and `Stop`, which read native memory on every access, the values these five hand back are copies taken at read time and stay valid after the media or time is released (#1087).
- [Media Blocks SDK .Net] **One stalled pipeline no longer freezes bus message delivery for every other pipeline in the process.** Latency recalculation ran directly on the GLib main loop, which is shared process-wide and dispatches one source at a time. A pipeline whose latency query could not complete - a stalled mixer, a wedged source - therefore held that loop and stopped the EOS, error and state-change messages of all other pipelines, including the ones their `StopAsync`/`Dispose` were waiting on, so unrelated pipelines appeared to hang (#1065). The recalculation now runs off the bus loop, with bursts of latency notifications coalesced so a graph is never recalculated twice at once.
- [Core] **Breaking: `Gst.Object.Replace` and `Gst.Rtsp.Global.RtspAuthCredentialsFree` change signature, and the GStreamer binding's `T **` out-parameters now return real data instead of uninitialised heap.** Eighteen P/Invoke declarations passed a C out-parameter by value, so native wrote its eight-byte pointer into the front of a caller-allocated struct-sized block and everything past that was read back as garbage - `Gst.Rtsp.RTSPUrl.Parse` returned a url whose host, path and credentials were undefined, `Gst.Rtsp.RTSPRange.Parse` returned a range whose unit was a random integer, and the same held for `RTSPTransport.New`, `SDPMedia.New`/`Copy`, the `RTSPMessage` constructors and `RTSPAddressPool.ReserveAddress`. `Gst.Object.Replace(oldobj, newobj)` was worse: it handed native the object pointer where C wants the address of a variable, so every call unreffed the object's class pointer and overwrote it - it becomes `Replace(ref Gst.Object oldobj, Gst.Object newobj)`, and the parameterless overload becomes `Replace(ref Gst.Object oldobj)`. `RtspAuthCredentialsFree` now takes the credential array pointer (`IntPtr`) rather than a single `RTSPAuthCredential`, which native was reading as a pointer and freeing. Two more of the same family are fixed with it: `Gst.Sdp.SDPMessage.Init` becomes an instance method (`msg.Init()`) and `Gst.Sdp.Global.SdpMessageInit` now takes the message, because C's `gst_sdp_message_init` re-initialises a message you already own - declared as an out-parameter it wrote a whole SDP message through an eight-byte stack slot and aborted the process inside malloc; and `WebRTCICE.OnGetLocalCandidates`/`OnGetRemoteCandidates` now return `WebRTCICECandidateStats[]`, since C returns a NULL-terminated array of pointers that was being read as a single struct. **`Gst.Video.VideoInfo.Init` and `Gst.Audio.AudioInfo.Init` become instance methods** for the same reason - C's `gst_video_info_init`/`gst_audio_info_init` initialise an info you already own, and as out-parameters they wrote a whole GstVideoInfo over the caller's stack frame and returned null every time; use `new VideoInfo()` / `new AudioInfo()` to get one, then `Init()` to reset it. `Gst.Rtsp.Global.RtspTransportInit`, `RTSPTransport.Init`, `Gst.Sdp.Global.SdpMediaInit` and `SDPMedia.Init` no longer hand those C functions an uninitialised heap block, which they began by calling `g_free` on. The `Gst.Rtsp.RTSPMessage` struct also gains the `type_data` union it was missing, so its layout matches the native one (#1062).
- [Core] **macOS: video capture no longer opens a different camera than the one selected.** The device index passed to `avfvideosrc` was recorded once at enumeration time, but macOS may reorder cameras between enumeration and pipeline start (USB re-enumeration), so after such a reorder every new capture opened whatever device had taken the selected camera's position - typically failing with "Internal data stream error" or capturing from the wrong webcam. The position is now resolved from AVFoundation's live device list by stable unique ID right before each start; the enumerated index remains as a fallback. If the selected camera is no longer connected, capture now fails with an explicit error instead of silently opening a different camera. `VideoCaptureDeviceInfo` gains `AvfUniqueID` on macOS (#843).
- [Core] **iOS: the selected camera is now opened by its AVFoundation unique ID rather than by its localized name.** Video capture looked the camera up by display name across every AVFoundation device, microphones included, so a name that was not unique - or that changed with the device language - could open a different camera or none at all. The unique ID recorded at enumeration is now authoritative: a camera that no longer resolves by it fails outright rather than falling back to a name match that could open a different camera. The name search remains only for a settings object built by hand, which carries no unique ID at all. A camera that cannot be found now fails with an error naming both the device and its unique ID (#1089).
- [Core] **Video capture blocks no longer throw `NullReferenceException` when no camera was found.** `CreateWithDefaultDeviceAsync()` returns a block with no settings when device enumeration comes back empty - camera permission denied, a simulator, a machine with no webcam - and only the Android path checked for it. Every other platform dereferenced the missing settings and threw out of the public `Build()`; both `SystemVideoSourceBlock` and `IOSVideoSourceBlock` now return `false` and log what is missing. The same applies to settings that exist but name no device, and on iOS to settings with no video format.
- [Core] **SDK log events now carry the exception object, not just its text.** Every logging call that takes an exception passed it to Serilog as a message-template value rather than as the exception, and a template with no placeholders discards it - so a sink whose output template renders `{Exception}` printed nothing there, and exception types and stack traces never reached the log at all. They are attached properly now, across the whole SDK.
- [Core] `KLVDecoder` and `KLVRemux` are now `static` classes. Both only ever exposed static members, so documented usage (`KLVDecoder.DecodeFromFile(...)`) is unaffected; code that instantiated them with `new` will no longer compile.
- [Core] `VideoFrameRate` gained the `<=` and `>=` operators, completing the comparison set alongside the existing `==`, `!=`, `<` and `>`. They use the same 0.0001 tolerance as `==`.

## 2026.8.23

- [Core] **WPF skin controls are now available on every Windows target framework.** `VisioForge.Core` previously compiled the WPF skins (`SkinPlaylist`, `SkinCaptureControls`, `SkinPlayerControls`, …) only for `net*-windows10.0` and .NET Framework targets, so projects targeting a plain `-windows` TFM such as `net10.0-windows` — including the Skinned Player and Skinned Capture demos under the nano build flavour — failed with "The tag 'SkinPlaylist' does not exist in XML namespace" (#859). Note that `SkiaSharp.Views.WPF` ships no asset for plain `-windows` targets, so restore falls back to its .NET Framework asset (NU1701); the controls compile and work.
- [Media Blocks SDK .Net] **Fixed a process crash when a subtitle auto-hide timer fired after the overlay block had been torn down.** `OverlayManagerBlock.Video_Overlay_Update` dereferenced its internal element without a null check on the re-add path, so a late subtitle hide tick raised an unhandled `NullReferenceException` on a timer thread and aborted the whole process (#823).
- [Media Blocks SDK .Net] **Media Foundation H.264/HEVC encoders no longer log a GLib critical and silently drop the reference-frames setting on every run where it is left at the default.** The default of 0 ("encoder default") lies below the encoder element's own property range, which starts at 1; the value is now skipped instead of being written out of range (#857).

## 2026.8.22

- [Core] **Breaking: `new Gst.Buffer(size)`, `new Gst.BufferX(size)` and `new Gst.BufferList(size)` are replaced by `Gst.Buffer.NewAllocate(size)`, `Gst.BufferX.NewAllocate(size)` and `Gst.BufferList.NewSized(size)`.** The size constructor sat one implicit conversion away from the pointer constructor `Buffer(IntPtr)`, and since .NET 7 an `int` literal converts implicitly to a native integer - so `new Gst.Buffer(1024)` silently bound to the pointer overload and produced a buffer wrapper over address 1024. Nothing failed at the call site; it crashed later inside GStreamer with no hint of where it came from. The allocating form is now a named factory that cannot be confused with wrapping a pointer, and both old spellings fail to compile with a message naming the replacement. Wrapping an existing native pointer is unchanged.
- [Core] **Long GStreamer sessions no longer grow their native memory footprint on every negotiation, frame push and dropped frame.** The managed wrappers for `GstCaps`, `GstBuffer`, `GstEvent`, `GstMessage`, `GstMemory`, `GstSample`, `GstQuery` and `GstTagList` never released the native object: `Dispose()` and `using` on them did nothing at all, so every capability negotiation, every pad-caps query and every self-allocated buffer that was created and released left its native allocation behind for the life of the process. The effect grew with running time and with the number of pipelines built and torn down; it was largest on paths that touch caps or buffers per frame - pad probes, overlays, VU metering, and the custom mixer's queue-overflow frame drops. Reference counting is restored, so disposing these objects - or letting the garbage collector do it - now actually frees them.
- [Video Edit SDK .Net] **Encoder settings on the render/output path are no longer silently lost on hosts where the encoder element exposes fewer properties.** Video Edit renders configured the encoder through the GStreamer `encodebin` profile, which writes every property with an unchecked `g_object_set`: a property the concrete element class does not expose - Media Foundation encoder classes are generated per device, so their property set differs from machine to machine - raised a GLib critical and was dropped without any error. The profile now pins only the encoder factory; the settings are applied to the encoder element after encodebin creates it, with each property probed first and a warning logged when one is not available.
- [Media Blocks SDK .Net] **`SimpleVideoMarkDetectBlock.VideoMarkDetected` now actually fires.** The block installed its bus handler with `Bus.AddWatch`, but a GStreamer bus supports a single watch and the pipeline already owns it, so the install silently failed and watermark detection never reported anything; the handler is now delivered through the pipeline's own bus signal dispatch. Two defects found behind the same dead event are fixed with it: the detection pattern was read from a message field that does not exist (the element posts it as `data`), and the handler could be handed an already-released message by the pipeline's own bus handler running before it.
- [Core] **Disposing `DeviceEnumerator` while another thread was starting device monitoring or enumerating NDI/Decklink devices no longer risks disposing the same GStreamer device monitor twice** - which surfaced as GLib object-lifetime criticals in the log, or as a device monitor left running after dispose. Monitor teardown now serializes with monitor creation through one lock (so device-monitor work is queued across enumerator instances), and concurrent `Dispose()` calls are safe. NDI enumeration still never blocks other instances: its potentially slow mDNS discovery runs outside the shared lock on an exclusively claimed monitor.
- [Core] **Disposing any `DeviceEnumerator` instance no longer breaks NDI device-provider toggling for every other enumerator in the process.** Dispose released the shared registry-feature wrapper all instances use to load/unload the NDI provider, so after one enumerator was disposed its siblings passed a dead pointer into the GStreamer registry on every later enumeration (`gst_registry_remove_feature: assertion 'GST_IS_PLUGIN_FEATURE' failed` in the log). The reference is now dropped instead of disposed.
- [Core] **Dropping an engine object without disposing it no longer risks killing GStreamer for the rest of the process.** `VideoCaptureCoreX`, `MediaPlayerCoreX`, `SimplePlayerCoreX`, `MediaBlocksPipeline`, the Live Video Compositor and its outputs, the overlay managers and several other classes ran their full GStreamer teardown from the garbage collector's finalizer thread when an instance was never disposed - which could take the process-global GStreamer registry with it, so every pipeline created afterwards failed to build with nothing in the log connecting the failure to the object collected minutes earlier. Finalizers now leave the native objects to the binding's deferred release path; `Dispose` remains the way to stop pipelines deterministically. One trade to know about: a recording whose engine was never disposed ends without a muxer trailer and stays unplayable - dispose explicitly to finalize files.
- [Core] **An undisposed GigE (Aravis) camera now releases its stream and camera handles at collection** instead of taking locks, tearing down timers and raising events from the finalizer thread. Stopping acquisition still requires an explicit `Disconnect()`.
- [Media Player SDK .Net] **A faulted dispose of `MediaPlayerCoreX` no longer leaves the player permanently half-torn-down with no way to finish it.** If stopping or closing the pipeline threw during `Dispose`/`DisposeAsync`, the player marked itself as disposed while the GStreamer pipeline had never reached NULL and internal resources were never released - and every later dispose call only re-observed the stored failure instead of retrying. A faulted teardown now leaves the player usable, flushes and re-arms the debug log for the next attempt, and a subsequent `Dispose()` or `DisposeAsync()` completes the teardown.
- [Video Capture SDK .Net] **DirectShow Picture-in-Picture recording no longer fails with "Unable to set PIP layer settings" in Horizontal and Vertical layouts, and `PIP_CustomOutputSize_Set` now produces output of exactly the requested size.** The struct passed by value to the video mixer filter declared its frame-duration field as 32-bit while the native filter reads it as 64-bit, so every output-settings call was rejected and the mixer silently kept its previous canvas: in Horizontal/Vertical layouts the later layer-position calls then failed with an error at start, and with a custom output size smaller than the main video the recording came out at the wrong size. Output size is now applied before layer positions, the main video fills a custom canvas, and a failed PiP configuration call logs the failing parameters with the native result code.

## 2026.8.21

- [Demos] **The Avalonia demos and the console RTSP servers build again on macOS regardless of which macOS workload patch is installed.** They pinned `net10.0-macos26.2`, a target platform version that only machines whose workload manifests declare 26.2 accept - everywhere else the build failed before compilation with `NETSDK1140: 26.2 is not a valid TargetPlatformVersion for macOS`. The demos now use `net10.0-macos` with no version suffix, like the rest of the sample tree, so the platform version follows whatever the machine has installed.
- [Demos] **The remaining Media Blocks console demos and the Blazor RTSP servers build again on Apple-silicon Macs.** An unconditional `PlatformTarget x64` conflicted with the `osx-arm64` runtime identifier inferred for `net10.0-macos` (`NETSDK1032`) in VideoResizer, FrameRateAdjuster, RTSPViewCV and both Blazor RTSP servers; the pin is now Windows-only. The ones used as `.app` bundles on macOS also lacked a bundle identifier and now declare one.
- [Demos] **The Live Subtitles console sample no longer declares a macOS target.** Whisper.net requires static whisper.cpp archives on Apple platforms and `Whisper.net.Runtime` ships none for macOS, so the sample's speech-to-text pipeline could not link there; it stays available on Windows and Linux.
- [Media Blocks SDK .Net] **Stopping a pipeline with `ObjectAnalyticsBlock` no longer logs analytics or overlay errors and no longer loses the frame that was in flight.** Teardown freed the block's renderer, tracker, zones and lines while the streaming thread could still be using them, so a frame arriving during the stop was dropped with a logged `ObjectDisposedException` or null-reference message; teardown now waits for the frame in flight before freeing anything.
- [Media Blocks SDK .Net] **`FallbackSwitch` enabled on source settings passed directly to a source block is no longer silently ignored.** `RTSPSourceSettings.FallbackSwitch` (and the same property on the SRT, NDI, RTMP and HTTP source settings) is applied by `VideoCaptureCoreX` and by an explicit `FallbackSwitchSourceBlock`; a bare `RTSPSourceBlock`, `SRTSourceBlock`, `SRTRAWSourceBlock`, `NDISourceBlock` (or the Windows-only `NDISourceXBlock`), `RTMPSourceBlock` or `HTTPSourceBlock` does not use it, and enabling it there now logs a warning at build time explaining how to get automatic failover instead of proceeding without any message.
- [Core] **`MediaInfoReaderX` no longer spins up a full-throughput decoder just to read file metadata.** The discovery pipeline let GStreamer auto-plug `dav1ddec` with its defaults - threading and frame delay sized to the CPU core count - so reading the metadata of one 8K AV1 file pre-allocated a reference-frame pool costing ~700 MB of working set on a 14-core machine and growing with every core. Discovery now pins that decoder to low-latency single-thread mode before it starts, bounding the same read by the stream's reference structure instead of the machine's core count (~310 MB for 8K AV1 on any machine).
- [Core] **The built-in HLS/DASH HTTP server on macOS and Linux no longer dies if a player connects while it is starting.**
- [Core] **The built-in HLS/DASH HTTP server on macOS and Linux now accepts IPv6 clients, including `http://localhost/` when that name resolves to `::1`.**
- [Media Blocks SDK .Net] **Adding an audio or video effect to a running pipeline no longer leaves it paused.** Under concurrent effect changes, the pipeline could still be resuming when the add returned, leaving later effect operations or stopping playback waiting indefinitely.
- [Media Blocks SDK .Net] **A video or audio effect added while the pipeline has just left Playing now reaches the running graph.** A pause that landed during the add used to leave a video filter in NULL, and to skip the audio filter until the next build.
- [Media Blocks SDK .Net] **A pipeline that was preloaded and then resumed no longer flickers back to paused, and no longer seeks `StartPosition`, after playback was already started.** Resume (or the next `StartAsync`) had already published `Play`, but a late confirmation of the preload's pause could overwrite it and re-seek. `MediaPlayerCoreX.State`, which reports the pipeline's state, is covered by the same fix.
- [Media Blocks SDK .Net] **A live-added proxy, buffer or subtitle bridge source now brings its whole graph up with the pipeline.** Those three sources published no core wrapper, so a live add synced only the one GStreamer element the block exposed and left the rest of the bridge in NULL.
- [Media Blocks SDK .Net] **`MediaBlocksPipeline.SyncBlockStateLive` no longer throws on a block that was never built, and no longer races the block's own teardown.** Calling it out of order - before `AddBlockLive` built the block, or after it had been cleaned up - raised a `NullReferenceException` out of the SDK instead of returning `false` with a logged reason like every other refusal in that method. It also read the block's element and then synchronised it after releasing the lock that guarded it, so a teardown landing in that window left the live add reported as "failed to set block to Playing" with the real reason only in a GStreamer log line. The same "has not been built" refusal now also applies to `MediaBlockHelper.SetState` and `MediaBlockHelper.SendEvent`.
- [Media Blocks SDK .Net] **RTSP playback no longer fails with "Failed to link RTSP pad: WasLinked" when the source re-announces a pad.** On a reconnect, or when an RTSP server re-announces a stream, `UniversalSourceBlockV2` could report a pad it had already linked as a link error and end the session - intermittently, since two of rtspsrc's streaming threads can pass the "is this pad linked" checks together. A duplicate announcement is now recognised from the link result itself - a second attempt reports `WasLinked`, which is logged at debug level instead of failing the session - and the handler's check-and-link section is serialised.
- [Core] **A handler connected with `Connect(...)` or with `+=` on a generated GStreamer event no longer keeps that object alive for the life of the process.** Every `Connect(...)` on an element - the mechanism behind source, demuxer and decoder auto-plugging - and every `+=` on a generated event was recorded in a process-wide table that only an explicit unsubscribe ever cleared, and the entry held the element, the handler, and everything the handler had captured. An application that builds and tears down sources or decoders in a loop, a playlist or a transcode over a directory, grew without bound with nothing disposable to blame. A connection is now owned by the object it was made on and is released with it. Two defects of the same family go with it: a handler silently stopped being delivered once its wrapper had been disposed, and the callback's handle was released while an emission could still be inside it - a rare crash on a streaming thread when a recording was stopped on a file split.

## 2026.8.20

- [Video Capture SDK .Net] **`VideoCaptureCoreX.WaitForStartAsync` no longer waits forever, and no longer returns before the capture starts.** It polled for `PLAYING` and nothing else, so a source that never gets there - an RTSP or HTTP address that black-holes, a capture device with no signal, a Decklink with no input - parked a thread on a `Task` that never completed, and an asynchronous failure (which takes the pipeline back to `READY` without tearing it down) did the same. The wait now ends when the start settles somewhere it will not leave, and has a 30-second deadline; the new `WaitForStartAsync(TimeSpan timeout, CancellationToken cancellationToken = default)` overload chooses that deadline, cancels the wait, and returns whether `PLAYING` was actually reached. The documented fire-and-forget pairing `_ = StartAsync(); await WaitForStartAsync();` also no longer completes instantly against a capture whose pipeline does not exist yet.
- [X-engines] **A second `Start()` landing while the first is still building is now rejected instead of building over it.** `VideoCaptureCoreX.Start()` and `MediaBlocksPipeline.Start()` had the guard only on their async twins, so a concurrent call cleared the first start's state and re-entered the build over the pipeline that call was still assembling. Relatedly, a start that fails now finishes its own rollback before it releases the start, so processing blocks registered by another thread are no longer disposed under it, and a throw out of a restart's teardown no longer leaves the instance permanently unable to start.
- [Media Blocks SDK .Net] **A `ChromaKeyBlock` added to a running pipeline now brings its whole graph up with the pipeline, not just the compositor.** The block builds six elements, and a live add synchronised the state of only one of them, so the other five - the background scaler and capsfilter, the alpha key, and both converters - stayed in whatever state they had been created in. They now live in one bin, which is the one thing the pipeline brings up.
- [Media Blocks SDK .Net] **A start the pipeline refuses is now reported as stopped instead of as playing.** When an element refused the transition to playing - a capture device that cannot be opened, a renderer that cannot create its window - `Start()` returned `false` but left `State` reporting `Play`, and left every element that had already opened a device, handle or socket holding it. The pipeline is now torn down and reports `State = Free`, so a retry rebuilds it. With `PauseOnStop` enabled that retry previously returned `true` without rebuilding anything, on a graph that never started. A start that never started no longer raises `OnStop` when it is stopped afterwards. `MediaPlayerCoreX.State`, which reports the pipeline's state, is covered by the same fix, and `VideoCaptureCoreX.Start` now returns as soon as the pipeline fails instead of going on to start the auto-start outputs against it.
- [Media Blocks SDK .Net] **A preload that fails while prerolling is now reported.** `StartAsync(onlyPreload: true)` and `Start(onlyPreload: true)` returned `true` whenever the source failed asynchronously - a camera already in use, an unplayable file, a stream that never connects - and left the pipeline holding whatever its elements had opened, with nothing telling the caller. Only a transition the pipeline refused outright was reported. Both now return `false` and tear the partial graph down; `Pause()` on a running pipeline reports the same failure the same way.
- [Media Blocks SDK .Net] **The processing block passed to an `LVCVideoInput` constructor is now applied.** On LiveVideoCompositor V2, the optional `processingBlock` argument of both `LVCVideoInput` constructors was stored and never linked into the graph: the input composited unprocessed, with no error and no log line, while the identically shaped argument of `LVCVideoAudioInput` worked. It is now an alias for `LVCVideoInput.ProcessingVideoBlocks`, so the block runs between the source and the mixer as the argument always implied. Code that already uses `ProcessingVideoBlocks` is unaffected.
- [Media Blocks SDK .Net] **The `channel` parameter of `LiveVideoCompositorV2.Video_Effects_*` is deprecated.** V2 has a single effects block on the composed output, after the mixer, so the index never selected anything - `Video_Effects_Clear(channel: 1)` cleared the whole composition's effects, where the identically named V1 call validates the index and ignores a channel that does not exist. Every `Video_Effects_*` method now has a channel-free form; the overloads that take a `channel` still work, forward to it and warn. To process a single input rather than the composition, add a `VideoEffectsBlock` to that input's `LVCVideoInput.ProcessingVideoBlocks` - those blocks run between the source and the mixer, which is where V1's per-channel effects were. V1 is unchanged.
- [Media Blocks SDK .Net] **An effect added to a running pipeline while that pipeline is being stopped is no longer left in the graph unreachable.** `VideoEffectsBlock.AddOrUpdateAsync` and `AudioEffectsBlock.AddOrUpdate` splice the new effect into the live graph, and that work can take seconds - it runs your `OnUpdate` handler twice and pauses the pipeline to relink it. A stop that gave up waiting for it went ahead and released the block anyway, and the insertion then carried on and spliced its element in regardless: the block no longer knew about it, so `Remove()` reported success without removing anything and the next `Build()` created a second element under the same name, for the rest of the run. Both blocks now stop an insertion the moment a teardown has been through, and leave the element to the pipeline's own disposal - on an ordinary stop that is what releases it. The effect stays registered, so the next build puts it in the graph.
- [Media Blocks SDK .Net] `MediaBlocksPipeline.State` now reports `Pause` as soon as `StartAsync(onlyPreload: true)` / `Start(onlyPreload: true)` returns, instead of briefly reporting `Free` while the pipeline was already preloading. Inside that window a preloaded pipeline looked stopped to every "is anything running?" check: `StopAsync` and `Stop` returned without tearing it down and without raising `OnStop`, `Dispose` skipped the stop it does first, `ClearBlocks` disposed the blocks of a live pipeline instead of refusing, a `StartPosition` set on the preloaded pipeline was dropped instead of seeked, and starting playback right after a preload could be rejected with "Already starting or start in progress". `MediaPlayerCoreX.State`, which reports the pipeline's state, is covered by the same fix.

## 2026.8.19

- [Media Blocks SDK .Net] `RTSPSourceSettings.BufferMode` and `DropOnLatency` now reach the RTSP source. Setting them previously had no effect, so jitter-buffer tuning was silently ignored. The default jitter buffer is **500 ms**; `LowLatencyMode` uses **150 ms**, or the explicit `Latency` if you set it to 150 ms or less.
- [Media Blocks SDK .Net] **Changing video mixer settings while the pipeline is being stopped no longer crashes or silently does nothing.** `SetSettings`, `Input_Update`, `Input_Move`, `StartFadeIn`, `StartFadeOut`, `Input_UpdateChromaKeySettings` and `Input_SetChromaKeyEnabled` ran with nothing serialising them against the block's own teardown, so a call that landed during a stop reached GStreamer through an element the teardown had already released - a `NullReferenceException`, or a change that was accepted and quietly not applied. Building a mixer while it was being stopped had the same problem and could throw out of `Build()`. Affects `VideoMixerBlock`, `VideoMixerSourceBlock`, `GLVideoMixerBlock`, `D3D11VideoCompositorBlock` and `MetalVideoCompositorBlock`. `AddInputPadLive` on a mixer that is not built now returns `null` and logs, instead of throwing.
- [Media Blocks SDK .Net] **A video mixer fade or move animation no longer outlives the block that started it.** `StartFadeIn`, `StartFadeOut` and `Input_Move` animate on a background thread for the duration requested; stopping or disposing the mixer while one was running left that thread writing to a released element, which took the whole application process down with an unhandled `NullReferenceException`. Teardown now stops the animations and waits for them first. They also no longer keep the process alive after everything else has finished.
- [Video Fingerprinting SDK .Net] **Disposing a `FrameSource` while `PlayAsync` was still starting no longer leaves a playing pipeline behind.** The teardown and the start shared no synchronization, so a `Dispose()` - or a `StopAsync()` - landing mid-start tore down the session the start was still building, and the start went on to leave a fully wired pipeline that nothing owned: `OnVideoFrame` kept firing for the rest of the process. Overlapping `PlayAsync`/`StopAsync` calls, which a UI can produce with two quick clicks, could also tear the same pipeline down twice. `FrameSource` now also implements `IAsyncDisposable`; `await frameSource.DisposeAsync()` is the deterministic teardown, because a synchronous `Dispose()` cannot wait for a start already in flight.
- [Media Blocks SDK .Net] **Disposing a pipeline that was only preloaded (`StartAsync(onlyPreload: true)`) no longer hangs.** The teardown skipped the stop for a preloaded pipeline and set its elements to the null state under a live streaming thread, which wedged the disposing thread and the streaming thread against each other indefinitely.
- [Media Blocks SDK .Net] **Disposing a pipeline while it was reporting a state change no longer hangs.** The teardown and the pipeline's own message thread could block on each other for good.
- [Media Blocks SDK .Net] `VP8EncoderSettings.GetCaps()` now reports `video/x-vp8` instead of `video/x-vp9`.
- [Media Blocks SDK .Net] An IPv6 URL such as `udp://[ff05::1]:5004` now reaches a UDP source, a universal source and an RTSP server without the brackets, so the element binds and joins multicast instead of failing silently. A Windows link-local zone id (`%12`) is left intact instead of being decoded as a byte.
- [Media Blocks SDK .Net] `LiveSourceSwitchBlock.Switch(i)` no longer **pairs one source's video with another's audio** on a switcher that holds a mix of input types. A video-only input and a video+audio input take their switch pads from two independent counters, so the same index meant a different source in each of the two switches: with a video-only input added first, `Switch(1)` played the second input's picture with **silence**, because no input feeds audio pad 1. `Switch` now resolves the input at the given index and moves each switch to that input's own pad. An input that carries only one of the two streams leaves the other switch where it was, so switching to a video-only input keeps the audio that was playing. New `CurrentVideoIndex` / `CurrentAudioIndex` properties report the pads actually selected. Two smaller changes come with it: an index past the last added input is now refused and logged instead of pointing the switch at a reserved pad that carries nothing, and `SourceSwitchBlock.Switch` returns `bool` - `false` when the block is not built yet, the index is out of range, the pad at that index was never obtained, or a concurrent stop tore the element down - where it used to return `void`. Every one of those is logged; a switch that could not be applied no longer passes silently.
- [Media Blocks SDK .Net] `LiveSourceSwitchBlockDynamic.Switch(slot)` no longer **silences the audio when the slot holds a video-only input**. Nothing feeds that slot's audio pad, so moving the audio switch there played silence; it now stays where it was, matching `LiveSourceSwitchBlock.Switch`. An **empty** slot is not that case - switching to a slot with no input in it still takes the audio with it, rather than leaving the previous source's sound playing under a black picture; one limit is structural, in that a switcher whose `MaxAudioInputsCount` is smaller than its `MaxVideoInputsCount` has no audio pad above the audio limit for the audio to move to. A slot index past the last slot is now refused and logged; on a switcher whose audio switch has more pads than its video one it used to move the audio switch while the video switch declined, so the sound went silent under a picture that kept running. Its `CurrentVideoIndex` / `CurrentAudioIndex` also **start at `-1` instead of `0`** - they used to report slot 0 before any switch had been applied, which was not true, and they now record only a switch the block actually applied. Code that reads either property before the first switch and indexes its own array with the result has to handle `-1`.
- [Media Blocks SDK .Net] Disposing a `LiveSourceSwitchBlock` now **releases its inputs and internal resources**. The teardown freed nothing at all, so an application that created and disposed switchers - or added file inputs to one - leaked a whole graph, including a pipeline per input, on every instance.
- [Media Blocks SDK .Net] A `LiveSourceSwitchBlock` configured for **one stream only** (`VideoStream` or `AudioStream` turned off) now starts. It threw a `NullReferenceException` on the first `StartAsync`, so the setting could not be used at all. `Input_AddAsync` now also **refuses an input for a stream the switch does not carry** and returns `false` instead of throwing, or - for an audio input on a video-only switch - accepting it and playing nothing. The same applies to `LiveSourceSwitchBlockDynamic.Input_AddToSlotAsync`, where a video/audio input on a switch without audio is now refused rather than half-connected.
- [Media Blocks SDK .Net] Building a `BridgeBufferSourceBlock` whose paired sink was never created, or has already been disposed, no longer throws `ArgumentNullException` — `Build()` returns `false` instead.
- [Media Blocks SDK .Net] **Retargeting a UDP sink at runtime no longer sends to a mixed destination.** `UDPSinkBlock.SetFilenameOrURL` and the UDP MPEG-TS sinks pushed the new host and the new port as two separate steps, so two calls landing at once could leave the sink streaming to one URL's host and the other's port. An **IPv6 URL now reaches the sink correctly** - `udp://[ff05::1]:5004` used to arrive with the brackets still on the address, which it cannot resolve, the URL reported back by `GetFilenameOrURL` could not be parsed again, and a link-local zone id (`udp://[fe80::1%25eth0]:5004`) kept its percent escape. This covers the UDP **sink**; the UDP source, universal source and RTSP server are the matching follow-up. New public overload `UDPSinkSettings.TryParseUrl(string url, out string host, out int port)` returns the parsed pair, for callers that must not read it back off shared settings.
- [Core] Fixed a **memory leak on every GStreamer property or caps field set to a string, or to a caps, structure, buffer or tag reference**. The value handed to the element was copied but the caller's copy was never released, so each set leaked the string's allocation - or, for caps and elements, held a reference that kept a live GStreamer object alive for the rest of the process. Worst on properties pushed repeatedly: text and image overlay contents, bridge channel names, device paths, file names and URLs, and every caps renegotiation. Numeric and boolean properties were never affected.
- [Media Blocks SDK .Net] A media block that is **garbage-collected without being disposed** no longer tears its GStreamer elements down from the finalizer thread. An application that forgot a `Dispose()`, or dropped a block after an exception, could see a crash or a stall inside the .NET finalizer during collection; abandoned blocks now leave their elements to the pipeline that owns them.
- [Core] The WPF `VideoView` no longer shows a **black preview in a remote-desktop session** when the D3D11 composable renderer is requested. Such a session composes WPF in software and its Direct3D9 device sits on a different adapter, so the GPU surface can never be presented; the view now detects that and falls back to its software rendering path automatically, logging a warning, instead of displaying nothing.
- [Core] Fixed the WPF `VideoView` **silently dropping back to software rendering on the second playback**. After a `Stop()` the next start rebuilt the view from the engine's renderer mode alone — and both the `D3D11Composable` and `Direct2DManaged` paths rewrite that mode to `FrameCallback` — so GPU-resident composition degraded to a per-frame CPU upload, with no error and `GetSurfaceProvider()` returning `null`. The view now remembers the renderer it was asked for and restores it on the next start; setting a different renderer mode on the engine between two starts still switches away from it, as before.
- [Media Blocks SDK .Net] **Audio effects added during playback are now inserted at their position in the effect list**, so the applied order no longer depends on whether an effect was added before or during playback - and a second effect added straight after the first is no longer silently left out of the pipeline. The block's output also correctly follows the last effect after live additions and removals; removing the last effect used to leave the block pointing at the removed one.
- [Media Blocks SDK .Net] An audio or video effect **added while the pipeline was being stopped or disposed** is no longer silently lost. Stopping the pipeline from the effect's own `OnUpdate` handler let the block build the effect's element against a pipeline that no longer existed: nothing failed, nothing was reported, and the effect was simply absent from the graph. The block now reports it and keeps the effect registered, so the next start puts it in.
- [Core] Calling `Dispose()` on a GStreamer wrapper object no longer prints a GLib critical such as `gst_iterator_free: assertion 'it != NULL' failed` or `gst_structure_free: assertion 'structure != NULL' failed`. The object was always freed correctly; a second, redundant free with a null handle produced the log line. This affected `Gst.Iterator`, `Gst.Structure`, `Gst.Video.VideoInfo`, `Gst.Audio.AudioInfo`, `Gst.Video.VideoConverter`, `Gst.ParseContext` and the other non-reference-counted opaque wrapper types, all of which are now safe to dispose.

## 2026.8.18

- [Core] Fixed a **crash when playback was stopped while the WPF `VideoView` was rendering through `Direct2DManaged`**. The view freed the RGBA staging buffer on the UI thread while a frame was still being converted into it on the streaming thread, which corrupted the heap or took the process down outright. The same buffer was also sized from the very first frame and never grown, so a source that **switched to a higher resolution mid-stream** overflowed it.
- [Core] Fixed the WPF `VideoView` **silently replacing a classic engine's `WPF_WinUI_Callback` / `FrameCallback`, `None`, `Direct2DManaged` or `D3D11Composable` renderer mode with EVR**. The view built a native HWND renderer instead of the requested one, so WPF controls placed over the video stopped composing (airspace), and for `WPF_WinUI_Callback` and `None` the engine's `Video_Renderer.VideoRenderer` read back `EVR` — a mode the application never set. (`Direct2DManaged` and `D3D11Composable` still read back as `FrameCallback`: the view draws those itself and the engine feeds it frames.) Calling `VideoView1.SetNativeRendering(false)` is no longer required for the software rendering path.
- [Media Blocks SDK .Net] Stopping a pipeline that has **already reached the end of its stream** no longer waits ten seconds for an end-of-stream that has already happened. The output file was already complete; the stop just took that long to return.
- [Media Blocks SDK .Net] Fixed **stopping a pipeline reporting a spurious error** — `Resume for EOS did not reach PLAYING ... Muxer may not finalize` — when the pipeline had not finished starting up yet. The stop also stalled two seconds before reporting it, and applications that treat an SDK error as a failure saw a clean stop as a failed one.
- [Media Blocks SDK .Net] Fixed a **crash when chroma-key settings were changed while the pipeline was being stopped**. Updating the key color, alpha or sensitivity from one thread used to be able to land on the filter while another thread was tearing it down.
- [Media Blocks SDK .Net] Fixed **audio effect settings being silently discarded when changed while the pipeline was being stopped**. Every audio effect — volume, balance, amplify, echo, compressor/expander, both equalizers, pitch, loudness normalization, RNNoise, HRTF, Csound, the Chebyshev filters, karaoke, wide stereo, reverberation and the rest — used to be able to push a change onto an element another thread had already released, in which case nothing happened and nothing was reported.
- [Media Blocks SDK .Net] Fixed **removing an audio effect while the pipeline is being stopped leaving that effect in the graph**. The removal reported success while the effect was still spliced into the chain, and could also throw `IndexOutOfRangeException` out of `AudioEffectsBlock.Clear`.
- [Media Blocks SDK .Net] Fixed **`AudioEffectsBlock.Remove` not removing an effect that had been updated since it was added**. The live element was unplugged but the effect stayed in the list, so the next time playback started it came back.
- [Media Blocks SDK .Net] Fixed **`AudioEffectsBlock.AddOrUpdate` called twice with the same effect object stopping that effect's later property changes from reaching the graph**.
- [Media Blocks SDK .Net] Audio effect names are now matched the same way everywhere — **case-insensitively**. Adding `Volume` and then `volume` used to create two effects that both drove the first one.
- [Media Blocks SDK .Net] Fixed a **`NullReferenceException` when an audio effect property was changed after the pipeline had been stopped**.
- [Media Blocks SDK .Net] Pipelines containing an `AudioEffectsBlock` no longer carry **one unused audio converter element** each.
- [Media Blocks SDK .Net] Fixed **the whole video or audio effect chain silently disappearing for the rest of the run** after a stop that had to give up waiting for an effect operation to finish. The block was left claiming it was built while owning nothing, so every later start produced no effects at all and reported no error.
- [Media Blocks SDK .Net] Fixed **`VideoEffectsBlock` keeping every effect object it was given alive after it was disposed**. The effects stayed subscribed to the disposed block, so neither they nor the pipeline's elements could be collected, and changing one of their properties afterwards reached a block whose pipeline was gone.

## 2026.8.17

- [Media Blocks SDK .Net] Fixed **playback freezing for the rest of the run when a video or audio effect added to a running pipeline is refused by the graph**. The effect is simply not applied now, instead of leaving the chain cut at the point it was being inserted.
- [Media Blocks SDK .Net] Fixed the same freeze on the removal side: **removing a video or audio effect from a running pipeline no longer cuts the chain when the surrounding elements cannot be linked to each other**. The effect stays in place and the removal reports failure, instead of reporting success over a chain nothing flows through.
- [Media Blocks SDK .Net] **Removing an effect that is built from several elements — box, crop, aspect-ratio crop, resize, pan/zoom, fisheye, LUT, text overlay, image overlay, QR overlay, mouse highlight, overlay manager, pitch, compressor/expander, loudness normalization — now takes them out of a running graph as one unit.** A removal that succeeded for some of an effect's elements and failed for the rest used to leave the effect half in the graph: the next effect added live could end up in the wrong position, or the block could stop producing output altogether. The removal now either takes the whole effect out or leaves it running untouched and reports failure.
- [Media Blocks SDK .Net] **Removing a LUT or QR-code overlay effect live no longer leaves the chain pinned to that effect's pixel format.** Both build an internal format filter, and it used to stay in the graph after the effect was gone, forcing RGB on everything downstream of it for the rest of the run.
- [Media Blocks SDK .Net] **Repeatedly adding and removing a LUT effect during playback no longer leaves an unused element in the pipeline for every add.** That internal format filter is now taken out with the rest of the effect instead of accumulating one per add; the QR-code overlay releases its own the same way.
- [Media Blocks SDK .Net] **Changing an effect's settings from one thread while the pipeline is being stopped on another no longer silently does nothing.** The push used to be able to land on an element the teardown had already released, in which case it was discarded without any error being reported. Most visible on Android, where the renderer's resize is updated from the view thread whenever the view is resized or the device is rotated.
- [Media Blocks SDK .Net] Fixed a **`NullReferenceException` when the Android renderer's view was resized while the pipeline was stopping**.

## 2026.8.16

- [Core] Fixed video fingerprinting **`FrameSource.PlayAsync` throwing `NullReferenceException` unless the optional `Crop` and `CustomResolution` properties were set**.
- [Core] Video fingerprinting: **new `FrameSource.StopAsync()`** stops the current session and releases its pipeline so the instance can be reused — previously the only way to stop was disposing the whole object.
- [Core] Video fingerprinting: **the `VFPAnalyzer` error callback now fires exactly once per failed analysis, on the caller's thread**, with the underlying cause — previously mid-run errors could be swallowed entirely or delivered from the pipeline's internal thread.
- [Core] Video fingerprinting: **a repeated `FrameSource.PlayAsync` now stops and disposes the previous session** instead of leaving its pipeline playing for the life of the process, **a failed `PlayAsync` cleans up the half-built pipeline and is reported through the `VFPAnalyzer` error callback** instead of hanging the analysis, and `Dispose` tears the session down in a safe order.
- [Core] Fixed **event handlers subscribed after start never being called** in `VideoCaptureCoreX` (`OnError`, `OnStart`, including separate outputs), `MediaPlayerCoreX` (`OnError`, `OnStart`, `OnPause`, `OnResume`) and the video fingerprinting `FrameSource` (`OnError`, `OnStop`) — the engines captured a snapshot of the handler list at start, so late subscribers were silently ignored and unsubscribing mid-session did not detach.
- [Media Blocks SDK .Net] Fixed LiveVideoCompositor **`Video_Effects_Clear` removing every channel's effects instead of only the requested channel's** — clearing channel 0 no longer wipes the effects of all other channels for the rest of the run.
- [Media Blocks SDK .Net] LiveVideoCompositor **video-effect calls that target a channel which does not exist, or that run after the compositor was disposed, no longer throw** `ArgumentOutOfRangeException` — the call is ignored and reported through the log and `OnError`. Applies to `Video_Effects_AddOrUpdateAsync`, `Video_Effects_Get`, both `Video_Effects_RemoveAsync` overloads and `Video_Effects_Clear`.
- [Media Blocks SDK .Net] Fixed LiveVideoCompositor **`OnError` handlers never being called** — pipeline errors were dropped instead of reaching subscribers.
- [Media Blocks SDK .Net] **Video effects added during playback are now inserted at their position in the effect list**, so the applied order no longer depends on whether an effect was added before or during playback, and the block's output correctly follows the last effect after live additions and removals.
- [Media Blocks SDK .Net] **Video effect names are now matched without regard to case.** Adding `"Blur"` and then `"blur"` updates one effect instead of creating a second one that could never be updated or removed, and `Video_Effects_Get` keeps finding an effect whatever case it is asked for.
- [Media Blocks SDK .Net] **Updating a video effect with one of a different type under the same name now replaces it in the pipeline.** The graph used to keep applying the old effect and only report the mismatch.
- [Media Blocks SDK .Net] Fixed **a video effect added while the pipeline was starting never reaching the pipeline** for the rest of the run. It is now applied as soon as playback begins.
- [Media Blocks SDK .Net] Fixed **adding, removing and updating video effects from several threads at once** leaving a filter in the pipeline that no public call could reach, or applying settings to an effect that was being removed.
- [Media Blocks SDK .Net] Adding a video effect to a running pipeline now **returns only once playback has resumed**, so stopping right after it no longer reports that the pipeline could not be resumed.

## 2026.8.15

- [Media Player SDK .Net] / [Media Blocks SDK .Net] Fixed **`Video_Effects_RemoveAsync` never returning when the pipeline has nothing to pause** — a player that was never opened, or one already being stopped. It polled for the paused state with no way out, and in one overload it blocked the calling thread outright, so the call could not be interrupted from outside either. It now checks the pause once and returns: a pause that did not land is reported through the log and the effect is left in place. `LiveVideoCompositor.Video_Effects_RemoveAsync` is fixed the same way.
- [Media Blocks SDK .Net] Fixed **adding a video effect never returning when the pipeline is shutting down**, and **adding one to a paused pipeline waiting forever**. The wait for playback to resume is now capped at thirty seconds; past it the effect is left for the next start and the wait is reported.
- [Media Blocks SDK .Net] Fixed a **crash when changing a property of a video effect that is not applied to the running pipeline** — one added while playback was paused or stopped, with at least one other effect already active. The property setter threw an exception instead of doing nothing.
- [Media Blocks SDK .Net] Fixed **an effect being applied twice to a running pipeline**, leaving a duplicate filter that could no longer be updated or removed, and **an effect coming back after being removed** when it had been re-added under the same name.

## 2026.8.14

- [Video Capture SDK .Net] / [Media Player SDK .Net] Fixed a **GStreamer error when removing a video effect** (grayscale, balance, and the other live filters) from a paused capture or player pipeline.
- [Video Capture SDK .Net] / [Media Player SDK .Net] Fixed **video stopping after removing an image overlay, overlay manager, pan/zoom, or LUT effect** at runtime.
- [Media Player SDK .Net] Fixed **audio going silent after removing an audio effect** during file playback.
- [Media Player SDK .Net] / [Media Blocks SDK .Net] Fixed a **hang when removing pitch, compressor, loudnorm, or similar multi-element audio effects** from a live pipeline.
- [Media Blocks SDK .Net] Fixed a **crash when disposing an `AudioEffectsBlock`** that still had effects in the public list.
- [Video Capture SDK .Net] / [Media Blocks SDK .Net] Fixed **MP4 recordings that could not be played back after stopping a paused capture** (`VideoCaptureCoreX` / `MediaBlocksPipeline`). Start → Pause → Stop (without Resume) left a non-zero file with no `moov` index. Stopping a paused capture now finalizes the file.
- [Media Blocks SDK .Net] **RTSP sources can send their own GET\_PARAMETER keep-alive.** Set `RTSPSourceSettings.ForceCustomKeepAlive` (or the same flag on `RTSPRAWSourceSettings`) to replace the default RTSP keep-alive with a GET\_PARAMETER every 30 seconds. Off by default — use it if a camera drops the session under the built-in keep-alive.
- [Demos] The RTSP Preview demos now have a **transport selector (Auto / TCP / UDP)** and a **Force custom keep-alive** checkbox, so a camera that works in VLC but dies after a minute can be tried the same way without rebuilding.
- [Media Blocks SDK .Net] Fixed **the first line of an `OverlayManagerText` (and `OverlayManagerDateTime`) disappearing when `Y` was 0 or close to the top of the frame.** `X` and `Y` are the top-left corner of the text in pixels; `(0, 0)` is a valid position and the first line of a multiline string is fully visible there. Previously the coordinates were treated as the Cairo baseline, so a block placed at the origin had its first line clipped off the top of the picture.
- [Media Player SDK .Net] **`MediaPlayerCoreX` now has the same overlay manager as capture.** Set `Video_Overlay_Enabled` before `OpenAsync`/`PlayAsync` and use `Video_Overlay_Add` with `OverlayManagerText` (including `TextProvider`). The overlay is drawn on the preview only — after the sample grabber and after any custom video outputs — so the file on disk, snapshots and exports are not modified. Overlays added once stay across `Stop` and opening another file.

## 2026.8.13

- [Media Blocks SDK .Net] **`OverlayManagerText` can now build its text for every frame through the new `TextProvider` callback.** Set `TextProvider` to a `Func<TimeSpan, string>` and it is asked for the text once per frame, receiving the frame timestamp counted from the pipeline start; returning `null` falls back to `Text`. This is the supported way to overlay a live readout — sensor values, a clock, a frame counter, or a template mixing all three — without removing and re-adding the overlay or touching the pipeline. Assigning `Text` directly still works and is equally cheap: the text layout is cached on the element and re-measured only when the string, font or geometry actually changes, so an unchanged value costs nothing. The callback runs on the streaming thread while the overlay list is locked, so it must be short and must not block — calling back into a UI dispatcher from it can deadlock rather than merely drop a frame. A callback that throws is reported once through `OnError` and is then **not called again**: the element falls back to `Text` for the rest of the run, because retrying it would unwind an exception at the frame rate under that lock. Assign `TextProvider` again to re-enable it — worth knowing if your callback can throw on its first frame, while the values it reads are still being initialised. `OverlayManagerDateTime` inherits the property and substitutes its `[DATETIME]` token into whatever the callback returned.
- [Media Blocks SDK .Net] **Overlay elements are now up to twice as fast on multi-core machines.** Cairo-based overlays render through `cairooverlay`, which only accepts BGRx/BGRA/RGB16, so a YUV source pays for two full-frame colour conversions per frame — and those conversions were running single-threaded, which was not enough to sustain 1080p50 on many machines. The recording branch was the first to suffer, because a preview renderer silently drops late frames while an encoder writes whatever reaches it, so the preview looked fine and the recorded file did not. Measured on a 14-core machine at 1920x1080 NV12: 361 to 815 frames per second through `OverlayManagerBlock`. Affects `OverlayManagerBlock`, `ImageOverlayCairoBlock`, `PanZoomBlock`, the mouse-highlight overlay and the Android text overlay.
- [Media Blocks SDK .Net] Fixed **`StartTime` and `EndTime` on overlay elements being ignored unless both were set.** The visibility window was only applied when neither value was `TimeSpan.Zero`, so the common case of "show this for the first ten seconds" — a zero `StartTime` with a real `EndTime` — left the element on screen for the whole session. Either bound now defines a window on its own, and an `EndTime` of `TimeSpan.Zero` means the element has no end. The break is symmetric, so check both directions: an element with only `EndTime` set used to stay visible for the whole session and now disappears at that moment, and an element with only `StartTime` set used to be drawn from the first frame and is now hidden until that moment. If you set either value and relied on it being ignored, clear it. Frames that carry no timestamp at all — an `appsrc` feeding unstamped buffers, for instance — are outside any window that can be judged, and every element is drawn on them.
- [Media Blocks SDK .Net] **RTCP is now on by default for RTSP sources.** `RTSPSourceSettings.DoRTCP` and `RTSPRAWSourceSettings.DoRTCP` defaulted to `false`, and the value is always written to the underlying RTSP source — so no VisioForge application ever sent RTCP receiver reports unless it set the property itself. Many cameras and RTSP servers use those reports to tell that the client is still watching and tear the session down without them: the picture freezes on the last decoded frame and the stream ends a session timeout later, with nothing in between to explain it. The same omission also made `NTPSync` ineffective, because the NTP mapping arrives in RTCP sender reports. Both properties now default to `true`, which is also the default of the underlying GStreamer element. Set `DoRTCP = false` explicitly if you talk to an old server that cannot handle RTCP.
- [Demos] Fixed **the RTSP Preview demos building a second pipeline when Start was clicked twice.** Connecting to a camera takes a few seconds, and nothing appears on screen while it happens, so a second click was easy to make — it created a second pipeline over the same `VideoView` and opened a second session to the same camera. The two fought over the preview window, one of them failed with "Failed to open window", and on a camera that serves a single session its teardown stopped the stream for the surviving pipeline too, leaving a frozen picture. The Start button is now disabled while a start is in progress, a pipeline abandoned by a failed start is released instead of leaking, and the demos now report the stream ending — including a camera dropping the session — in their log instead of leaving a still frame with no explanation.
- [Media Blocks SDK .Net] **A user-defined overlay element can now be drawn through the new `IOverlayManagerDrawable` interface.** `Video_Overlay_Add` accepts any `IOverlayManagerElement`, but only the built-in element types were rendered, so a custom type was silently never drawn. An element that implements `IOverlayManagerDrawable.Draw` now receives the live Cairo context of the frame exactly like `OverlayManagerCallback` does. A custom type that implements neither the interface nor a built-in type is still not drawn, but is now reported once through `OnError` naming the type instead of failing silently.

## 2026.8.7

- [Core] **The BCL cryptography packages now match the framework you target instead of always being the .NET 10 line.** `System.Security.Cryptography.Pkcs`, `System.Security.Cryptography.Xml` and `System.Formats.Asn1` were pinned at 10.0.10 for every target framework, so a .NET 6, 7, 8 or 9 application referencing a VisioForge package was pulled onto the 10.0.x line whether or not it wanted to be there — and an application holding the 8.0.x servicing line got a version conflict it could not resolve, because our own assemblies were compiled against `System.Security.Cryptography.Pkcs, Version=10.0.0.0`. A .NET 6, 7 or 8 application now resolves the 8.0.x line and .NET 9 the 9.0.x line; .NET 10, .NET Framework 4.7.2/4.8 and .NET Standard are unchanged at 10.0.10. **.NET Framework 4.6.1, .NET Core 3.1 and .NET 5 move down to the 6.0.x line** — that is the only line these three are supported on, and it is what gives them a real `net461` / `netcoreapp3.1` build instead of a `netstandard` fallback, but 6.0.x is out of support and did not receive the 2026 `System.Security.Cryptography.Xml` fixes. If you target one of those three frameworks and that matters to you, add an explicit `PackageReference` to `System.Security.Cryptography.Xml 10.0.10` in your own project — expect a build warning with it, because 10.0.x states it does not support those frameworks and falls back to its `netstandard2.0` build. That warning is exactly the reason the SDK itself does not take 10.0.x there. Every other rung sits at a patched version (8.0.4, 9.0.19, 10.0.10), because those advisories are fixed in each branch separately. On .NET 6 and .NET 7 this also replaces a `netstandard2.0` fallback with the real framework build.
- [Core] **`System.Text.Encoding.CodePages` now matches the framework you target as well** — 6.0.1 on .NET Framework 4.6.1, .NET Core 3.1 and .NET 5, 8.0.0 on .NET 6 and .NET 7, and 10.0.6 unchanged on .NET 8 and newer, on .NET Framework 4.7.2/4.8 and on .NET Standard. Those older frameworks were previously handed the 10.0.6 package, which states it does not support them and gave them a `netstandard2.0` build; they now get one made for the framework they run on. This package carries no security advisory at any version.
- [Core] Fixed **`VisioForge.DotNet.Core` not declaring its dependency on `System.Security.Cryptography.Pkcs`**. The package has needed it since 2026.2.19 — the licensing code verifies Authenticode signatures — but it was declared only from 2026.4.21 onwards, and only as a side effect of how the dependency graph happened to be built. If you are on a version between 2026.2.19 and 2026.4.18, the shipped assembly requires `System.Security.Cryptography.Pkcs 10.0.0.0` with nothing in the package asking for it; add the package reference yourself or move to a current release.
- [Demos] Fixed **the Unity package's sample scenes logging three "The referenced script (Unknown) on this Behaviour is missing!" errors each** in any project that does not use the Universal Render Pipeline and the Input System. The scenes were authored from a URP 2D template and carried a `Light2D`, a `UniversalAdditionalCameraData` and an `InputSystemUIInputModule` that none of the samples use — the video is rendered into a uGUI `RawImage`, which needs no render pipeline and no input module. They now open cleanly on Built-in, URP and HDRP alike.
- [Demos] Fixed **the Unity RTSP and IP-camera samples printing a "Frame stall" warning the moment a stream starts**, on the first connect and on every reconnect after it. The watchdog compared its timeout against the time since the last decoded frame, which is infinite before the first frame ever arrives and, after a drop, still points at the last frame of the previous session — so it fired seconds before the camera could deliver anything. The reported stall is now capped at the age of the current stream, and a camera that genuinely never delivers is still reported after the same timeout.
- [Core] Fixed **the Avalonia `VideoView` reporting a black background even when one was set**. `GetBackgroundColor()` only read immutable solid-color brushes, so the mutable `SolidColorBrush` the control installs itself — and any colour a user assigns — always fell back to black, and that wrong colour fed the renderer as its clear colour. It now reads any solid-color brush, mutable or immutable.

## 2026.8.6

- [Core] Fixed **video editing and video preview breaking on macOS**. `VideoEditCoreX` failed every render that had a video track — any container, any codec — with `Internal data stream error`, while audio-only output still worked; and `VideoRendererBlock` froze the pipeline on the first frame in any application without a Cocoa UI running on its main thread, such as a console tool, a background service or a test host. GStreamer picks several elements automatically by rank rather than by name, and the Metal elements' ranks put them ahead of the software ones, so they were selected in places they were never meant for — including as the mixer inside every video-editing timeline. They are now registered for explicit use only, and the Metal video renderer is used only when you give it a view to draw into. `MetalVideoCompositor`, `MetalConvertScale`, `MetalVideoRendererSettings` and the other Metal wrappers are unaffected and still give you GPU rendering when you ask for it.
- [Core] Fixed **`VideoRendererBlock(pipeline, windowHandle)` ignoring the window handle** on Windows and macOS — only the Android and iOS paths read it, so elsewhere the renderer behaved as though no target window had been given and opened one of its own. On macOS this constructor now also defaults to the Metal renderer, which is the only one there that can draw into a handle you supply. Two consequences, both documented on the constructor: the handle must be an `NSView*` (not an `NSWindow*`), and your main thread must keep running a Cocoa run loop while the pipeline plays, because the Metal renderer attaches to the view on the main queue.

## 2026.8.5

- [Core] **The SDK no longer brings a pre-release package into your dependency graph.** SkiaSharp moves from `3.119.4-preview.1.1` to the stable `3.119.4`, and Avalonia from 12.0.3 to 12.0.5 — the two had to move together, because Avalonia itself switched to the stable SkiaSharp in 12.0.4 and holding it back would have kept a preview build of the WebAssembly native assets in the graph. Restoring a VisioForge package used to pull those preview builds transitively, with no opt-in on your side and no warning: they simply appeared in your lock file and in `dotnet list package --include-transitive`. That matters if you mirror packages into an internal feed that rejects pre-release versions, or if a policy scan flags them. Everything the SDK resolves is now a stable release. The SkiaSharp difference itself is confined to bundled native libraries (libexpat 2.7.5, libpng 1.6.58) — no API changed.
- [Core] **The Avalonia package no longer brings a nightly build of DialogHost.Avalonia with it.** `VisioForge.DotNet.Core.UI.Avalonia` uses MessageBox.Avalonia for `ShowMessageEx`, and MessageBox.Avalonia 12.0.0 — still its newest release — depends on `DialogHost.Avalonia 0.12.1-nightly.0.1`, so that nightly landed in the dependency graph of every application referencing our Avalonia package. DialogHost is now pinned to the stable 0.12.3. No API or behaviour change on our side.
- [Core] **`VisioForge.DotNet.Core.AI.Whisper` now requires .NET 8 or newer.** Seven builds are gone from the package — `net5.0`, `net5.0-windows`, `net6.0`, `net6.0-windows`, `net7.0`, `net7.0-windows` and `net7.0-windows10.0.19041.0` — so a WinUI or WPF head on one of those is affected as much as a plain console project. `net8.0`, `net9.0`, `net10.0` and their Windows, Android, iOS, macOS and Mac Catalyst variants are unchanged. Speech-to-text runs on Whisper.net, which now depends on `Microsoft.Extensions.AI.Abstractions` and through it on `System.Text.Json` 10, and `System.Text.Json` 10 states that it does not support and has not been tested on anything below .NET 8 — so those seven builds could only have shipped in a configuration Microsoft declares untested. .NET 5, 6 and 7 are themselves all out of support. If you reference this package from any .NET 5, 6 or 7 project, retarget it to `net8.0` or later — keeping the same platform suffix if it has one; no code changes are needed. Only this package is affected — every other VisioForge package keeps its full framework list, down to .NET Framework 4.6.1.
- [Core] **The macOS native package now ships the SRT and WebRTC GStreamer plugins.** Six plugins — `libgstsrt.dylib`, `libgstsrtp.dylib`, `libgstwebrtc.dylib`, `libgstrswebrtc.dylib`, `libgstwebrtcdsp.dylib` and `libgstwebrtchttp.dylib` — and the three libraries they load against (`libgstwebrtc-1.0.0.dylib`, `libgstwebrtcnice-1.0.0.dylib`, `libsrt.1.5.3.dylib`) were built and kept current but never packaged, so on macOS any pipeline using SRT or WebRTC failed to find its element, while identical code worked on Mac Catalyst, whose package has carried them all along. `VisioForge.CrossPlatform.Core.macOS.Adds` now ships the same 58 files as its Mac Catalyst counterpart.

## 2026.8.1

- [Demos] Fixed **several shipped samples referencing outdated packages**. The macOS and Mac Catalyst native packages in the demo projects were six months behind the published versions, a `net472` demo pinned a `System.Resources.Extensions` build meant for .NET 8 and newer, and the Virtual Camera and WebM redistributables were pinned to 2023-era releases. If you copied a demo project as a starting point, its package references were older than the SDK you installed.
- [Core] **Security:** updated `System.Security.Cryptography.Xml` to 10.0.10, closing five advisories that affected the version shipped before it — CVE-2026-47304, a bypass of XML encryption protections rated 8.1, and four denial-of-service issues rated 7.5. `System.Security.Cryptography.Pkcs` and `System.Formats.Asn1` moved to 10.0.10 with it. The SDK does not call these APIs itself; they are reached through WCF, which ONVIF device communication uses. No action is needed on your side beyond taking the new package — but a security scan run against the previous release will have flagged it.
- [Core] Fixed **a random process crash while GStreamer objects were being released**. On any platform, an application could die with an access violation (`0xC0000005` on Windows, `SIGSEGV` on macOS) on a background thread, with no error, no exception and nothing in the log to connect it to what the application had been doing — the crash landed long after the code that caused it. The SDK now checks that a native object is still alive before releasing it, and when it is not, writes one line naming the type instead of taking the process down.
- [Core] **API change:** `VisioForge.GStreamer.API.CustomAPI.g_signal_connect`, `g_signal_connect_data` and `g_signal_handler_disconnect` now use `UIntPtr` for the GLib signal handler id instead of `uint`. The id is a `gulong`, which is 64-bit on macOS, Linux, iOS and Android, so the previous declaration truncated it. These are low-level interop helpers; if you call them directly, change the variable holding the handler id to `UIntPtr`.
- [Media Blocks SDK .Net] **The SDK no longer takes ownership of the elements a decoder builds while playing a file.** Playing any file made the SDK hold a native reference to every element inside `uridecodebin` — parsers, demuxers, queues, several hundred per playback — and those references were given back only later, on a background thread, so the elements stayed alive past the pipeline that owned them. This is the same ownership mistake behind the render-time crash fixed below, on the playback path; measured on a four-class test run, the number of such references dropped by 78%. Affects every engine that plays or captures through a file or URL source.
- [Core] Fixed **an error or warning on the pipeline bus tearing down the bus handler**. In `VideoEditCoreX` and `SimplePlayerCoreX`, an error message that carried no source element raised a `NullReferenceException` inside the handler, so that message and every message after it was lost — including the error you needed to see. A state-change message with no source could also be mistaken for one from the pipeline itself while the pipeline was being torn down.
- [Video Edit SDK .Net] Fixed **a process crash after rendering with `VideoEditCoreX`**. An application that rendered several timelines in one session could die with an access violation on a background thread, typically long after the render had finished and the objects involved had been released. Rendering to WMV made it most likely, but the underlying cause affected any render. Applications that create and destroy `VideoEditCoreX` repeatedly — batch converters, render services — were the most exposed.
- [Core] Fixed **`Debug_Mode` writing an empty log file**. With debug logging enabled, the log was buffered and never flushed when the engine was disposed, so a short session produced an empty file and a longer one lost everything after the last automatic flush — exactly the log you are asked for when reporting a problem. The file also stayed locked for the life of the process, so it could not be read or deleted. Affects `VideoCaptureCoreX`, `MediaPlayerCoreX`, `SimplePlayerCoreX`, `VideoEditCoreX` and `MediaBlocksPipeline`.
- [Core] Fixed **the same empty log file when the engine was disposed with `await using`**. The fix above covered the synchronous `Dispose()` only, so `MediaPlayerCoreX` and `SimplePlayerCoreX` released asynchronously — the form most applications use — still produced an empty or truncated log and still held the file open. `SimplePlayerCoreX.DisposeAsync` is also safe to call twice now, and on all three engines a failure during teardown no longer swallows the log, which is precisely the case you need it for.
- [Media Blocks SDK .Net] Fixed **open-vocabulary detection exhausting memory on Apple hardware**. `OpenVocabularyDetectorBlock` and `ObjectAnalyticsBlock` with an open-vocabulary detector could consume every gigabyte the machine had and bring it down rather than produce a detection. ONNX Runtime cannot map OWLv2 or Grounding DINO onto CoreML in one piece — it splits them into 126 and 255 separately compiled models — so `Provider = Auto` now selects the CPU for these two model families on Apple hardware and leaves every other AI block unchanged. Setting `Provider` to `CoreML` by name still does what you ask; it is not recommended for these models. On the CPU provider the memory retained after a detector is disposed also drops by about 2.4 GB on the same models, with no change to inference time.
- [Media Blocks SDK .Net] Fixed **a crash while tearing down `ObjectAnalyticsBlock` with an open-vocabulary detector**. Disposing the block while a frame was still being analysed could free the inference session underneath the analysis and abort the process.
- [Core] Fixed **Media Foundation H.264 and H.265 encoder settings being silently ignored**. On a machine whose Media Foundation encoder does not advertise a given control - the property set differs by GPU, driver and machine - the SDK wrote the value anyway. Nothing threw, the call reported success, and the encoder quietly kept its default, so the same code produced different output on different machines with no way to tell. Settings the encoder cannot accept are now skipped, and each one is named in a warning. This covers encoders you build yourself (`HEVCEncoderBlock`, `H264EncoderBlock`, `CreateBlock()`) and the AMD MA35D encoders and decoders. Encoding profiles - `MP4Output` and the other render outputs - are not covered yet, so the original symptom can still occur there.
- [Core] Fixed **an instability while enumerating Decklink capture cards and outputs**. Plugging a card in or out, or listing devices from more than one place at once, could leave the SDK using a device object it had already released — harmless in the log on a good day, a crash on a bad one.
- [Core] Fixed **WASAPI2 audio capture breaking up under load and never recovering**. From 2026.3.7, audio captured through a WASAPI2 device could develop artifacts that got worse over time and only cleared when the pipeline was restarted; the log filled with `Found N frames gap` warnings. The bundled GStreamer runtime was requesting a capture buffer of roughly 20 ms instead of the 200 ms it used to, so any brief stall lost audio at the driver. The buffer is back to its previous size on capture and playback alike, and the `LowLatency` setting again means what it says. Affects Windows x86, x64 and ARM64.
- [Core] Added `BufferTime` and `LatencyTime` to `WASAPI2AudioCaptureDeviceSourceSettings`, `WASAPIAudioCaptureDeviceSourceSettings`, `LoopbackAudioCaptureDeviceSourceSettings`, `WASAPIRendererSettings` and `WASAPI2RendererSettings`. They control how much audio the device buffers — raise `BufferTime` on machines that see brief CPU spikes, lower it when you need latency. Defaults are 200 ms and 10 ms, matching previous behaviour; set either to `TimeSpan.Zero` to leave the underlying element untouched.
- [Core] An audio renderer whose output plugin is missing from the deployment now reports a clear error instead of throwing a `NullReferenceException` out of `StartAsync`.
- [Core] Fixed **the built-in HLS/DASH HTTP server never starting on Windows unless the application ran as administrator**. With `Custom_HTTP_Server_Enabled` set, the sink reported no error and the pipeline ran, but nothing was ever served — the server binds `http://*:<port>/`, which Windows refuses to a process without an elevated token unless a URL reservation exists, and the failure went no further than one line in the log. The server now falls back to the loopback prefixes — both `http://localhost:<port>/` and `http://127.0.0.1:<port>/`, so a player on the same machine works whichever of the two it is given — and the log names the `netsh http add urlacl` command to run once as administrator to reach the server from other devices. Elevated applications and machines that already have the reservation are unaffected, as are macOS and Linux.
- [Core] Fixed **an application that never exits after `DestroySDK()`**. The SDK runs the GStreamer main loop on a foreground thread, and `DestroySDK()` could return having failed to stop it: the request to stop was dropped whenever it arrived in the moment between that thread being created and it reaching the loop, and nothing checked afterwards. The process then stayed alive with no window, no error and nothing running — visible as an application that closes but keeps a process in the task list, or a console tool that never returns to the prompt. `DestroySDK()` now waits for the loop thread to actually finish before returning, and reports it in the log if it does not.
- [Core] Fixed **the WASAPI2 audio renderer going silent whenever `Volume` was below 1.0**. The value was passed to the renderer as a whole number, so anything between 0.0 and 1.0 was rounded down to zero — setting `Volume = 0.5` produced silence rather than half volume. Only `Volume = 1.0` behaved as expected.

## 2026.7.27

- [Media Blocks SDK .Net] Fixed **a stopped pipeline not resuming when it was started again** — after `StopAsync()`, a `StartAsync()` on the same `MediaBlocksPipeline` with the same blocks returned `true` and then did nothing: a recorder wrote no bytes, a preview stayed black, and no error was reported. Stopping now keeps the blocks and the connections you made, and starting rebuilds the pipeline from them, so the same pipeline instance can be recorded, stopped and recorded again. You no longer have to recreate the pipeline and every block between runs (doing so still works). A sink filename changed between runs — `SetFilenameOrURL` — is picked up by the next run.
- [Media Blocks SDK .Net] Fixed **a group of blocks that stayed silent after a pipeline was restarted**, each in the same way: the block reported a successful start and then produced nothing. OCR (`OcrBlock`) and Data Matrix (`DataMatrixDecoderBlock`) stopped raising their detection events; `UniversalDemuxBlock`, `UniversalAutoDemuxerBlock` and `UniversalDecoderBlock` delivered no data on the second run (the demuxer could also throw from a streaming thread); `StreamSourceBlock` came up over a closed stream, and now also rewinds a seekable one so a restarted source plays from the beginning; `PreEventRecordingBlock` dropped every frame and then threw from `TriggerRecording()`; both squeezeback blocks failed to rebuild. The bridge blocks silently lost the `OnEOS` handler you had attached at the first stop.
- [Media Blocks SDK .Net] `MediaBlocksPipeline.ClearBlocks()` now **disposes the blocks it removes**. Removing a block hands it back to nobody, and the stop path no longer disposes it, so keeping it alive leaked whatever it held — an inference session, an encoder, a device handle. Do not call `ClearBlocks()` for blocks you mean to reuse; a stopped pipeline can simply be started again with the same blocks.
- [Media Blocks SDK .Net] A stop no longer closes a file opened by `StreamSourceBlock(filename)` for good: the file is released on every stop, as before, and reopened when the pipeline is started again. Stopping and then deleting, overwriting or re-recording to the same path keeps working. A stream you passed in yourself is still never closed by the block — it is yours.
- [Media Blocks SDK .Net] Fixed **a crash on Android when the video surface was recreated after the pipeline was stopped** — rotating the device or returning from the background after `StopAsync()` dereferenced the pipeline the stop had already released.
- [Media Blocks SDK .Net] Fixed **an intermittent crash while a pipeline was being stopped or restarted**. Under a restart-heavy load the process aborted outright about one run in three, with no exception to catch — a bus message could still be in the middle of being handled when the stop released the pipeline underneath it. Stopping now waits for an in-flight bus message to finish before releasing anything, and gives up after two seconds rather than hanging.
- [Media Blocks SDK .Net] Fixed a family of **latent memory-corruption defects around teardown and restart**, in sample grabbers, renderers, sources, decoders, bridge blocks, effects and device enumeration. Nothing failed visibly: GStreamer's own type checks turned the affected calls into no-ops, so the symptom was warnings in the log rather than a crash — but the same code was one timing change away from a hard `AccessViolationException`. Restarting a pipeline produces far fewer `GST_IS_ELEMENT` / `GST_IS_PAD` warnings; the remaining ones are being worked through.
- [Media Blocks SDK .Net] Fixed **removing a video or audio effect at runtime leaving the pipeline holding a released element**. Every effect filter — 51 of the video ones and 15 of the audio ones — released its GStreamer element while still pointing its own input and output at it, so removing an effect, or clearing them all, worked on the surface while the next teardown reached through a dangling reference. As with the teardown defects above, GStreamer's type checks kept it to log warnings instead of a crash, but the memory was already gone.
- [Media Blocks SDK .Net] Fixed **`UniversalTransformBlock` releasing its own pads on the first frame**. The transform callback released the pads the block had published, so every later probe, unlink and teardown on that block used a dead reference. `CustomMediaBlock` did the same to the pads its wrapped element owns, including the pad handed to it when a demuxer creates one.
- [Core] Fixed **a reference-counting error that corrupted GStreamer's encoder registry on Windows**. Enumerating the available hardware encoders released a reference the SDK never held, on every encoder registered on the machine — audio ones included. GStreamer detected it, logged a warning per encoder and recovered, so nothing failed visibly, but the accounting was left inconsistent and a concurrent registry change could have turned that into a crash.
- [Media Blocks SDK .Net] Fixed **Vorbis audio bitrate settings being ignored**. `VorbisEncoderSettings.Bitrate`, `MaxBitrate` and `MinBitrate` are documented as "-1 to disable", which is also their default, and that default was passed to the encoder as an out-of-range value. The encoder rejected the whole assignment and fell back to its own defaults, so a bitrate you set took effect only if you had also set the other two. Encoding profiles built from these settings carried the same invalid value.
- [Media Blocks SDK .Net] Fixed **the pipeline-graph debug helpers misbehaving once playback had finished**. `Debug_GetPipeline()` and `Debug_SavePipeline()` called after a stop — including the stop that happens on its own when a file reaches the end — wrote no graph and logged a GStreamer warning instead. `Debug_GetPipeline()` now returns an empty string, as documented, and `Debug_SavePipeline()` does nothing. The same applies to `VideoCaptureCoreX.Debug_SavePipeline()`.
- [Video Capture SDK .Net] Fixed **`Video_Source_GetResolutionAndFrameRate` and `Audio_Source_GetInfo` damaging a running capture**. Both released the source block's own pad, so calling either of these read-only queries while capturing left the source unusable.
- [Video Capture SDK .Net] Fixed **the second recording of a separate-capture output silently producing no file**. With an output registered and the engine running, `StartCaptureAsync(index, filename)` worked the first time and every later call returned `true` while writing nothing — the record button worked exactly once per application run. All subsequent recordings now write to the file passed to `StartCaptureAsync`, with the preview left untouched, which is what the API is for.

## 2026.7.26

- [Media Blocks SDK .Net] Added **`AndroidUVCSourceBlock`** — capture from a **USB (UVC) camera connected to an Android device over OTG**, such as a webcam or a capture dongle. These cameras are invisible to the regular `SystemVideoSourceBlock`, because Android only exposes them through Camera2 on devices whose vendor ships the External Camera HAL (Samsung, among others, does not). Connected cameras are listed with `AndroidUVCDevices.FindCameras()`, access is requested with `AndroidUVCDevices.RequestPermissionAsync()`, and the requested resolution and frame rate are matched against the modes the camera advertises. Your app must declare **and be granted `android.permission.CAMERA`** — Android refuses to hand a USB video device to an app without it, even though the Android camera API is not used. Unplugging the camera ends the stream, so the pipeline reports end-of-stream rather than stalling silently. Requires **Android 9 (API 28) or later**. Note that a camera enumerating at USB 2.0 speed offers markedly lower frame rates than on a desktop: a Logitech BRIO, for example, tops out at 1080p30 (MJPEG) with no 4K modes available at all.
- [Video Capture SDK .Net] **USB (UVC) cameras on Android can now be used with `VideoCaptureCoreX`** — assign an `AndroidUVCSourceSettings` to `Video_Source` and the camera works like any other source, so recording to MP4, network streaming, video effects and snapshots are all available. New `AndroidUVCDevices.GetModes()` lists the resolutions, frame rates and formats you can actually pick from — formats the SDK cannot stream are left out — so you can offer the real choices instead of requesting a mode and silently getting the nearest one, and `AndroidUVCSourceSettings.Format` asks for one of them. Two things to know: an unplugged camera is reported through `OnError`, not `OnStop` - and only once the stream has been silent for a few seconds, so handle Android's `ACTION_USB_DEVICE_DETACHED` broadcast as well if your app needs to react the moment the cable comes out; and a camera with a built-in microphone also registers as a USB audio input that Android prefers for recording but that cannot be captured while the camera is streaming, so such a recording is video-only. Live capture should also set the new `VideoCaptureCoreX.Video_Output_IsSync = false`, which stops the bridge feeding an output pipeline from waiting on the clock - left synced it can fill its queue and stall the preview along with it. `Audio_Output_IsSync` is the matching switch for the audio branch, so a capture with audio can hand both branches over on the same terms.
- [Demos] Added a **USB Camera** Android sample showing live preview from a UVC camera attached over OTG, including the device and permission handling, in both a Media Blocks SDK and a Video Capture SDK version — the latter also records to MP4.

## 2026.7.24

- [Video Capture SDK .Net] Fixed **Picture-in-Picture crashing on .NET 9 and .NET 10** — `VideoCaptureCore` terminated with an unrecoverable `ExecutionEngineException` at `Start`/`StartAsync` as soon as a PiP source was added (the same code worked on .NET 8). Adding a PiP overlay now works on all supported .NET versions.
- [Video Edit SDK .Net] Fixed the legacy FFMPEG output crashing at start on .NET 9 and .NET 10 with the same `ExecutionEngineException`; it now works as it did on .NET 8.
- [Media Blocks SDK .Net] [Video Capture SDK .Net] Fixed **video missing or corrupted when streaming MPEG-TS over SRT** (`SRTMPEGTSSinkBlock`, `SRTOutput`). The MPEG-TS muxer now emits a full 1316-byte payload per buffer instead of one transport packet at a time, so SRT sends whole datagrams rather than seven times as many undersized ones. Receivers such as MediaMTX, ffmpeg or OBS no longer see an audio-only or truncated stream. The UDP, multi-UDP and RIST MPEG-TS outputs get the same alignment.
- [Media Blocks SDK .Net] [Video Capture SDK .Net] Fixed **corrupted video from the Apple (iOS / macOS / Mac Catalyst) H.264 hardware encoder**. `AppleMediaH264EncoderSettings.AllowFrameReordering` was enabled by default; the resulting B-frames left a large share of the encoded frames with a presentation timestamp earlier than their own decode timestamp, so MPEG-TS outputs (SRT, UDP, RIST) and MP4/MOV recordings played back torn or undecodable in MediaMTX, ffmpeg and VLC. RTMP/FLV happened to tolerate it, which is why streaming from iOS looked broken over SRT but fine over RTMP. The property now defaults to `false`; set it back to `true` only for offline encoding where you can verify the resulting timestamps.
- [Media Blocks SDK .Net] [Video Capture SDK .Net] Fixed **SRT and RIST output failing to start on macOS and Mac Catalyst** when the Apple hardware H.264 encoder was used: the stream parser those outputs need to feed the MPEG-TS muxer was omitted on those platforms.
- [Media Blocks SDK .Net] [Video Capture SDK .Net] [Video Edit SDK .Net] Fixed **MPEG-TS output producing an empty file** when AAC audio was encoded with a software encoder (`voaacenc`, used on macOS, Linux and iOS). The MPEG-TS muxer only accepts framed AAC, which those encoders do not advertise, so the audio never linked and the muxer waited on it instead of writing - the recording ended as a 0-byte `.ts`. Affects `MPEGTSSinkBlock`/`MPEGTSOutput` and the SRT, UDP and RIST outputs built on them.
- [Media Blocks SDK .Net] Fixed **RTSP playback failing with "Failed to link RTSP pad: WasLinked"** in `UniversalSourceBlockV2`. When the source announced a pad it had already handed over - on reconnect, or when a server re-announced a stream - the block tried to link it a second time and reported the result as an error, ending the session.
- [Media Blocks SDK .Net] Fixed **DASH output never starting** (`DASHSinkBlock`): the sink requested its input pads without a name, which `dashsink` rejects because it takes the stream index from the pad name. No manifest or segments were written and the pipeline hung on start instead of reporting the failure.
- [Media Blocks SDK .Net] Fixed **text overlays rendering as empty boxes (▯▯▯) on iOS, Android and macOS** — the SDK now sets up font resolution at startup, so `TextOverlayBlock`, subtitle overlays and the trial watermark draw real glyphs instead of tofu. Fonts your app bundles are picked up automatically, and on iOS the SDK carries a fallback font so text renders even in an app that bundles none.

## 2026.7.22

- [Video Capture SDK .Net] Fixed RTSP / IP camera **login and password being URL-encoded**, which broke authentication for credentials containing special characters such as `&`, `@`, `%`, `?` or spaces (e.g. a password `password&@%!?End` was sent to the camera as `password%26%40%25!%3fEnd`). Credentials are now used verbatim. Applies to both the `RTSPSourceSettings` (X engine) and `IPCameraSourceSettings` (VideoCaptureCore) sources. If you previously worked around this by storing the pre-encoded value on the device, revert it to the real password after upgrading.
- [Core] MAUI apps now build cleanly for Android 16: the bundled HarfBuzzSharp native library is updated to a 16 KB page-size-aligned build, removing the `XA0141` ("Android 16 will require 16 KB page sizes") warning on Android app builds.

## 2026.7.21

- [Media Blocks SDK .Net] Added **AMD Alveo MA35D** hardware acceleration (via the AMD AMA Video SDK) on Linux: H.264, HEVC and AV1 encoders (`AMAH264EncoderSettings` / `AMAHEVCEncoderSettings` / `AMAAV1EncoderSettings`), matching decoders, and an `AMAScalerBlock`. A specific MA35D card is selected with the `Device` property (`-1` auto-selects), so you can pin encoding/decoding to the accelerator rather than the host GPU. Requires the AMD AMA Video SDK (kernel driver + GStreamer plugins) to be installed.

## 2026.7.10

- [Media Blocks SDK .Net] Added **`AudioEventDetectorBlock`** — on-device audio event detection that recognizes real-world sounds (siren, dog bark, glass break, alarm, music, speech, and hundreds more from the 521-class AudioSet ontology) in live or file audio using a YAMNet ONNX classifier. Audio passes through unchanged; detections are raised via `OnAudioEvent` with a label, confidence, and start/end time, using score smoothing and hysteresis so one continuous sound is a single event rather than a burst of duplicates. Optional class allowlist and a live top-K scores event. Works in `VideoCaptureCoreX`/`MediaPlayerCoreX` via `Audio_Processing_AddBlock`.
- [Demos] Added an **Audio Event Detection** WPF sample (Media Blocks SDK): open a file or select a microphone, live event log with label/confidence/time, class-filter box, and threshold slider.

## 2026.7.9

- [Core] Video stream info now reports the pixel aspect ratio (`VideoStreamInfo.ParNumerator`/`ParDenominator`) when the negotiated caps carry it, so anamorphic sources can be displayed at the correct proportions.
- [Media Blocks SDK .Net] Fixed pipeline restart after a failed start: blocks no longer report themselves as built when their Build fails, so a retried start rebuilds them instead of running a half-built pipeline.
- [Media Blocks SDK .Net] File output blocks (M4A/MP4/MKV/AVI) now fail cleanly instead of throwing an unhandled exception when configured with an unsupported encoder, so the pipeline reports a normal start error you can handle.
- [Core] Fixed stale frame dimensions after a mid-stream resolution change in video frame grabbing: frame callbacks and snapshots kept reporting the old width/height/stride, so the frame data could be mis-read at the new size.
- [Media Blocks SDK .Net] Added AI auto-reframe (`AutoReframeBlock`): converts landscape footage into vertical 9:16 (or 1:1, 4:5) video that dynamically crops around the detected subject with smooth, jitter-free tracking — ideal for Shorts/Reels/TikTok.
- [Demos] Added an **Auto Reframe** WPF sample (Media Blocks SDK): open a landscape file, follow the subject in a side-by-side original/reframed preview (9:16, 1:1, or 4:5), configure smoothing, dead zone, detection interval, and the followed class, and optionally export the reframed output to MP4.
- [Media Blocks SDK .Net] Added on-device **speaker diarization** ("who spoke when"): the new `SpeakerDiarizationBlock` analyses the audio as it plays and, once the recording has finished, reports every speech turn with the speaker who made it. Diarization is inherently offline — a voice heard at minute 1 can only be matched to the same voice at minute 40 once the whole recording has been heard — so the turns are raised at end-of-stream (`OnSpeakerSegment`, or `GetTimeline()` in one piece); check `IsTimelineComplete` before reading them. Pair it with speech-to-text via `DiarizedTranscriptBuilder` for a speaker-labeled transcript. Works with `MediaPlayerCoreX`/`VideoCaptureCoreX` and manual Media Blocks pipelines. Set `NumSpeakers` when you know the count, or leave it at `-1` and tune `ClusterThreshold` (a cosine distance — smaller yields more speakers).
- [Media Blocks SDK .Net] Speaker diarization is **multilingual**: alongside the default English WeSpeaker voiceprint model you can select the Apache-2.0 3D-Speaker ERes2NetV2 embedding (`SpeakerDiarizationSettings.EmbeddingModel = ERes2NetV2Multilingual`) for far better speaker separation on non-English or mixed-language audio. The feature front-end adapts to the chosen model automatically, so no other code changes are needed when you switch.
- [Media Blocks SDK .Net] Fixed degraded **speech-to-text accuracy on any source that is not already 16 kHz mono** — that is, on essentially every camera, capture card, media file and RTSP stream. The audio front-end decimated to the 16 kHz the model needs without band-limiting first, so everything above 8 kHz folded back into the speech band and corrupted the features both Whisper and the voice-activity detector consume. The audio is now low-pass filtered before the rate conversion.
- [Media Blocks SDK .Net][Video Capture SDK .Net] Added **PTZ auto-tracking** — an ONVIF PTZ camera can now automatically follow a detected object. `PTZAutoTrackingController` turns detections from `ObjectAnalyticsBlock` (or `YOLOObjectDetectorBlock`) into continuous pan/tilt/zoom commands with a configurable dead zone, sticky target tracking, a lost-target timeout (with optional return-to-preset), and command rate limiting. Target selection by largest object, first detected, tracker ID, or class label. Includes the new "PTZ Auto Tracking" WPF demo.
- [Media Blocks SDK .Net][Video Capture SDK .Net] PTZ auto-tracking can now run an **idle preset patrol** — when no target reappears for a configurable delay, the camera cycles through a list of ONVIF presets (with a per-preset dwell time) until a new target is acquired, which immediately aborts the patrol and resumes tracking.
- [Demos] Added a **PTZ Auto Tracking** WPF sample for the Media Blocks SDK — the same ONVIF auto-tracking built on a low-level `MediaBlocksPipeline` (RTSP source → `ObjectAnalyticsBlock` → video renderer, with `PTZAutoTrackingController` driving the camera).
- [Media Blocks SDK .Net] Added **`VideoStabilizationBlock`** — real-time video stabilization that removes camera shake by estimating global inter-frame motion (translation and rotation) with OpenCV optical flow, smoothing the camera trajectory, and warping each frame back onto the smoothed path. Configurable smoothing radius, crop/zoom ratio, and per-frame correction limits; all tunable live. Requires the OpenCV redistributable (Windows).
- [Media Blocks SDK .Net][Video Capture SDK .Net][Media Player SDK .Net] `VideoStabilizationBlock` can now be used with the X engines: pass it to `Video_Processing_AddBlock()` on `VideoCaptureCoreX` or `MediaPlayerCoreX` to stabilize a live camera or a playback stream, with live retuning through `ApplySettings()`.
- [Demos] Added a **Video Stabilization** WPF sample (Media Blocks SDK): open a file, preview stabilized playback, record the stabilized result to MP4, and adjust the smoothing radius and crop ratio live.
- [Demos] Added a **Video Stabilization Capture X** WPF sample (Video Capture SDK X): stabilize a live camera with `VideoCaptureCoreX` and tune the stabilizer while the capture runs.
- [Demos] Added a **Video Stabilization Camera** WPF sample (Media Blocks SDK): stabilize a live camera with a hand-built `MediaBlocksPipeline` (camera source → stabilizer → renderer), with live tuning.

## 2026.7.8

- [Video Edit SDK .Net] Fixed a native process crash (fail-fast) when rendering FLAC output from a timeline with more than one clip (or a gap before the audio clip) in `VideoEditCoreX`.
- [Video Capture SDK .Net] Fixed empty WMA audio-only recordings from the legacy `VideoCaptureCore` engine: the default WMA profile was variable-bitrate (VBR), which the WM ASF Writer cannot produce from a live capture source, so the file contained only an ASF header with no audio data. The default is now an equivalent constant-bitrate WMA profile.
- [Core][Video Capture SDK .Net][Media Blocks SDK .Net] Fixed a **32-bit (x86)** ABI bug that mis-sized the native `GMutex` field (as a pointer) in the GStreamer object layout, shifting every element's field offsets by 8 bytes on x86. This made the element pad list read as empty and caused a NullReferenceException crash whenever the video/audio sample grabber, snapshots, or a frame-processing block was used on 32-bit. Frame grabbing, snapshots, and per-frame processing now work correctly on x86 (x64 unaffected).

## 2026.7.6

- [Media Blocks SDK .Net] Fixed an intermittent "Unable to create sample grabber element" failure that could occur when starting several camera pipelines (e.g. multiple RTSP cameras) at the same time. Managed element construction is now thread-safe.
- [Media Blocks SDK .Net] Fixed a NullReferenceException crash in the video sample grabber (and related processing elements) that could occur on the streaming thread when a frame buffer was momentarily unavailable.

## 2026.7.3

- [Media Blocks SDK .Net] Added **`PIIRedactionBlock`** — automatic on-video redaction of personally identifiable information: faces (YuNet), vehicle license plates (FastALPR detector), and on-screen text (PP-OCRv5 detection + recognition — recognition filters out the detector's non-text false positives — with an optional regex filter that redacts only matching text such as e-mails or phone numbers). Redaction styles: Gaussian blur, pixelate, and solid fill. Each category can be toggled live; regions are padded and held between detection cycles so PII stays covered through motion and detector flicker. Works in `VideoCaptureCoreX`/`MediaPlayerCoreX` via `Video_Processing_AddBlock`.
- [Demos] Added a **PII Redaction** WPF sample (Media Blocks SDK): webcam, file, or RTSP source with live category/style switching.
- [Demos] Added **Player PII Redaction X** and **Capture PII Redaction X** samples (WPF and MAUI) — live face/plate/text redaction on `MediaPlayerCoreX` (file playback) and `VideoCaptureCoreX` (camera) via `Video_Processing_AddBlock`.

## 2026.7.2

- [Media Blocks SDK .Net] Added an **open-vocabulary object-detection** block (`OpenVocabularyDetectorBlock`) that detects objects from free-text prompts (OWLv2 / Grounding DINO) instead of a fixed class list, with prompts swappable at runtime. It can also drive `ObjectAnalyticsBlock` as a detector for tripwire / zone analytics.
- [Media Blocks SDK .Net] Added a **Florence-2 vision-language** block (`VLMBlock`) for frame captioning, OCR, phrase grounding, and object detection.
- [Media Blocks SDK .Net] Added a **CLIP video-embedding** block (`VideoEmbeddingBlock`) with a semantic frame-search index, for natural-language search over indexed video.
- [Media Blocks SDK .Net] `VideoEmbeddingBlock` can index a file at full decode speed with no dropped samples via `VideoEmbeddingSettings.BackpressureNoDrop` (backpressures the pipeline instead of dropping frames when the encoder is busy).
- [Media Blocks SDK .Net] `OpenVocabularyDetectorBlock` confidence and IoU thresholds can now be adjusted at runtime (`SetConfidenceThreshold` / `SetIoUThreshold`); the new value takes effect on the next frame without rebuilding the pipeline.
- [Demos] Added three WPF samples: **Open Vocabulary Detection**, **VLM Captioning**, and **Semantic Video Search**.
- [Media Player SDK .Net] Added `MediaPlayerCoreX.Video_Renderer_IsSync` — set it to `false` to run the video renderer without clock synchronization so a file is processed at full decode speed (for offline AI indexing / analysis) instead of in real time; `null` (default) keeps the automatic behavior.
- [Demos] Added **X-engine** versions of the new AI samples (WPF and MAUI): **Open Vocabulary Detection** and **VLM Captioning** for both `VideoCaptureCoreX` (camera) and `MediaPlayerCoreX` (file), plus **Semantic Video Search** for `MediaPlayerCoreX`. Each inserts the AI block through the `Video_Processing_AddBlock` API.

## 2026.6.30

- [Demos] Added **Face Recognition** and **OCR** demos for the X engines, in both WPF and MAUI: **Player Face Recognition X** and **Player OCR X** (`MediaPlayerCoreX`), plus **Capture Face Recognition X** and **Capture OCR X** (`VideoCaptureCoreX`). Each inserts the AI block through the `Video_Processing_AddBlock` API — the face demos enroll people from photos and label them on the video; the OCR demos draw and log recognized text.
- [Demos] Added a **Capture Live Subtitles X** WPF sample (`VideoCaptureCoreX` with on-device Whisper speech-to-text subtitles).

## 2026.6.29

- [Media Blocks SDK .Net] Speech-to-text (`SpeechToTextBlock`) now always transcribes the full input losslessly — the source is paced to Whisper so no audio is ever dropped. The previous live drop-buffer mode and the `SpeechToTextSettings.BackpressureWhenBusy` option were removed (the lossless behavior is now the only mode).

## 2026.6.27

- [Video Capture SDK .Net] `VideoCaptureCoreX` can now insert AI processing blocks — object detection, OCR, face recognition, license-plate recognition, object analytics, background removal, generic ONNX inference, and Whisper speech-to-text — directly into the capture pipeline through `Video_Processing_AddBlock` / `Audio_Processing_AddBlock`, with on-frame overlays and detection events.
- [Media Player SDK .Net] `MediaPlayerCoreX` gains the same `Video_Processing_AddBlock` / `Audio_Processing_AddBlock` API to run AI processing (object detection, OCR, speech-to-text, and more) on played files and streams.
- [Demos] Added a **Player AI Processing** demo (WPF): plays a file in `MediaPlayerCoreX` with a YOLO object detector or a Whisper speech-to-text block inserted through the new processing-block API.
- [Demos] Added four **MAUI** AI demos (Android/iOS/Mac Catalyst/Windows) for the new X-engine processing-block API: **Player Object Detection X** and **Player Live Subtitles X** (`MediaPlayerCoreX`), plus **Capture Object Detection X** and **Capture Live Subtitles X** (`VideoCaptureCoreX`).
- [Media Blocks SDK .Net] Fixed an `AccessViolationException` ("Attempted to read or write protected memory") that could crash the application when using text overlays (`OverlayManagerBlock` / `OverlayManagerText`) — most reliably reproduced by adding a text overlay right after `StartAsync` and then stopping. The font-enumeration path freed Pango-owned font objects it did not own, corrupting memory during a later garbage collection or pipeline shutdown.
- [Media Blocks SDK .Net] Fixed a related intermittent fatal crash ("Attempt to execute managed code after the .NET runtime thread state has been destroyed") that could abort the process during text overlay or font enumeration when a background media thread was recycled, or at application exit. The available-fonts / monospace-detection path no longer attaches a managed callback to Pango's internal font map.

## 2026.6.24

- [Media Blocks SDK .Net] Fixed a rare crash during pipeline shutdown or garbage collection in applications with many active GStreamer objects, such as multi-camera RTSP capture with sample grabbers, bridges, and file outputs.
- [Media Blocks SDK .Net] `FaceRecognitionBlock` — enrolling a face from a photo that carries an EXIF orientation tag (typical of phone camera shots) now works; the image is rotated upright before detection instead of reporting "no face found".
- [Demos] Added a **Face Recognition Uno** demo (Uno Platform): live camera 1:N face recognition with on-frame name/box overlay, photo enrollment, and switchable SFace / AuraFace embedding models. Android-focused.
- [Demos] The Face Recognition demos (WPF and CLI) now let you pick the embedding model: **SFace (128-D)** or **AuraFace (512-D, ArcFace family, Apache-2.0)** — a higher-accuracy, commercially licensed 512-D embedder downloaded on demand. The CLI adds an `--embedding sface|auraface` switch.
- [Demos] Face Recognition WPF demo: switching the embedding model now automatically rebuilds the gallery from the enrolled photos, so changing models no longer makes every face read as **Unknown** (embeddings from different models are not comparable).
- [Demos] Face Recognition MAUI demo: added the same SFace/AuraFace embedder selection and automatic gallery rebuild, plus a **video-file source** with a seek bar and a real-time / max-speed playback toggle (in addition to the live camera).

## 2026.6.23

- [Media Blocks SDK .Net] Unity samples now use Unity's default Enter Play Mode behavior (Domain + Scene Reload); disabling Domain Reload is no longer required. The SDK survives the Editor's Play/Stop and script-recompile domain reloads via a built-in reload guard.

## 2026.6.21

- [Video Capture SDK X .Net] Added **Android audio playback capture** support to `VideoCaptureCoreX` — assign `AndroidAudioPlaybackCaptureSourceSettings` to `Audio_Source` to record the audio played by **other apps** (system AudioPlaybackCapture API, Android 10 / API 29+, on top of a `MediaProjection` token) straight to a file. Includes a new native Android "Audio Playback Capture" demo built on `VideoCaptureCoreX` that records another app's audio to an `.m4a` file. Only apps that allow playback capture (usage MEDIA/GAME/UNKNOWN and not opted out) can be captured.

## 2026.6.20

- [Media Blocks SDK .Net] `VideoSampleGrabberBlock` now works as a terminal block: if you leave its output unconnected (e.g. you only poll `GetLastFrameAsSKBitmap()` or handle `OnVideoFrameBuffer`), the block self-terminates so frames keep flowing. Previously a grabber with an unconnected output stalled after the first frame, so every snapshot returned the same initial image.
- [Media Blocks SDK .Net] `VideoSampleGrabberBlock.GetLastFrameAsSKBitmap()` and `GetLastFrameAsBitmap()` now return `null` when no frame has been captured yet, instead of throwing a `NullReferenceException`.
- [Media Blocks SDK .Net] Setting `VideoSampleGrabberBlock.SaveLastFrame = false` now discards the cached frame, so toggling it back on later never hands back a stale frame captured during an earlier session.
- [Media Blocks SDK .Net] `KLVParser` now reads MISB KLV packets larger than 127 bytes. Standard MISB ST 0601 metadata uses BER long-form lengths, and the parser previously threw on the common 1- and 2-byte long-form lengths — so real-world packets failed to parse. All BER length forms are now decoded correctly.

## 2026.6.19

- [Media Blocks SDK .Net] Added **Android audio playback capture** — the new `AndroidAudioPlaybackCaptureSourceBlock` records the audio played by **other apps** using the system AudioPlaybackCapture API (Android 10 / API 29+) on top of a `MediaProjection` token, with a configurable format and usage filter (`AndroidAudioPlaybackCaptureSourceSettings`). Includes a new native Android "Audio Playback Capture" demo that records another app's audio to an `.m4a` file. Only apps that allow playback capture (usage MEDIA/GAME/UNKNOWN and not opted out) can be captured.
- [Media Blocks SDK .Net] Speech-to-text (`SpeechToTextBlock`) gains a lossless file-transcription mode: set `SpeechToTextSettings.BackpressureWhenBusy = true` to pace a file source to the transcription engine so no audio is dropped and the pipeline position tracks the transcription frontier — ideal for transcribing a file as fast as the engine allows without losing speech. The new `SpeechToTextBlock.RequestStop()` lets you stop promptly mid-file, and an `OnEndOfStream` event fires when transcription finishes.

## 2026.6.18

- [Media Blocks SDK .Net] Fixed WMV/ASF output where the video stream was written with a roughly 1000-hour timestamp offset while audio started at zero — players saw a broken duration and the video and audio never shared a timeline. WMV/ASF files now have correctly aligned, overlapping video and audio timestamps.
- [Media Blocks SDK .Net] Fixed MP4 recordings produced from a still/image source (`ImageVideoSourceBlock`, live mode) ending up unreadable ("moov atom not found") — a live image source now finalizes its file correctly on stop.
- [Media Blocks SDK .Net] VP9 WebM output now uses a real-time-capable speed/quality default: `VP9EncoderSettings.CPUUsed` defaults to `4` instead of `0`. The previous slowest/highest-quality default could not keep up with a live source, so the recorded video track could be truncated to about a second while audio ran the full length. Set `CPUUsed = 0` to restore maximum quality for offline encoding.
- [Media Blocks SDK .Net] The rav1e AV1 encoder (`RAV1EEncoderSettings`) now defaults to the fastest speed preset (`SpeedPreset = 10`) instead of `6`. rav1e is a quality-oriented, very slow software encoder; the previous default could encode well under real time (~1 fps at 720p), stalling live and short captures. Lower `SpeedPreset` for higher quality in offline encoding where throughput does not matter.

## 2026.6.14

- [Media Blocks SDK .Net] The AI blocks — `YOLOObjectDetectorBlock`, `OcrBlock`, object analytics, ANPR, `BackgroundRemovalBlock` (`VisioForge.DotNet.Core.AI`) and `SpeechToTextBlock` (`VisioForge.DotNet.Core.AI.Whisper`) — now build and run cross-platform on Linux, macOS, iOS, and Android, including .NET MAUI, in addition to Windows.
- [Media Blocks SDK .Net] On-device speech-to-text (`SpeechToTextBlock`, Whisper + Silero VAD) now runs on iOS and Android.
- [Demos] Added three .NET MAUI sample apps: **YOLO Object Detection**, **OCR Text Recognition**, and **Live Subtitles** (on-device Whisper speech-to-text). The existing Live Subtitles console sample is now cross-platform (Windows, Linux, macOS).
- [Media Blocks SDK .Net] Fixed a crash that could occur when stopping live speech-to-text with `SpeechToTextBlock` configured with `EnableVad = false` (fixed-window mode) — stopping the pipeline at end-of-stream while a transcription was in progress could terminate the process. Transcription of the in-progress window now completes cleanly during shutdown.
- [Media Blocks SDK .Net] `SpeechToTextSettings.FixedWindowSeconds` is now clamped to 1–30 s and `SileroVadSettings.MaxSpeechMs` no longer accepts "0 = unlimited" (a non-positive value falls back to the 15 s cap), so a single transcription window — and the time a stop waits for it to finish — stays bounded.

## 2026.6.13

- [Media Blocks SDK .Net] Added **live speech-to-text / subtitles** — the new `SpeechToTextBlock` (in the new `VisioForge.DotNet.Core.AI.Whisper` package) transcribes the audio stream in real time with Whisper (Whisper.net / GGML) on a background worker, gated by Silero VAD so silence is skipped and not mis-transcribed. Audio passes through unchanged. It raises `OnSpeechRecognized`, can auto-render captions onto video via `SubtitleRenderer` + `OverlayManagerBlock`, and can write `.srt` / `.vtt` side-car files. Runs fully on-device (CPU or NVIDIA CUDA); Whisper and Silero models are downloaded at runtime. Includes a new WPF Live Subtitles demo.
- [Media Blocks SDK .Net] Added **AI background removal (matting)** — the new `BackgroundRemovalBlock` runs an ONNX segmentation model (for example MODNet) to estimate a per-pixel foreground mask and replaces the background in real time with a blur of the original, a solid color, a static image, or transparency. Includes a new WPF Background Removal demo. The background is composited on every frame, so running the model less often (frame skipping) lowers CPU/GPU load without flicker.

## 2026.6.11

- [Media Blocks SDK .Net] Added **Object Analytics** — multi-object tracking with stable IDs, directed tripwire line crossing (In/Out counts), and polygon zone occupancy on top of ONNX object detection. Includes a turnkey `ObjectAnalyticsBlock`, a pure C# analytics API (`ByteTracker`, `LineZone`, `PolygonZone`), overlay rendering with traces and counters, a new analytics mode in the YOLO Object Detection demo, and separate Tripwire and Polygon Zone demo applications.

## 2026.6.8

- [Video Capture SDK .Net] Updated the bundled FFmpeg DirectShow source and encoder filters to **FFmpeg 8.1.1**, with refreshed codec libraries (VP8/VP9, Opus, Vorbis, Speex, SRT) and current OpenSSL — bringing newer format support and upstream security and stability fixes to FFmpeg-based capture and output.

## 2026.6.7

- [Media Blocks SDK .Net] Fixed a crash when reusing a `TSAnalyzerBlock` across runs: after the block is stopped, analyzing a second transport stream with the same instance in a new pipeline now works instead of failing during rebuild.
- [Media Blocks SDK .Net] Fixed MPEG-TS output with KLV metadata aborting (no valid file produced) when a video frame arrived with an out-of-order/duplicate timestamp — the muxer now keeps the stream writable, so KLV-bearing transport streams record reliably.
- [Core] Fixed native memory steadily growing while reading media information for many different files in sequence with `MediaInfoReaderX`; per-file discovery resources are now released after each read.

## 2026.6.6

- [Media Player SDK .Net] **New "Modern Player" MAUI demo.** A from-scratch cross-platform sample (Android, iOS, macCatalyst, Windows) built on `MediaPlayerCoreX` with a dark glassmorphism UI, a YouTube-style seek preview (a thumbnail popup follows the scrub bar — generated in the background from the opened file), a live video + audio effects drawer (brightness/contrast/saturation/hue, gamma, blur/sharpen, grayscale, edge, deinterlace, color presets, flip/rotate, 3D-LUT; plus gain, pitch, 10-band equalizer, reverb, echo, true-bass, and karaoke), frame snapshot, playback-speed control, and volume/mute.
- [Media Player SDK .Net] [Media Blocks SDK .Net] Fixed opening local media files by absolute file path on Android, iOS, macOS, and Linux. A path starting with `/` (the form returned by the native file pickers) previously failed with a URI-format error; `MediaPlayerCoreX.OpenAsync(string)`, `MediaInfoReaderX`, and `UniversalSourceSettings.CreateAsync(string)` now open such files correctly. Windows paths were unaffected.
- [Media Blocks SDK .Net] **OCR — text recognition:** new `OcrBlock` recognizes text in any video or image source using a multi-stage PaddleOCR (PP-OCRv5) ONNX pipeline — text detection, automatic 180° orientation handling, and text-line recognition. Runs on CPU or GPU (DirectML on Windows, CoreML on Apple, CUDA) and is fully cross-platform (Windows/Linux/macOS/Android). It raises the recognized regions per frame (text, confidence, and the text polygon) and can optionally draw the boxes and recognized text directly into the video. Works with the permissive Apache-2.0 PP-OCRv5 mobile models (100+ languages available); the models ship with the sample, not the package.
- [Media Blocks SDK .Net] **ANPR — license plate recognition:** new `LicensePlateRecognizerBlock` reads vehicle number plates from a live stream or file using a specialized two-stage pipeline — a dedicated license-plate detector locates each plate, then a plate-specific OCR model (a global head covering the USA and 90+ countries, or a European head) reads its characters. Recognition runs on a background thread so live video never stalls; recognized plates (text, confidence, bounding box) are raised per frame and optionally drawn over the video. Cross-platform and GPU-accelerated (DirectML / CUDA / CoreML). The MIT-licensed models ship with the sample, not the package.

## 2026.6.4

- [Media Blocks SDK .Net] **AI inference package renamed:** the AI/ONNX inference package is now published as `VisioForge.DotNet.Core.AI` (previously `VisioForge.DotNet.Core.ONNX`). Update your `PackageReference` to the new id — the API and namespaces of the inference blocks are unchanged.
- [Media Blocks SDK .Net] **Object detection: more models, permissive default.** `YOLOObjectDetectorBlock` now decodes three model families via the new `YoloDetectorSettings.Model` property — **YOLOX** and **RT-DETR / D-FINE** (both Apache-2.0) in addition to YOLOv8/v11. Each family's frame preprocessing (resize mode, normalization, channel order) and the model's input size are applied automatically, so you only pick the family and the `.onnx` file. The Object Detection demo now ships a ready-to-run **Apache-2.0** model (YOLOX-nano) and works out of the box without any third-party model download. RT-DETR / D-FINE detectors are end-to-end (NMS-free).
- [Media Blocks SDK .Net] **TS analyzer — ETSI TR 101 290 monitoring:** `TSAnalyzerBlock` now reports a structured TR 101 290 Priority 1/2/3 check list (sync loss, sync-byte errors, PAT/PMT/PID errors, continuity-count errors, transport errors, CRC errors, PCR/PTS errors, and SI/SDT/EIT/TDT errors), each with its priority, error count, and pass/fail status — turning the block into a broadcast-grade transport-stream monitor.
- [Media Blocks SDK .Net] **TS analyzer — service information:** the report now exposes per-program SDT service names, service provider, and service type, the network name, and the stream UTC time (TDT/TOT), so programs show up as their real service name instead of just a program number.
- [Media Blocks SDK .Net] **TS analyzer — audio language:** elementary-stream entries now carry the ISO 639 audio language parsed from the PMT descriptors.
- [Media Blocks SDK .Net] **TS analyzer — scrambling detection:** per-PID and per-program scrambling state is now reported (transport-scrambling-control and free\_CA\_mode), along with a scrambled-packet count.
- [Media Blocks SDK .Net] **TS analyzer — null and effective bitrate:** the report adds the null-packet count, the null (stuffing) bitrate, and the effective (useful) bitrate, plus per-PID instantaneous and peak bitrate alongside the existing cumulative average.
- [Media Blocks SDK .Net] **TS analyzer — PCR timing and PTS/DTS:** PCR statistics now include maximum jitter and PCR repetition errors, and the report tracks PTS/DTS presence per PID and audio/video synchronization offset.
- [Media Blocks SDK .Net] **TS analyzer — codec details:** video elementary streams now report parsed codec details (resolution, frame rate, profile, level, chroma format, and display aspect ratio) for H.264, HEVC, and MPEG-2. Frame rate and aspect ratio are reported from the MPEG-1/2 sequence header.
- [Media Blocks SDK .Net] **TS analyzer — optional EPG:** when enabled, the analyzer parses EIT events (event id, start time, duration, name, description) and exposes them as an EPG event list. The new analysis options (service info, EPG, scrambling, TR 101 290, PTS/DTS, codec details) are configurable on `TSAnalyzerSettings`. The WPF and console demos display all of the new information.
- [Video Capture SDK .Net] Fixed audio capture failing to start with certain WDM capture cards (for example the Viewcast Osprey 460E) when the device was selected by its device path — the device enumerated correctly but capture aborted with an "audio output pin is null" error. Such devices now bind reliably.
- [Media Blocks SDK .Net] Fixed a `MediaBlocksPipeline` becoming unusable after a media file played to its end. Once a source reached End-of-Stream, the next `StartAsync()` was permanently rejected with "Already starting or start in progress." and the pipeline could not be restarted without recreating it — for example when switching from a finished file back to a live camera. Playback now shuts down cleanly at end-of-stream exactly like an explicit `StopAsync()` (sources stopped, resources released), so the same pipeline can be started again.

## 2026.6.3

- [Media Blocks SDK .Net] **MPEG-TS analyzer:** new `TSAnalyzerBlock` analyzes a transport stream and reports the program/service line-up (PAT/PMT/PSI), the per-PID stream types and codecs, per-PID and total bitrate, continuity-counter errors, and PCR timing (interval min/avg/max and discontinuity count). It accepts a raw MPEG-TS byte stream from a file, UDP, or SRT source and can run terminal (`Input`) or inline passthrough (`InputOutput`); subscribe to `OnAnalysisUpdated` for periodic snapshots or call `GetReport()`. New WPF and console demos ("TS Analyzer Demo", "TS Analyzer CLI") show file and live UDP/SRT analysis.
- [Media Blocks SDK .Net] **Raw MPEG-TS UDP source:** new `UDPRAWMPEGTSSourceBlock` receives a live UDP unicast or multicast transport stream and exposes the untouched MPEG-TS byte stream without demuxing — for analysis or passthrough remuxing/recording. The advertised packet size is configurable via `UDPRAWMPEGTSSourceSettings.PacketSize` (188 by default, or 192 for M2TS-style streams).
- [Media Blocks SDK .Net] **Split-recording segment events:** `MP4SinkBlock`, `MPEGTSSinkBlock`, and `MP4OutputBlock` now raise `OnSegmentCreated` and `OnSegmentClosed` when configured for split recording (`MP4SplitSinkSettings` / `MPEGTSSplitSinkSettings`). The arguments carry the segment file path, fragment index, and timing (running time, plus start offset and duration on close) — so you can be notified when a segment file is finished and, for example, rename it to include its start/end time.
- [Media Blocks SDK .Net] **Custom split-segment file names:** the same blocks add an `OnSegmentFileNameRequested` event, raised just before each new segment file is created, letting you supply a custom file name (for example one that embeds the segment start date/time). Leave it unset to keep the default name from the location pattern.
- [Media Blocks SDK .Net] **New AI inference blocks:** `OnnxInferenceBlock` runs any ONNX Runtime model over the live video frames and raises an event with the raw model outputs, while `YOLOObjectDetectorBlock` performs YOLOv8/v11 object detection, draws bounding boxes and labels directly on the video (label text auto-scales to the frame resolution so it stays readable on 720p/1080p/4K, or pin a fixed size via `YoloDetectorSettings.LabelFontSize`), and raises a detections event (with class, confidence, and box for each object). Both support frame skipping to tune throughput. On Windows the package uses the DirectML ONNX Runtime build, so inference runs on any DirectX 12 GPU (NVIDIA, AMD, or Intel) out of the box; the execution provider defaults to `Auto`, which picks the fastest available backend (DirectML/CUDA/CoreML) and transparently falls back to the CPU. Use `OnnxInferenceEngine.GetAvailableProviders()` to detect what is available and the new `ActiveProvider` property on either block to see which provider engaged. The `VisioForge.DotNet.Core.ONNX` package targets the full SDK framework matrix (.NET Framework 4.6.1 through .NET 10); inference requires a 64-bit (x64 or ARM64) ONNX Runtime native build.

## 2026.6.2

- [Video Capture SDK .Net] Fixed KLV metadata progressively drifting out of sync with the video (about 2 seconds per source loop) on the receiving side when restreaming a looping KLV-bearing MPEG-TS via `UDP_FFMPEG_EXE`. KLV and video now stay aligned across source loop boundaries.
- [Video Capture SDK .Net] Unity: new VideoCaptureCoreX samples — local webcam preview + MP4 recording (Windows, macOS) and IP/RTSP camera viewing (Windows, Android, macOS, iOS).
- [Video Edit SDK .Net] Unity: new VideoEditCoreX sample — combine clips, apply effects, preview the timeline in Unity, and render to MP4.

## 2026.5.31

- [Media Blocks SDK .Net] **New `UDPRAWSourceBlock`:** receives a live UDP stream (MPEG-TS, RTP, or raw elementary) and exposes the parsed, still-encoded media without decoding — ideal for recording or remuxing without re-encoding. MPEG-TS feeds are auto-detected; RTP and raw modes let you set the codec, RTP payload type, and a multicast address. It exposes all common video and audio codecs (video: H264, H265, VP8, VP9, AV1, MPEG-2, MJPEG; audio: AAC, MP3/MPEG audio, AC-3, Opus, FLAC); RTP can also carry audio on a separate port (`AudioPort` / `AudioCodec`). A codec without a dedicated parser is passed through unchanged rather than dropped, so a connected recorder/muxer is never starved.
- [Demos] **New WPF "UDP RAW Capture Demo" (Media Blocks SDK .Net):** records a live UDP H264/H265 feed to MP4 files **without re-encoding**, with selectable transport (Auto / MPEG-TS / RTP / raw), starting a new file on a configurable interval and splitting on key-frames so no data is lost between files, while previewing the stream.
- [Media Player SDK .Net] Unity: new MediaPlayerCoreX sample — play files and network URLs with seek, pause and volume, rendered into a Unity `Texture2D`.

## 2026.5.29

- [Media Blocks SDK .Net] **Unity 6 (.NET Standard 2.1) build flavor:** the managed SDK now ships as a single `netstandard2.1` assembly compatible with Unity's IL2CPP backend (Api Compatibility Level = .NET Standard 2.1). This lets Unity projects target the SDK without requiring the .NET Framework 4.x compatibility surface. The existing net48 Unity package remains supported.
- [Media Blocks SDK .Net] **Unity macOS Standalone player support (Universal arm64 + x86\_64):** the Unity 6 ns2.1 `.unitypackage` now ships a third platform flavor for macOS Standalone (in addition to Windows and Android). Includes pre-built P/Invoke for macOS `.dylib` names, the bundled CrossPlatform.Core.macOS native runtime (GStreamer dylibs + `libgioopenssl` TLS backend + `ca-certificates.crt`), and a one-time `Configure()` bootstrap that prunes any system / homebrew GStreamer from `DYLD_LIBRARY_PATH` before the loader runs.
- [Core] **New API:** `VisioForgeX.StopMainLoop()` — explicit teardown of the internal GLib main loop independent of `DestroySDK()`, for scenarios that need to release the loop without tearing the SDK down.

## 2026.5.22

- [Demos] **Unity `.unitypackage` distribution:** the Unity 6 (net48) integration now ships as a single self-contained `.unitypackage`
- [Demos] **New Unity 6 (net48) samples:** `SimplePlayer` (file playback) and `RTSPViewer` (live RTSP camera) render a `MediaBlocksPipeline` into a Unity `RawImage` via a reusable `VisioForgeVideoView` component (Stretch / Letterbox / Crop). The bundled native + managed runtime is set up automatically; a step-by-step setup guide is included.

## 2026.5.20

- [Media Blocks SDK .Net] **Fix:** native memory leak in `OverlayManagerFilter` and `PanZoomFilter` on iOS/AOT builds.

## 2026.5.19

- [Media Blocks SDK .Net] **Fix:** `CVMotionCellsBlock`, `CVFaceDetectBlock`, `CVHandDetectBlock`, `CVTemplateMatchBlock` — event subscriptions added after `StartAsync` sometimes were silently dropped.
- [Media Blocks SDK .Net] **Fix:** `CVMotionCellsSettings.Gap` and `PostNoMotion` are now rounded and clamped to the ranges accepted by the underlying `motioncells` element (`Gap` → `[1, 60]` s, `PostNoMotion` → `[0, 180]` s). Previously sub-second values truncated to `0` and were silently rejected.
- [Media Blocks SDK .Net] **Docs:** `CVMotionCellsSettings.GridSize` XML-doc clarified that the minimum is 8x8 (constraint of the underlying `motioncells` element); smaller values are silently rejected.

## 2026.5.18

- [Media Blocks SDK .Net] **New API:** `SRTSinkSettings.PreResolveHostname` and `SRTSourceSettings.PreResolveHostname` (`bool`, default `false`). When set to `true`, the SDK resolves any DNS hostname in the SRT URI to a literal IPv4 on the managed side (via `System.Net.Dns`) before handing the URI to the native code.

## 2026.5.16

- [Core] Public-API XML documentation is now validated for correct syntax across the shipped NuGet packages.

## 2026.5.15

- [Core] Added `D3D11Composable` WPF renderer mode: a pure FrameworkElement video panel built on a D3D11 shared texture + `D3DImage` bridge that composes natively with the WPF visual tree (transforms, opacity, z-order, rounded clips) and keeps frames GPU-resident end-to-end. New type: `D3D11ComposablePanel`.
- [Core] Added true-peak (dBTP) metering per ITU-R BS.1770-4: new `TruePeakComputer` (4× polyphase FIR oversampling, per-channel running peak, NaN/Inf-safe) and `VUMeterXData.TruePeak[]` channel array fired alongside the existing sample-peak/RMS data.
- [Core] Added `VolumeMeterLED` WPF control: segmented LED-bar VU meter with broadcast-style green/yellow/red zones, optional peak-hold marker (configurable fall time), optional dB scale labels, optional RMS overlay bar, horizontal/vertical orientation.
- [Core] NuGet packages now ship XML documentation generated from real summaries for the full public API surface (previously the doc files were empty).

## 2026.5.14

- [Avalonia] Updated Avalonia, Avalonia.Desktop, Avalonia.Fonts.Inter, Avalonia.Themes.Fluent from 12.0.1 to 12.0.3.
- [WinForms] Resolve issue with WinForms designer when using `VideoView` in .Net Framework 4.x projects
- [Dependencies] Closed two transitive security advisories: pinned `System.Drawing.Common` per-TFM on bare/cross-platform `netN.0` (was 5.0.1 via DlibDotNet — GHSA-rxg9-xrhp-64gj, critical) and added explicit `SharpCompress 0.48.1` CPM pin to lift the transitive floor from MongoDB.Driver (was 0.30.1 — GHSA-6c8g-7p36-r338, moderate); bumped MongoDB.Driver 3.8.0 → 3.8.1.
- [Breaking] `VisioForge.Core.CVD` and `VisioForge.Core.FaceAI` assemblies are no longer strong-named. The underlying `DlibDotNet` dependency is unsigned, so the strong-name chain was already broken at runtime; the `<SignAssembly>` flag was dropped to silence CS8002. Consumers that referenced these assemblies by fully-qualified strong name (`PublicKeyToken=...`) or used `[InternalsVisibleTo("VisioForge.Core.CVD, PublicKey=...")]` must remove the strong-name assertion when upgrading.

## 2026.5.10

- [Core] `CustomMixerSourceBlock`: reliability and throughput improvements under heavy load.

## 2026.5.8

- [Dependencies] Upgraded MongoDB.Driver.GridFS 2.30.0 to MongoDB.Driver 3.8.0; pinned Snappier 1.3.1 to resolve NU1903 high-severity vulnerability (GHSA-pggp-6c3x-2xmx)

## 2026.5.2

- [Core] Breaking change: licensing APIs now accept only raw certificate bytes. Removed file-path and stream-based certificate setters across shared licensing, public SDK wrappers, legacy Windows wrappers, tests, and licensing docs. Applications must load `.vflicense` files into memory and call `SetLicenseCertificateAsync(byte[])`.
- [Core] `AudioMixerBlock`: `AudioMixerSettings.IgnoreInactivePads` is now opt-in (default `false`). The 2026.4.30 release briefly forced it `true`, which broke single-input mixers — silent live audio and corrupted MP4 output. Multi-stream consumers (`MediaPlayerCoreX` additional audio streams, `LiveVideoCompositor`, and `AudioMixerSourceSettings`-based multi-source capture) now opt in explicitly. If you wired a multi-stream `AudioMixerBlock` on 2026.4.30–2026.5.1 and relied on the implicit `true`, set `AudioMixerSettings.IgnoreInactivePads = true` explicitly.

## 2026.4.25

- [Core] Fixed WinForms designer exception on `VideoView` in net472 demos — SkiaSharp 3 migration regression
- [Core] Added transitive `SkiaSharp.NativeAssets.Linux` dependency for bare cross-platform TFMs (`netcoreapp3.1`, `net5.0`–`net10.0`) so consumers publishing to `linux-x64`/`arm64` no longer need to add the package manually; main `SkiaSharp` already covers Win32/macOS/iOS/Android/MacCatalyst/tvOS via per-TFM nuspec groups
- [Avalonia] Migrated SDK and all 28 demos from Avalonia 11.3.8 to **12.0.1**: replaced `Avalonia.Diagnostics` with `AvaloniaUI.DiagnosticsSupport 2.2.1`, switched to `ReactiveUI.Avalonia 12.0.1`, updated `RxApp.MainThreadScheduler` → `RxSchedulers.MainThreadScheduler` (ReactiveUI 23.x), new `UseReactiveUI(_ => { })` signature, moved Android `CustomizeAppBuilder` from `MainActivity` to new `MainApplication : AvaloniaAndroidApplication<App>`, migrated `SaveFileDialog`/`OpenFileDialog`/`FileDialogFilter` to `IStorageProvider.SaveFilePickerAsync`/`OpenFilePickerAsync` in 4 demos. SkiaSharp pinned to 3.119.3-preview.1.1 (required by Avalonia.Skia 12).

## 2026.4.23

- [NuGet] Extracted Intel Quick Sync Video (QSV) plugin (`gstqsv.dll`) from `VisioForge.CrossPlatform.Core.Windows.x64/x86` into new optional packages `VisioForge.CrossPlatform.Core.Windows.Intel.x64` and `VisioForge.CrossPlatform.Core.Windows.Intel.x86`; each depends on the corresponding base Core package
- [Video Capture SDK .Net] Fixed FFMPEG.exe pipe output argument ordering so resize/aspect options are emitted after all inputs, including KLV metadata pipe input

## 2026.4.21

- [Core] Added `AutoAV1EncoderSettings`: auto-selecting AV1 encoder that walks AMF → NVENC → QSV → SVT-AV1 via `EncoderRuntimeTracker`, mirroring `AutoH264EncoderSettings` / `AutoHEVCEncoderSettings`; AV1 sessions now participate in per-runtime slot accounting
- [Core] Added typed `AV1Encoder.CanCreateSession(IAV1EncoderSettings, out string)` probe so AV1 runtime selection can detect driver rejections before wiring a pipeline
- [Core] Added `MFH264EncoderSettings`, `D3D12H264EncoderSettings`, `D3D12HEVCEncoderSettings` — alternative Windows runtimes (`mfh264enc`, `d3d12h264enc`, `d3d12h265enc`) with independent per-adapter session counters for bypassing per-runtime caps (e.g., AMD iGPU 2-session ceiling)
- [Core] Added `AutoH264EncoderSettings` / `AutoHEVCEncoderSettings`: auto-selecting encoder that probes runtimes in order (AMF → NVENC → QSV → MF → D3D12 → software), tracks in-flight sessions via `EncoderRuntimeTracker`, and falls back when a runtime's cap is reached
- [Demo] Added `Encoder Concurrency Test` WPF demo (Media Blocks SDK): spawn multiple source→encoder→decoder→renderer pipelines with configurable resolution, frame rate, encoder runtime, and adapter to exercise concurrent-session limits end-to-end

## 2026.4.18

- [Media Blocks SDK] UniversalSourceBlock: added `VideoFlipRotate` option for automatic video orientation correction using image-orientation metadata
- [Core] VOAACEncoderSettings deprecated in favor of `AVENCAACEncoderSettings`
- [Core] RTSPXOutput: now accepts any `IAACEncoderSettings`, not just VOAAC
- [Core] MediaInfoReaderCore: preserves image-orientation flip metadata during media info reading
- [Core] H264Encoder: fixed thread-safety issue in KeyFrameDetected callback
- [iOS] PhotoGalleryHelper: requests `PHAccessLevel.AddOnly` for iOS 26 compatibility
- [Android] GStreamer Android NuGet rebuilt with zbar barcode plugin, bumped to 2026.4.18
- [Platform] macOS demos migrated from net9.0-macos to net10.0-macos
- [Dependencies] Uno.Sdk bumped 6.4.24 → 6.5.31
- [Media Blocks SDK] LiveVideoCompositor V2: added `OnRenderStatistics` event with `ActualFps`, `ConfiguredFps`, `FramesDelivered`, and `LastFrameTimestamp` payload for detecting when the compositor falls behind the configured frame rate under heavy load
- [Media Blocks SDK] LiveVideoCompositor V1 (`VisioForge.Core.LiveVideoCompositor`) marked `[Obsolete]` — migrate to `VisioForge.Core.LiveVideoCompositorV2` (identical class names, single-line `using` swap); V1 will be removed in a future release
- [Demos] WPF LVC Demo and MAUI LVC Demo show the real vs configured output FPS in the UI; WinForms Video Mixer Player migrated from V1 to V2

## 2026.4.11

- [Media Player SDK X] Added `Play_PauseAtFirstFrame` property to MediaPlayerCoreX — pauses at the first rendered frame for preview/thumbnail scenarios, matching the existing MediaPlayerCore API
- [Core] Migrated SkiaSharp from 2.88.9 to 3.119.2 — updated text rendering to SKFont API, replaced SKFilterQuality with SKSamplingOptions, switched SVG library from SkiaSharp.Svg to Svg.Skia
- [UI] Updated SkiaSharp.Views.WPF and SkiaSharp.Views.Maui.Controls to 3.119.2; WPF skins now use DrawImage with high-quality Mitchell resampling

## 2026.4.8

- [Android] Added live camera switching (SwitchCamera) to SystemVideoSourceBlock — switches between front/back cameras without recreating the GStreamer pipeline, preserving resolution and frame rate
- [Video Capture SDK X] Added Video\_Source\_SwitchCamera for live camera switching on Android without pipeline restart
- [Video Capture SDK X] Added Video\_Renderer\_IsSync and Audio\_Renderer\_IsSync properties (default false) for lower-latency live preview
- [Android] New NuGet native version v2026.4.1

## 2026.3.27

- [Core] Fixed UNC path media info reading failure: `MediaInfoReaderAlt` now correctly handles SDK initialization guard, null caps in `OnPadAdded`, and falls through to `MediaInfoReaderX` on failure. `IsSambaURL()` extended to detect `file://host/path` UNC URIs. `OpenAsync` uses `uri.LocalPath` for correct Windows UNC path.

## 2026.3.18

- [Media Blocks SDK .Net] Fixed missed context menu issue in WPF VideoView

## 2026.3.17

- [Media Blocks SDK .Net] Added UDPSinkBlock and MultiUDPSinkBlock for raw UDP streaming output with single and multi-destination support
- [Media Blocks SDK .Net] Added UDPMPEGTSSinkBlock and MultiUDPMPEGTSSinkBlock for MPEG-TS multiplexed UDP streaming with single and multi-destination support
- [Media Blocks SDK .Net] Added UDPSinkSettings, MultiUDPSinkSettings, and UDPSinkSettingsBase for UDP sink configuration with IPv6 support and URL parsing
- [Media Blocks SDK .Net] Added UDP MPEG-TS streamer demo (screen capture to UDP output)

## 2026.3.11

- [Core] Device enumeration: Blackmagic ATEM and Web Presenter devices now appear in regular video/audio device lists instead of being filtered as Decklink hardware. These devices use standard USB/UVC drivers, not the Decklink SDK. Applies to both DirectShow and GStreamer enumeration paths.
- [Core] RTSP info reader: Added audio channel count and sample rate parsing from SDP rtpmap and GStreamer pad caps.

## 2026.2.16

- [Media Blocks SDK .Net] Added PreEventRecordingBlock for circular buffer (pre-event) video recording with configurable buffer duration, keyframe-aware drain, and automatic post-event stop
- [Video Capture SDK .Net] VideoCaptureCoreX: Added pre-event recording API with TriggerPreEventRecording, ExtendPreEventRecording, StopPreEventRecording, and state query methods
- [Video Capture SDK .Net] VideoCaptureCoreX: Added PreEventRecordingOutput for configuring circular buffer recording with MP4, MPEG-TS, and MKV container support

## 2026.2.12

- [Media Blocks SDK .Net] Added OnNetworkSourceDisconnect event for detecting network source disconnections (RTSP, HTTP, SRT, NDI, RTMP, etc.) with detailed error information and source URI

## 2026.2.11

- [Media Player SDK .Net], [Media Blocks SDK .Net] Fixed audio effects pipeline routing

## 2026.2.10

- [Core] Added UNC (SMB/Samba) network path support for file sources across all X-engines, fixing File.Exists() failures on network shares
- [Media Blocks SDK .Net], [Video Capture SDK .Net] Added mouse click highlight support for screen capture with auto-subscribe/unsubscribe, manual click input, and real-time settings update

## 2026.2.8

- [Media Blocks SDK .Net] Added OverlayManagerImageSequence: image sequence overlay with per-frame durations, looping, position/size animation, fade effects, and easing support
- [Media Blocks SDK .Net] Added ImageSequenceItem data class for defining image sequence frames
- [Media Blocks SDK .Net] OverlayManagerBlock: Added convenience methods for image sequence overlays (Video\_Overlay\_AddImageSequence, UpdateImageSequencePosition, AnimateImageSequence, ImageSequenceFadeIn/Out)
- [Core] Extracted OverlayManagerEasingHelper: shared easing functions for all overlay animation types (Image, Fade, Pan, Squeezeback, ImageSequence)

## 2026.2.4

- [Media Blocks SDK .Net] Added H264PushSourceBlock for pushing raw H.264 encoded data into a decoding pipeline, with automatic AVC-to-byte-stream conversion and PTS rebasing
- [Core] Added RtspDescribeClient: lightweight cross-platform RTSP DESCRIBE client for fast stream discovery (~100-200ms), with SDP parsing and Basic/Digest auth support
- [Core] RTSPSourceSettings: Added fast RTSP discovery path using RtspDescribeClient
- [Core] RTSPRAWSourceSettings: Added fast RTSP discovery path using RtspDescribeClient
- [Core] UniversalSourceSettings: Added fast RTSP discovery path for rtsp:// and rtsps:// URIs

## 2026.2.2

- [Core] VideoCaptureDeviceInfo: Extended Windows device path population to support Media Foundation (MF) devices in addition to KS
- [Core] VideoCaptureDeviceInfo: Fixed pre-existing bug where V4L2 device path validation checked wrong variable
- [Core] VideoCaptureDeviceSourceSettings: Added FindByDevicePath() static methods for restoring saved camera profiles by device path
- [Core] DeviceEnumerator: Added FindVideoSourceByDevicePathAsync() method for looking up devices by path
- [Media Blocks SDK .Net] Added RIST (Reliable Internet Stream Transport) MPEG-TS sink output support
- [Media Blocks SDK .Net] Added WebRTC WHIP (WebRTC-HTTP Ingestion Protocol) output support
- [Video Capture SDK .Net] Added WebRTC WHIP streaming output
- [Video Capture SDK .Net] Added RIST streaming output

## 2026.1.16

- [Media Blocks SDK .Net] BridgeVideoSourceSettings: Added DoTimestamp property to enable fresh timestamp generation for cross-pipeline scenarios

## 2026.1.15

- [Media Blocks SDK .Net] DecklinkVideoSinkSettings: Made Mode parameter required in constructor to prevent frame rate mismatch issues (was defaulting to Unknown mode causing unexpected 23.98fps output)
- [Media Blocks SDK .Net] DecklinkVideoSinkSettings: Made DeviceNumber and Mode properties read-only for immutability
- [Core] DecklinkVideoOutputDialog (WPF): Added Video Mode selector for configuring output frame rate

## 2026.1.12

- [Core] WPF VideoView: Fixed crash (System.ExecutionEngineException) when minimizing window during video overlay playback

## 2026.1.11

- [Media Blocks SDK .Net] RTSPSourceBlock: Fixed video freeze when audio capture is disabled for cameras with multiple audio streams
- [Media Blocks SDK .Net] RTSPRAWSourceBlock: Added fakesink handling for disabled audio streams to prevent pipeline stalls
- [Core] MediaInfoReaderCore: Added logging for discovered audio, video, and RTP streams
- [Core] MediaInfoReaderCore: Fixed excessive block size (5MB) being set for RTSP sources, improving discovery speed

## 2026.1.10

- [Video Capture SDK .Net] DSFFMPEGEXEPipeOutput: Fixed preview lag during video capture with optimized pipe handling and queue processing
- [Video Capture SDK .Net] FFMPEG EXE output: Added real-time encoding optimizations for VP8/VP9, fixed MJPEG quality mode, improved default H264MFSettings defaults

## 2026.1.6

- [Video Capture SDK .Net] VideoCaptureCoreX: Fixed video capture resolution issue when ResizeVideoEffect is applied

## 2025.12.12

- [Media Blocks SDK .Net] Added PitchBlock for audio pitch shifting with semitone control (-12 to +12 range)
- [Media Player SDK X .Net] CDGSource: Added pitch shifting support with EnablePitchShifting option and real-time PitchSemitones control
- [Media Player SDK X .Net / Media Blocks SDK .Net] CDGSourceSettings: Added ZIP archive support for karaoke files (MP3+CDG pairs inside ZIP)

## 2025.11.8

- [Media Blocks SDK .Net] OverlayManagerVideo and OverlayManagerDecklinkVideo: Changed AudioOutput property type from MediaBlock to AudioOutputDeviceInfo for direct audio device selection. Audio is now handled internally via AudioRenderer with automatic channel conversion support.

## 2025.11.4

- .Net 10 support for all SDKs

## 2025.11.3

- WPF VideoView update: Added RotationAngle, RotateCrop, and RotationStretch properties to support rotated video rendering

## 2025.11.1

- [Media Blocks SDK .Net] Add synchronized overlay group support for OverlayManagerBlock

## 2025.10.10

- [**Windows SDKs**] Updated VideoEffectRotate with no-crop option

## 2025.10.6

### 🚀 Major Feature: Ultra-Low Latency RTSP Streaming

- **[Media Blocks SDK .Net]** Revolutionary low latency mode for RTSP sources achieving **60-120ms total latency** (10-14x improvement over default 1-2 seconds)
- Added `RTSPSourceSettings.LowLatencyMode` property for one-line enablement of optimized streaming
- Automatic pipeline optimization: RTSP source (80ms), queue buffers (10-20ms), and renderer sync control
- GStreamer integration: `latency=80ms`, `buffer-mode=0`, queue `max-size-buffers=2` with `leaky=downstream`
- Perfect for real-time surveillance, security systems, live monitoring, and interactive video applications
- **[Media Blocks SDK .Net]** Enhanced RTSPSourceBlock with comprehensive low latency configuration
- Added `RTSPBufferMode` enum with 5 modes (None, Auto, Slave, Buffer, Synced) for fine-grained jitter buffer control
- Added `RTSPNTPTimeSource` enum (NTP, RunningTime, Clock) for NTP timestamp synchronization in multi-camera scenarios
- New properties: `LowLatencyMode`, `BufferMode`, `DropOnLatency`, `NTPSync`, `NTPTimeSource`
- Optimized `QueueElement` with automatic low latency configuration (2 frame max, leaky downstream mode)
- **[Video Capture SDK X .Net]** Full low latency mode support for RTSP sources
- Compatible with `VideoCaptureCoreX` engine across all platforms
- Same simple API: `RTSPSourceSettings.LowLatencyMode = true`
- Works seamlessly with IP Capture demo and RTSP MultiView demo
- **[Cross-Platform Support]** Low latency RTSP streaming now available on all platforms:
- Windows (WPF, WinForms, Console, Blazor)
- macOS (MAUI, Console)
- Linux (Console, WPF with Mono)
- Android (MAUI, Native)
- iOS (MAUI)
- **[Demo Applications]** Updated 6 demos with low latency mode UI controls:
- Media Blocks SDK: RTSP Preview Demo (WPF), RTSP MultiView Demo (WinForms), MAUI RTSPViewer, Android RTSP Client
- Video Capture SDK X: IP Capture (WPF), RTSP MultiView Demo (WinForms)
- All demos include easy-to-use checkboxes or default-enabled low latency for optimal user experience
- **[Documentation]** Official help documentation updated with a low-latency section and best practices.
- **[Testing]** Validated on real IP cameras across all platforms. Performance benchmarks: Windows (85ms), macOS (95ms), Linux (80ms), Android (110ms), iOS (100ms).
- **[Backward Compatibility]** 100% backward compatible implementation:
- Default behavior unchanged - existing code works without modification
- Low latency mode is opt-in via explicit property
- No performance impact when not using low latency mode
- Queue optimization only applied when `LowLatencyMode=true`

## 2025.10.3

- [Media Blocks SDK .Net] Added DASH (Dynamic Adaptive Streaming over HTTP) sink support with DASHSinkBlock and DASHOutput classes
- [Media Blocks SDK .Net] Added UniversalSourceBlockV2 with improved memory usage and performance
- [X-engines] Fixed uvch264src not starting on Linux by properly selecting the appropriate source pad based on video format (vidsrc for H264, vfsrc for raw/MJPEG)

## 2025.9.5

- [Video Fingerprinting SDK] Improved support for flipped videos

## 2025.9.3

- [Media Blocks SDK .Net] Added DataMatrix barcode support using DataMatrixDecoderBlock block

## 2025.9.1

- [Video Fingerprinting SDK] Improved support for flipped videos

## 2025.8.9

- [Video Capture SDK .Net] VideoCaptureCoreX: Resolved issue with Snapshot\_GetSK call on Android (wrong colorspace)

## 2025.8.6

- [X-engines] Updated RTSP RAW source block. Added WaitForKeyframe and SyncAudioWithKeyframe properties. Block can wait for keyframes because some cameras may not send them as first frames.

## 2025.8.4

- [X-engines] Added NDI source support in Live Video Compositor

## 2025.8.2

- [ALL] New ONVIF manager code in VisioForge.Core.ONVIFX. Full implementation of various ONVIF services including Device Management, Media v1/v2, PTZ, Events, Imaging, Analytics, Recording, and Replay services.

## 2025.8.1

- [Media Player SDK] Added PauseOnStop property to MediaPlayerCoreX

## 2025.6.30

- [X-engines] Added animated GIF support to `ImageVideoSourceBlock`/`ImageVideoSourceSettings` classes
- [X-engines] Resolved issues with delayed file start in Live Video Compositor
- [X-engines] Update video mixer API to use GUIDs instead of integer indexes for video sources

## 2025.6.27

- [Video Capture SDK] Resolved issue with RTSP Low Latency engine with some cameras

## 2025.6.5

- [X-engines] Resolved issue with NDI sources playback without audio streams

## 2025.6.3

- [X-engines] Updated GenICam source support for USB Vision cameras. Added GenTL source support.

## 2025.6.2

- [X-engines] Added deinterlace support for interlaced Decklink video sources

## 2025.6.1

- [Live Video Compositor] Resolved issue with file sources paused on start, and resumed with error

## 2025.5.1

- [ALL] Update NuGet dependency packages to the latest versions
- [X-engines] Resolved issue with RTMP network streaming to a custom server

## 2025.4.8

- [ALL] Added Absolute Move API to the `ONVIFDeviceX` class. You can use this API to move the ONVIF camera to the specified absolute position.

## 2025.2.24

- [X-engine] By default, Media Foundation device enumeration is disabled. You can enable it using the `DeviceEnumerator.Shared.IsEnumerateMediaFoundationDevices` property.

## 2025.2.18

- [Media Player SDK.Net] Added loop support for the cross-platform engine.
- [ALL] Updated RTSP-X engine output, fixed crash issue with RTSP output and VLC player frequent reconnects
- [X-engines] Changed face detector support to use IFaceDetector interface
- [Live Video Compositor] Fixed registration issues with custom video view attached to video input

## 2025.2.9

- [X-engines] Updated NDI connection speed

## 2025.2.4

- [X-engines] RTSP Server Media Block and RTSPServerOutput added to Video Capture SDK. You can use the RTSPServerBlock to create an RTSP server and stream video and audio to it.

## 2025.2.1

- [X-engines] Added NVENC and AMF AV1 encoders support

## 2025.1.25

- [Windows] Resolved HTTPS issue with the not loaded SSL certificates

## 2025.1.22

- [Windows] Resolved issue with missed ONVIF sources while enumerating on PC with multiple network interfaces
- [Media Blocks SDK .Net] Added the `OnEOS` event to `MediaBlockPad` class. You can use this event to get the EOS (End of Stream) event from the media block. It can be useful if you have several file sources with a different duration and you need to stop the pipeline when the first source ends.
- [Media Blocks SDK .Net] Added the `SendEOS` method to `MediaBlocksPipeline` class. You can use this method to send the EOS (End of Stream) event to the pipeline.

## 2025.1.18

- [NuGet] `VisioForge.Core.UI.Apple`, `VisioForge.Core.UI.Android`, and `VisioForge.Core.UI.WinUI` packages are merged into the `VisioForge.DotNet.Core` package. All namespaces are the same.
- [Media Blocks SDK .Net] Added the `ZOrder` property to `LVCVideoInput` and `LVCVideoAudioInput` classes. You can use this property to set the Z-order for the video input.

## 2025.1.14

- [NuGet] `VisioForge.Core.UI.WPF` and `VisioForge.Core.UI.WinForms` packages are merged into the `VisioForge.DotNet.Core` package. In WPF projects you have to update the XAML code if the assembly names are used. All namespaces are the same.

## 2025.1.11

- [Video Capture SDK .Net] Resolved QSV H264 FFMPEG encoder issue with the wrong symbols in parameters

## 2025.1.7

- [Cross-platform] Added `libcamera` source support for Linux/Raspberry Pi.

## 2025.1.5

- [Cross-platform] Improved previous frame playback in Media Player SDK .Net (Cross-platform engine)

## 2025.1.4

- [Cross-platform] Resolved issue with AMD AMF plugin initialization

## 2025.1.1

- [Cross-platform] Resolved memory leak in `OverlayManagerImage`

## 2025.1.0

- [Cross-platform] Updated Live Video Compositor engine. Improved Decklink support for input and output. Improved performance. The new engine classes are located in the `VisioForge.Core.LiveVideoCompositorV2` namespace.

## 2025.0.29

- [Cross-platform] Default video renderer on Windows has been changed to DirectX 11

## 2025.0.17

- [Media Blocks SDK .Net] Added libCamera source support (can be used on Raspberry Pi)

## 2025.0.16

- [Media Blocks SDK .Net] Resolved issue with adding several AudioRendererBlocks to the pipeline

## 2025.0.14

- [Media Blocks SDK .Net] Added the "PushJPEGSourceSettings" class to configure the JPEG source for the "PushSourceBlock". You can use this class to set the JPEG source settings for the "PushSourceBlock". Also "video-from-images" sample added.

## 2025.0.7

- [ALL] Resolved window capture issues in cross-platform SDKs
- [Media Blocks SDK .Net] Added the Bridge Source Switch sample

## 2025.0.5

- [iOS] Resolved issues with playback speed for some video files
- [iOS] Added iOS Simulator support for all SDKs. Camera source is not supported in the simulator.

## 2025.0.3

- [MacOS] Resolved wrong stride issue for vertical camera videos on MacOS
- [Video Capture SDK .Net] Resolved background color issue for the scrolling text overlay

## 2025.0

- [ALL] .Net 9 support
- [Media Blocks SDK .Net] Added `AVIOutputBlock` to save video and audio streams to the AVI file format
- [Media Blocks SDK .Net] `TeeBlock` constructor now accepts the media type as a parameter
- [Video Capture SDK .Net] Added `Video_CaptureDevice_SetDefault` and `Audio_CaptureDevice_SetDefault` methods to the `VideoCaptureCore` class. You can use this method to set the default video and audio capture devices
- [Cross-platform] Improved `Metal` video rendering performance on Apple devices
- [All] Improved performance of common video processing operations in Windows classic SDKs
- [CV] Added DNN face detectors for the `Media Blocks SDK .Net` and `Video Capture SDK .Net`
- [Mobile] Improved AOT compatibility for iOS and Android
- [WinUI] Improved performance of the `WinUI` video rendering
- [Media Blocks SDK .Net] Added the `GetLastFrameAsSKBitmap` and `GetLastFrameAsBitmap` methods to `VideoSampleGrabberBlock` to get the last frame as a `SkiaSharp.SKBitmap` or `System.Drawing.Bitmap`
- [Video Capture SDK .Net] `VideoCaptureCore`: Added the `AddFakeAudioSource` property to `FFMPEGEXEOutput`. The `Network_Streaming_Audio_Enabled` property of `VideoCaptureCore` should be set to false to use this fake audio.
- [ALL] Improved WinUI (and MAUI on Windows) VideoView performance
- [Video Capture SDK .Net] `VideoCaptureCore`: Added the `PIP_Video_CaptureDevice_CameraControl_` API to control the camera settings for the Picture-in-Picture mode
- [X-engines] Added the headers support for the HTTP sources created using the `HTTPSourceSettings` class
- [X-engines] Updated Avalonia samples, with projects for macOS, Linux, and Windows
- [X-engines] Added NuGet redist packages for macOS and MacCatalyst (including MAUI)
- [Video Capture SDK .Net] `VideoCaptureCore`: Added device path support for `PIP_Video_CaptureDevice_CameraControl` API
- [Video Capture SDK .Net] `VideoCaptureCore`: Added the `FFMPEG_MaxLoadTimeout` property for IP camera sources. It allows you to set the maximum time to wait for the FFMPEG source to load the stream
- [X-engines] Updated Linux support for `ALSA`, `PulseAudio` and `PipeWire` audio devices
- [X-engines] Updated Linux support for `V4L2` devices
- [X-engines] Avalonia samples has be changed to a modern 1-project structure
- [X-engines] Resolved issue with `MAUI` crashes on Windows after `SkiaSharp` update
- [X-engines] Resolved issue with `TextureView` crashes on Android in `MAUI` applications
- [X-engines] Resolved playback issue for http sources using the `UniversalSourceBlock`
- [X-engines] Added Mobile Streamer sample for Android
- [X-engines] Added `OverlayManagerBlock` support for Android (now it's available for all platforms)
- [Video Capture SDK .Net] `VideoCaptureCoreX`: Added `CustomVideoProcessor`/`CustomAudioProcessor` properties for all output formats. You can use these properties to set custom video/audio processing blocks for the output format.
- [Media Blocks SDK .Net] Added the `KeyFrameDetectorBlock` to detect key frames in video streams (H264, H265, VP8, VP9, AV1, etc.)
- [Media Blocks SDK .Net] Fixed licensing issue for the `LiveVideoCompositor` class

## 15.10.0

- [Windows] Updated window capture API to capture only the specified parent window by default. Added the `UpdateHotkey` method to the `WindowCaptureForm` class to update the hotkey for the window capture form.
- [X-engines] Better AOT compatibility for default MAUI settings in iOS.
- [Media Blocks SDK .Net] Added the `DNNFaceDetectorBlock` to detect faces and blur/pixelate them using OpenCV and DNN models.
- [Media Blocks SDK .Net] Added the `MKVOutputBlock` to save video and audio streams to the MKV file format.
- [X-engines] Better support for video source size dynamic changing in MAUI applications.
- [X-engines] Resolved an issue with two or more VU meters in the same pipeline.
- [X-engines] Resolved volume/mute error issue with audio mixer in Live Video Compositor engine.
- [X-engines] The `Spinnaker` source for `FLIR`/`Teledyne` cameras is included in the main package and no longer requires an additional plugin.
- [Video Capture SDK .Net] Resolved the issue with the `SeparateCapture` API if no `VideoView` was used.
- [X-engines] The `MediaBlocksPipeline` constructor no longer has the `live` parameter. For more customizable pipelines, video and audio renderers got the `IsSync` property (`true` by default).
- [X-engines] Resolved `VideoViewTX` crash in MAUI Android applications.
- [X-engines] `IVideoEncoder` interface added to the `MPEG2VideoEncoder` class. It allows the use of `MPEG2VideoEncoder` with `MPEGTSOutput`, `AVIOutput`, and other output classes.
- [X-engines] Resolved the issue with window capture using the `ScreenCaptureD3D11SourceSettings` class. If the rectangle was incorrect or not specified, it caused an error.
- [X-engines] `Metal` renderer was added to SDK for Apple devices and used by default for iOS and MAUI.
- [Media Blocks SDK .Net] Added the MAUI Screen Capture sample.
- [Video Capture SDK .Net] VideoCaptureCore: Added the `VLC_CustomDefaultFrameRate` property to `IPCameraSourceSettings` to set a custom frame rate for the VLC IP camera source if the source does not provide the correct frame rate.
- [Media Blocks SDK .Net] `RTSPSourceBlock`: If the RTSP source has audio but you've disabled the audio stream in `RTSPSourceSettings`, SDK will add a null renderer automatically to prevent warnings.
- [ALL] Resolved issue with `VideoFrameX.ToBitmap()` call (wrong color space)
- [Windows] Updated KLV support in MPEG-TS output
- [Windows] Resolved MediaPlayerCore serialization issue
- [ALL] Video renderer settings class no longer contains background color. Use the VideoView background color property instead.
- [X-engines] Updated GStreamer libraries
- [X-engines] Resolved video rendering issues on Android and iOS
- [X-engines] iOS crash fixed during VideoViewGL usage
- [X-engines] Added default AAC encoder for iOS
- [X-engines] iOS camera source update for high frame rate support
- [Windows] Updated VLC source - improved file loading speed
- [Media Blocks SDK .Net]: Added the `UniversalDemuxBlock` allows to demux video and audio streams from a file in MP4, MKV, AVI, MOV, TS, VOB, FLV, OGG, and WebM formats
- [Windows] Resolved FFMPEG stability issues
- [X-engines] Resolved issue with loopback audio source using VideoCaptureCoreX and audio capture to file
- [X-engines] Added SRT source and sink support in Media Blocks SDK .Net and Video Capture SDK .Net
- [Video Capture SDK .Net] VideoCaptureCore: The `IP_Camera_ONVIF_ListSourcesAsyncEx` method got an overload version with a callback for a more responsible UI
- [X-engines] RTSP source compatibility update
- [X-engines] `Breaking API change`. Starting with this update, the SDK uses `IAudioRendererSettings` interface implementations for audio output configuration. WASAPI output got the custom configuration classes. Output\_AudioDevice properties of `VideoCaptureCoreX`/`MediaPlayerCoreX` type have been changed to `IAudioRendererSettings`. You can create the `AudioRendererSettings` class instance from `AudioOutputDeviceInfo` using the default constructor.
- [X-engines] Resolved problem with missed Media Foundation sources during device enumeration
- [X-engines] Resolved RTSP source problems with audio connection in some situations
- [X-engines] Added the RTSP Preview Demo to Media Blocks SDK .Net
- [Windows] FFMPEG outputs and source updated to FFMPEG v7.0.
- [X-engines] Fixed rare crashes in RTSP source when camera information is not available for some reason (network issue)
- [X-engines] Resolved an issue with `WASAPI/WASAPI2` audio renderer usage
- [X-engines] Resolved an issue with the audio loopback audio source on Windows
- [X-engines] Improved iOS video rendering performance and stability
- [X-engines] Added AWS S3 Sink output for Media Blocks SDK .Net
- [X-engines] Added Allied Vision USB3/GigE cameras support in Media Blocks SDK .Net and Video Capture SDK .Net

## 15.9

- [X-engines] Resolved wrong aspect ratio with video resize effect/block
- [X-engines] Updated GStreamer redist
- [X-engines] Added Basler USB3/GigE cameras support in Media Blocks SDK .Net and Video Capture SDK .Net
- [Video Edit SDK .Net] VideoEditCoreX: The TextOverlay class changed to use SkiaSharp-based font settings. Additionally, you can set the custom font file name or configure all rendering parameters using custom SKPaint.
- [Windows] Added Stream support in `MediaInfoReader`. You can get the video/audio file information from a stream (DB, network, memory, etc.).
- [X-engines] Updated Live Video Compositor engine, which improved support of the file sources
- [Video Capture SDK .Net] Added camera-covered detector into the `Computer Vision Demo` and the `VisioForge.Core.CV` package
- [X-engines] Added API to get snapshots from video files using MediaInfoReaderX: GetFileSnapshotBitmap, GetFileSnapshotSKBitmap, GetFileSnapshotRGB
- [X-engines] iOS support in MAUI samples
- [X-engines] Resolved memory leak issue for RTSP sources
- [Media Player SDK .Net] MediaPlayerCore: Added support for data streams in video files using the FFMPEG source engine. Add the OnDataFrameBuffer event to get data frames (KLV or other) from the video file.
- [Video Capture SDK .Net] VideoCaptureCore: Added support for data streams in video files using the IP Capture FFMPEG source engine. Add the OnDataFrameBuffer event to get data frames (KLV or other) from the MPEG-TS UDP network stream or other supported source.
- [Video Capture SDK .Net] VideoCaptureCore: Added the FFMPEG\_CustomOptions property to the IPCameraSourceSettings class. This property allows you to set custom FFMPEG options for the IP camera source
- [Windows] Fixed the hang problem with the FFMPEG source when a network connection is lost
- [Media Blocks SDK .Net] Added RTSP MultiView in Sync Demo
- [X-engines] Added support for FLIR/Teledyne cameras (USB3Vision/GigE) using the Spinnaker SDK
- [Video Edit SDK .Net] VideoEditCoreX: Added support for .Net Stream usage as an input source
- The IAsyncDisposable interface was added to all SDK's core classes. The `DisposeAsync` call should be used to dispose of the core objects using async methods.
- [Video Capture SDK .Net] VideoCaptureCoreX: Resolved issues with Android video capture (sometimes started only one time)
- [Media Blocks SDK .Net] Added HLS streaming sample
- [Video Capture SDK .Net] VideoCaptureCore: Resolved crash if the `multiscreen` is enabled and screens added as window's handles (WinForms)
- [X-engines] Improved MAUI video rendering speed
- [X-engines] Resolved MAUI media playback issues (decoding) in MAUI Android
- [X-engines] Resolved an issue with the H264 webcam sources (sometimes not connected)
- [X-engines] Resolved an issue with audio stream playback in the Live VideoCompositor engine
- [Media Blocks SDK .Net] Resolved a bad audio issue while mixing using the Live Video Compositor engine
- [Media Blocks SDK .Net] Added Decklink output and file source into the Live Video Compositor sample
- [Media Player SDK .Net] MediaPlayerCore: Added growing MPEG-TS file support for the VLC engine. You can play growing MPEG-TS files while it's recorded

## 15.8

- [X-engines] [API breaking change] DeviceEnumerator can now be used only by using `DeviceEnumerator.Shared` property. One enumerator per app is required. DeviceEnumerator objects used by API have been removed
- [X-engines] [API breaking change] Android Activity is not required anymore to create SDK engines
- [X-engines] [API breaking change] X-engines require additional initialization and de-initialization steps. To initialize SDK, use the `VisioForge.Core.VisioForgeX.InitSDK()` call. To de-initialize SDK, use the `VisioForge.Core.VisioForgeX.DestroySDK()` call. You need to initialize SDK before any SDK class usage and de-initialize SDK before the application exits.
- [Windows] Improved MAUI video rendering performance in Windows
- [Windows] Added a mouse highlight for screen capture sources
- [Windows] Resolved a CallbackOnCollectedDelegate call issue with the BasicWindow class
- [Avalonia] Resolved an issue with Avalonia VideoView resize
- [X-engines] Added the StartPosition and StopPosition properties to UniversalSourceSettings. You can use these properties to set the start and stop positions for the file source.
- [ALL] Resolved the issue with passwords with special characters used for RTSP sources
- [ALL] Resolved the rare video flip issue with the Virtual Camera SDK engine
- [ALL] The VisioForge MJPEG Decoder filter was removed from the SDK's NuGet packages. You can optionally add it to your project by file copying or COM registration deployment.
- [X-engines] Fixed memory leak in the OverlayManager
- [Media Blocks SDK .Net] Resolved issue with the VideoSampleGrabberBlock, SetLastFrame option
- [Video Capture SDK .Net] VideoCaptureCoreX: WASAPI and WASAPI2 audio sources can be used now with the VideoCaptureCoreX engine
- [X-engines] DeviceEnumerator got events to notify about devices added/removed: OnVideoSourceAdded, OnVideoSourceRemoved, OnAudioSourceAdded, OnAudioSourceRemoved, OnAudioSinkAdded, OnAudioSinkRemoved
- [X-engines] Added custom error handler support for MediaBlocks, VideoCaptureCoreX, and MediaPlayerCoreX engines. Use the IMediaBlocksPipelineCustomErrorHandler interface and the SetCustomErrorHandler method to set a custom error handler.
- [Video Capture SDK .Net] VideoCaptureCoreX: Resolved issue with incorrect device index error for KS video sources (Windows)
- [Video Capture SDK .Net] VideoCaptureCore: Added Virtual\_Camera\_Output\_AlternativeAudioFilterName property to set a custom audio filter for the Virtual Camera SDK output
- [Video Edit SDK .Net] VideoEditCore: Added Virtual\_Camera\_Output\_AlternativeAudioFilterName property to set a custom audio filter for the Virtual Camera SDK output
- [Media Player SDK .Net] MediaPlayerCore: Added Virtual\_Camera\_Output\_AlternativeAudioFilterName property to set a custom audio filter for the Virtual Camera SDK output
- [Video Capture SDK .Net] VideoCaptureCoreX: Added NDI streaming support and sample app.
- [Media Blocks SDK .Net] Added the BufferSink block to get video/audio frames from the pipeline
- [Media Blocks SDK .Net] Added the CustomMediaBlock class to create custom media blocks for any GStreamer element
- [Media Blocks SDK .Net] Added the UpdateChannel method to update the channel of the bridge source or sink
- [Media Player SDK .Net] MediaPlayerCore: Updated Tempo effect.
- [X-engines] Updated device enumerator. Removed unwanted firewall dialog when listing NDI sources.
- [X-engines] Fixed an issue with the video mixer when adding/removing video sources.
- [Media Blocks SDK .Net] Added VideoCropBlock and VideoAspectRatioCropBlock blocks to crop video frames.
- [Media Blocks SDK .Net] Resolved wrong frame rate issue with VideoRateBlock.
- [All] Resolved an issue with the Tempo audio effect.
- [Video Capture SDK .Net] VideoCaptureCore: Added WASAPI audio renderer support for the VideoCaptureCore engine.

## 15.7

- [ALL] .Net 8 support
- [Video Capture SDK .Net] VideoCaptureCore: Fixed problem with the OnNetworkSourceDisconnect event being called twice.
- [X-engines] Added the MPEG-2 video encoder.
- [X-engines] Added the MP2 audio encoder.
- [X-engines] Resolved Decklink enumeration issues.
- [X-engines] Default VP8/VP9 settings changed to live recording.
- [X-engines] Added DNxHD video encoder support.
- [Video Capture SDK .Net] VideoCaptureCoreX: Fixed problem with audio source format setting (regression).
- [Video Capture SDK .Net] VideoCaptureCoreX: Resolved WPF native rendering issue with a pop-up window.
- [All] Avalonia 11.0.5 support.
- [Video Capture SDK .Net] VideoCaptureCoreX: Resolved licensing issues.
- [Video Capture SDK .Net] VideoCaptureCore: Start/StartAsync method will return false if the video capture device is already used by another application.
- [All] Updated VLC source (libVLC 3.0.19).
- [All] Updated FFMPEG sources and encoders. Resolved issue with missed MSVC dependencies.
- [Video Capture SDK] Updated ONVIF engine.
- [Cross-platform SDKs] Updated Decklink source. Resolved the issue with the incorrect device name.
- [All] SkiaSharp security updates.
- [Cross-platform SDKs] Updated Overlay Manager. Added OverlayManagerDateTime class to draw current date time and custom text.
- [Cross-platform SDKs] Updated OverlayManagerImage. Resolved issue with System.Drawing.Bitmap usage.
- [ALL] VideoCaptureCore: Resolved rare crash issue with WinUI VideoView
- [Video Capture SDK .Net] VideoCaptureCore: Updated FFMPEG.exe output. Improved support of x264 and x265 encoders of custom FFMPEG builds.

## 15.6

- [Video Capture SDK .Net] VideoCaptureCore: Improved video crop performance on modern CPUs
- [ALL] VideoCaptureCore, MediaPlayerCore, VideoEditCore: Added the static CreateAsync method that can be used instead of the constructor to create engines without UI lag.
- [Video Capture SDK .Net] VideoCaptureCore: Resolved issues with video crop.
- [Video Capture SDK .Net] VideoCaptureCoreX: Added video overlays API. The Overlay Manager Demo shows how to use it.
- [Video Capture SDK .Net] Improved HW encoder detection. If you have several GPUs, sometimes only the major GPU can be used for video encoding.
- [Cross-platform SDKs] Updated Avalonia VideoView. Resolved issue with VideoView recreation.
- [Media Player SDK .Net] MediaPlayerCoreX: Resolved startup issue with the Android version of the MediaPlayerCoreX engine.
- [Media Player SDK .Net] MediaPlayerCore: Video\_Stream\_Index property has been replaced with Video\_Stream\_Select/Video\_Stream\_SelectAsync methods.
- [Media Player SDK .Net] MediaPlayerCoreX: Added Video\_Stream\_Select method.
- [Video Capture SDK .Net] VideoCaptureCore: Network\_Streaming\_WMV\_Maximum\_Clients property moved to WMVOutput class. You can set the maximum number of clients for network WMV output.
- [All] Updated WPF rendering. Improved performance for 4K and 8K videos.
- [Video Capture SDK .Net] VideoCaptureCoreX: Resolved issue with multiple outputs used.
- [Video Capture SDK .Net] VideoCaptureCoreX: Resolved issue with OnAudioFrameBuffer event.
- [Video Capture SDK .Net] Decklink source changed to improve startup speed. The Decklink\_CaptureDevices method has been replaced by async Decklink\_CaptureDevicesAsync.
- [Media Player SDK .Net] MediaPlayerCoreX: Added Custom\_Video\_Outputs/Custom\_Audio\_Outputs properties to set custom video/audio renderers
- [Media Player SDK .Net] MediaPlayerCoreX: Added Decklink Output Player Demo (WPF)
- [Video Edit SDK .Net] Added Multiple Audio Tracks Demo (WPF)
- [Video Edit SDK .Net] Updated MP4 output for multiple audio tracks
- [Cross-platform SDKs] Updated device enumerator
- [Video Capture SDK .Net] Resolved issue with VU meter in cross-platform engine
- [Cross-platform SDKs] Resolved issue with VU Meter (event not fired)
- [Media Player SDK .Net] Updated memory playback
- [ALL] Added IAsyncDisposable interface support for cross-platform core classes. It should be used to dispose of the core objects in async methods.
- [Video Capture SDK .Net] Added madVR support for mutiscreen
- [Video Capture SDK .Net] Resolved NDI enumerating issue in the VideoCaptureCore engine
- [Media Player SDK .Net] Added madVR Demo
- [Video Capture SDK .Net] Added madVR Demo
- [ALL] Resolved madVR issues in all SDKs
- [Media Blocks SDK .Net] Added NDI Source demo
- [Video Capture SDK .Net] Added NDI support for cross-platform engine
- [ALL] Resolve the "image not found" issue with the WinUI NuGet package
- [Media Blocks SDK .Net/Media Player SDK .Net (cross-platform)] Added MP3+CDG Karaoke Player demo
- [Media Blocks SDK .Net] Added CDGSourceBlock for MP3+CDG karaoke files playback
- [ALL] Improved madVR support
- WinUI VideoView updated to fix issues during audio file playback
- [Video Capture SDK .Net] Improved VNC source support for the VideoCaptureCoreX engine.
- [Video Capture SDK .Net] Added VNC source support for the VideoCaptureCoreX engine. You can use VNCSourceSettings class to configure Video\_Source.
- [Media Blocks SDK .Net] Added VNC source support. You can use the VNCSourceBlock class as a video source block.
- [Video Capture SDK .Net] Video\_Resize property has been changed to IVideoResizeSettings type. You can use the VideoResizeSettings class to perform classic resize the same as before or use MaxineUpscaleSettings/MaxineSuperResSettings to perform AI resizing on Nvidia GPU using Nvidia Maxine SDK (SDK or SDK models are required to deploy).
- [ALL] Resolved issues with NDI source detection in the local network
- [ALL] Added KLVParser class to read and decode data from KLV binary files.
- [ALL] Added KLVFileSink block. You can export KLV data from MPEG-TS files.
- [Media Blocks SDK .Net] Added KLV demo.
- [Video Capture SDK .Net] Added MJPEG network streamer.
- [ALL] Added WASAPI 2 support.
- [Media Blocks SDK .Net] Updated Video Effects API. Added Grayscale media block.
- [Media Blocks SDK .Net] Added Live Video Compositor API and sample.
- [ALL] Updated Avalonia VideoView control. Resolved issues with video playback on Windows on HighDPI displays.
- [Video Capture SDK .Net] Added CustomVideoFrameRate property to MFOutput. You can set a custom frame rate if your source provides an incorrect frame rate (IP camera, for example).
- [Video Capture SDK .Net] Updated NVENC encoder. Resolved issue with high-definition video capture.
- [Video Capture SDK .Net] Resolved issue with TV Tuning on Avermedia devices
- [Media Blocks SDK .Net] Added OpenCV blocks: CVDewarp, CVDilate, CVEdgeDetect, CVEqualizeHistogram, CVErode, CVFaceBlur, CVFaceDetect, CVHandDetect, CVLaplace, CVMotionCells, CVSmooth, CVSobel, CVTemplateMatch, CVTextOverlay, CVTracker
- [CV] Resolved the issue with wrong face coordinates.
- [CV, Media Blocks SDK .Net] Added Face Detector block.
- [Media Blocks SDK .Net] Added rav1e AV1 video encoder.
- [Media Blocks SDK .Net] Added GIF video encoder.
- [Media Blocks SDK .Net] Added NDI Sink and NDI source blocks.
- [ALL] Resolved NDI SDK detection issues.
- [Media Blocks SDK .Net] Updated Speex encoder.
- [Media Blocks SDK .Net] Updated Video Mixer block.
- [ALL] Added Save/Load methods for output format to serialize into JSON.
- [Media Blocks SDK .Net] Added MJPEG HTTP Live streaming sink block.
- [ALL] Resolved MP4 HW QSV H264 regression.
- [ALL] WinForms and WPF VideoView stability updates.
- [Media Player SDK .Net] Removed FilenamesOrURL legacy property. Please use the `Playlist` API instead.
- [Media Blocks SDK .Net] Added fade-in/out feature for image overlay block.
- [ALL] Telemetry update
- [ALL] SDKs updated to use the `ObservableCollection` instead of the `List` in public API.
- [ALL] Updated MP4 HW output. Improved NVENC performance.
- [Media Blocks SDK .Net] Added Video Compositor sample.
- [Media Blocks SDK .Net] Added YouTubeSink and FacebookLiveSink blocks with custom YouTube/Facebook configurations. The `RTMPSink` can stream to YouTube/Facebook in the same way as before.
- [Media Blocks SDK .Net] Added SqueezeBack video mixer block.
- [ALL] Updated scrolling text logo. We've added the Preload method to render a text overlay before playback.
- [ALL] Updated scrolling text logo (performance)
- [Media Blocks SDK .Net] Updated Decklink sink blocks
- [ALL] Resolved crashes with a text logo with a custom resolution
- [Media Blocks SDK .Net] Added Intel QuickSync H264, HEVC, VP9, and MJPEG encoders support.
- [Video Edit SDK .Net] Added FastEdit\_ExtractAudioStreamAsync method to extract the audio stream from the video file.
- [Video Edit SDK .Net] Added "Audio Extractor" WinForms sample.
- [Media Blocks SDK .Net] Updated MP4SinkBlock. The sink can split output files by duration, file size, or timecode. Use MP4SplitSinkSettings instead of MP4SinkSettings to configure.
- [Video Capture SDK .Net] Added the OnMJPEGLowLatencyRAWFrame event that fired when the MJPEG low latency engine received a RAW frame from a camera.
- [Media Blocks SDK .Net] Added VideoEffectsBlock to use video effects, available in Windows SDKs
- [Media Blocks SDK .Net] Updated Decklink source
- [Media Blocks SDK .Net] Added Decklink Demo (WPF)
- [ALL] Resolved the DeinterlaceBlend video effect crash
- [ALL] Used 3rd-party libraries moved to VisioForge.Libs.External assembly/NuGet
- [ALL] Added Nvidia Maxine Video Effects SDK (BETA) and sample app for Media Player SDK .Net and Video Capture SDK .Net
- [Video Capture SDK .Net] Added Decklink\_Input\_GetVideoFramesCount/Decklink\_Input\_GetVideoFramesCountAsync API to get total and dropped frames for the Decklink source
- [ALL] VisioForge HW encoders update

## 15.5

- .Net 7 support
- Added NetworkDisconnect event support to MJPEG Low Latency IP camera engine
- Added Linux support for the VideoEditCoreX-based demos
- Added OnRTSPLowLatencyRAWFrame event to get RAW frames from RTSP stream, using RTSP Low Latency engine
- Added AutoTransitions property to the VideoEditCoreX engine
- System.Drawing.Rectangle and System.Drawing.Size types are replaced by VisioForge.Types.Rectangle and VisioForge.Types.Size in all crossplatform APIs
- MAUI samples (BETA) are added
- Improved compatibility with Snap Camera for MP4 HW encoding
- Online licensing updated
- Added Camera Light demo
- Added segments support in Media Player SDK .Net (Cross-platform engine)
- Added Playlist API in Media Player SDK .Net (Windows-only engine)
- Resolved issues with the "rtsp\_source\_create\_audio\_resampler" call in the RTSP Low Latency engine in Video Capture SDK .Net (Windows-only engine)
- Added support for multiple Decklink outputs in Video Capture SDK .Net and Video Edit SDK .Net (Windows-only engine)
- Resolved issues with the reverse playback engine in Media Player SDK .Net (Windows-only engine)
- ONVIFControl and other ONVIF-related APIs are available for all platforms
- API breaking change: the frame rate changed from double to VideoFrameRate in all APIs
- Added GPU HW decoding for VLC engine
- Resolved issue with WPF HighDPI apps that use EVR
- Resolved issue with MediaPlayerCore.Video\_Renderer\_SetCustomWindowHandle method
- Added previous frame playback in Media Player SDK .Net (Cross-platform engine)
- Added WPF Screen Capture Demo to Media Blocks SDK .Net

## 15.4

- Resolved an issue with ignored Play\_PauseAtFirstFrame property
- Updated HighDPI support in WinForms samples
- Resolved an issue with HighDPI support for the Direct2D video renderer
- Added additional API to ONVIFControl class: GetDeviceCapabilities, GetMediaEndpoints
- Resolved forced reencoding issue with FFMPEG files joining without reencoding
- Sentry update
- Added video interpolation settings for Zoom and Pan video effects
- Added GtkSharp UI framework support for video rendering
- FastEdit API has been changed to async
- Resolved screen flip issue with Video\_Effects\_AllowMultipleStreams property of Video Capture SDK .Net core
- Updated RTSP MultiView demo (added GPU decoding, added RAW stream access)
- Added OnLoop event into Media Player SDK .Net
- Added Loop feature into Media Blocks SDK .Net
- Avalonia VideoView was downgraded to 0.10.12 because of Avalonia UI problems with NativeControl
- Added File Encryptor demo for Video Edit SDK .Net

## 15.3

- App start-up time improved for PCs with Decklink cards
- NDI SDK v5 support
- Resolved an issue with MKV Legacy output (wrong cast exception).
- Zoom and pan effects performance optimizations
- Added basic Media Blocks API (WIP)
- Added HLS network streaming to Video Edit SDK .Net
- Added Rotate property to WPF VideoView. You can rotate the video by 90, 180, or 270 degrees. Also, you can use the GetImageLayer() method to get the Image layer and apply custom transforms
- API change - FilterHelpers renamed to FilterDialogHelper
- VisioForge.Types and VisioForge.MediaFramework assemblies merged into VisioForge.Core
- UI classes moved to VisioForge.Core.UI.\* assemblies and independent NuGet packages
- VisioForge.Types renamed to VisioForge.Core.Types
- VisioForge.Core no longer depends on the Windows Forms framework

## 15.2

- Added HorizontalAlignment and VerticalAlignment properties to the text and image logos
- Updated ONVIF support, resolved an issue with username and password specified in URL but not specified in source settings
- Resolved an issue with the FFMPEG.exe output dialog
- Resolved an issue with the separate capture in a service applications
- SDK migrated to System.Text.Json from NewtonsoftJson
- Updated DirectCapture output for IP cameras
- Video processing performance optimizations
- IPCameraSourceSettings.URL property type changed from string to a `System.Uri`
- Added DirectCapture ASF output for IP cameras

## 15.1

- Disabled Sentry debug messages in the console
- Added Icecast streaming
- VideoStreamInfo.FrameRate property type changed to VideoFrameRate (with numerator and denominator) from double
- Updated WPF VideoView, resolved the issue for IP camera stream playback
- API breaking change: `VisioForge.Controls`, `VisioForge.Controls.UI`, `VisioForge.Controls.UI.Dialogs`, and `VisioForge.Tools` assemblies are merged inside the `VisioForge.Core` assembly
- Audio effect API now uses string name instead of index
- Added Android support in Media Player SDK .Net
- Added a new GStreamer-based cross-platform engine to support Windows and other platforms within the v15 development cycle

## 15.0

- Added StatusOverlay property for VideoCapture class. Assign the `TextStatusOverlay` object to this property to add text status overlay, for example, to show "Connecting..." text during IP camera connecting.
- RTSP Live555 IP camera engine has been removed. Please use RTSP Low Latency or FFMPEG engines.
- Resolved SDK\_Version possible issue.
- Added Settings\_Load API. You can load the settings file saved by Settings\_JSON. Be sure that device names are correct.
- Resolved issue with an exception if separate capture started before Start/StartAsync method call.
- RTP support for the VLC source engine.
- API breaking change: SDK\_State property has been removed. We do not have TRIAL and FULL SDK versions anymore.
- API breaking change: DirectShow\_Filters\_Show\_Dialog, DirectShow\_Filters\_Has\_Dialog, Audio\_Codec\_HasDialog, Audio\_Codec\_ShowDialog, Video\_Codec\_HasDialog, Video\_Codec\_ShowDialog, Filter\_Supported\_LAV, Filter\_Exists\_MatroskaMuxer, Filter\_Exists\_OGGMuxer, Filter\_Exists\_VorbisEncoder, Filter\_Supported\_EVR, Filter\_Supported\_VMR9 and Filter\_Supported\_NVENC has been moved to VisioForge.Tools.FilterHelpers class.
- The `VFAudioStreamInfo`/`VFVideoStreamInfo` classes use the `Timespan` for the duration.
- Decklink types from VisioForge.Types assembly moved to VisioForge.Types.Decklink namespace.
- Telemetry updated.
- Custom redist loader updated.
- NDI update.
- API breaking change: The `Status` property was renamed to the `State`. The property type is `PlaybackState` in all SDKs.
- API breaking change: UI controls split into Core (VideoCaptureCore, MediaPlayerCore, VideoEditCore) and VideoView.
- API breaking change: Video\_CaptureDevice... properties merged into Video\_CaptureDevice property of VideoCaptureSource type.
- API breaking change: Audio\_CaptureDevice... properties merged into Audio\_CaptureDevice property of AudioCaptureSource type.
- API breaking change: In the Media Player SDK, the `Source_Stream` API properties were merged into the `Source_MemoryStream` property of the `MemoryStreamSource` type
- Updated DVD playback
- Updated FFMPEG source
- API breaking change: Media Player SDK types moved from VisioForge.Types namespace to VisioForge.Types.MediaPlayer
- API breaking change: Video Capture SDK types moved from VisioForge.Types namespace to VisioForge.Types.VideoCapture
- API breaking change: Video Edit SDK types moved from VisioForge.Types namespace to "VisioForge.Types.VideoEdit"
- API breaking change: Output types moved from VisioForge.Types namespace to VisioForge.Types.Output
- API breaking change: Video Effects types moved from VisioForge.Types namespace to VisioForge.Types.VideoEffects
- API breaking change: Audio Effects types moved from VisioForge.Types namespace to VisioForge.Types.AudioEffects
- API breaking change: Event types moved from VisioForge.Types namespace to VisioForge.Types.Events
- Added Video\_Renderer\_SetCustomWindowHandle method to set custom video renderer by Win32 window/control HWND handle

## 14.4

- Windows 11 support
- Telemetry update
- Resolved issues with Picture-in-Picture in 2x2 mode
- Resolved issues with MJPEG Low Latency source in .Net 5/.Net 6/.Net Core 3.1
- Resolved issue with UDP network streaming for Decklink source
- VFMP4v11Output renamed to VFMP4HWOutput
- Added Microsoft H265 encoder support
- Added Intel QuickSync H265 encoder support
- Added OnDecklinkInputDisconnected/OnDecklinkInputReconnected events
- Updated Decklink output
- Resolved issues with Separate capture for MP4 HW, MOV, MPEG-TS, and MKVv2 outputs
- Added Video\_CaptureDevice\_CustomPinName property. You can use this property to set a custom output pin name for a video capture device with several output video pins
- Custom redist configuration updated
- Updated IP camera RTSP Low Latency engine

## 14.3

- An issue with Video Resize filter creation for NuGet redists has been resolved
- Telemetry update
- Updated VFDirectCaptureMP4Output output
- .Net 6 (preview) support
- Nvidia CUDA removed. NVENC is a modern alternative and is available for H264/HEVC encoding.
- IP camera MJPEG Low Latency engine has been updated
- The NDI source listing has been updated
- Improved ONVIF support
- Added .Net Core 3.1 support for RTSP Low Latency source engine
- Resolved issues with Picture-in-Picture for 2x2 mode
- Split project and solutions by independent files for .Net Framework 4.7.2, .Net Core 3.1, .Net 5 and .Net 6

## 14.2

- An issue with audio stream capture with enabled Virtual Camera SDK output was resolved
- VFMP4v8v10Output was replaced with VFMP4Output
- The "CanStart" method was added for Video\_CaptureDevices items. The method returns true if the device can start and is not used exclusively in another app
- Added async/await API to the ONVIFControl
- An issue with wrong ColorKey processing in the Text Overlay video effect was resolved
- Added forced frame rate support for the RTSP Low Latency IP camera source
- MP4v11 AMD encoders were updated
- The timestamp issue that happened during the MP4v11 separate capture pause/resume was resolved
- FFMPEG.exe network streaming update
- FFMPEG output was updated to the latest FFMPEG version
- VC++ redist is no longer required to be installed. VC++ linking changed to static (except optional XIPH output)
- Many base DirectShow filters moved to the VisioForge\_BaseFilters module

## 14.1

- Added WPF VideoView control. You can push video frames from the OnVideoFrameBuffer event to control to render them
- Correct default transparency value for a text logo
- ONVIF support added to .Net 5 / .Net Core 3.1 builds
- Added IP\_Camera\_ONVIF\_ListSourcesAsync method to discover ONVIF cameras in the local network
- (BREAKING API CHANGE) Changed video capture device API for frame rates enumerating to support modern 4K cameras
- Updated MJPEG Decoder (improved performance)
- Removed MP4 v8 legacy encoders
- INotifyPropertyChanged support in WinForms/WPF wrappers to provide MVVM application support
- Resolved issue with RTMPS streaming to Facebook
- IP camera source added to the TimeShift demo
- Added separate output support for MOV
- Added fast-start FFMPEG flag for MP4v11 output that used FFMPEG MP4 muxer
- Added GPU decoding for the IP Camera source in demo applications
- Added CustomRedist\_DisableDialog property to disable the redist message dialog
- Removed Kinect assemblies and demos. Please contact us if you still need Kinect packages
- MP4v10 default profile has been changed to Baseline / 5.0 for better browser compatibility

## 14.0

- .Net 5.0 support
- Resolved issue with not visible Decklink sources in NuGet SDK version
- Resolved issue with device added/removed notifier
- Added alternative NDI source in Video Capture SDK .Net
- Added NDI streaming (server) in Video Capture SDK .Net
- Resolved Separate Capture usage issue for NuGet deployment
- Resolved issue with merged text/image logos
- Updated device notifier
- Added CameraPowerLineControl class to control webcam power line frequency option
- Legacy audio effects have been removed.
- Removed HTTP\_FFMPEG, RTSP\_UDP\_FFMPEG, RTSP\_TCP\_FFMPEG and RTSP\_HTTP\_FFMPEG from VFIPSource enumeration. You can use the Auto\_FFMPEG value
- Updated HLS server. Correct error reporting about used port
- Added NDI streaming (server) in Video Edit SDK .Net
- Added NDI streaming (server) in Media Player SDK .Net
- Added IP\_Camera\_CheckAvailable method in Video Capture SDK .Net
- Updated FFMPEG Source filter, more supported codecs, and added GPU decoding

## 12.1

- Migrated to .Net 4.6
- Added Debug\_DisableMessageDialogs property to disable error dialog if OnError event is not implemented.
- Fixed issue with resizing on the pause for WPF controls.
- Updated ONVIF engine in Video Capture SDK .Net
- Updated What You Hear source in Video Capture SDK .Net
- Added OnPause/OnResume events
- Updated YouTube demo in Media Player SDK .Net
- Improved support of webcams with integrated H264 encoder in Video Capture SDK .Net
- Updated VLC source
- Removed unwanted warning in MP4 v11 output
- One installer for TRIAL and FULL versions
- Same NuGet packages for TRIAL and FULL versions
- .Net Core NuGet packaged merged with .Net Framework package
- Added NuGet redists. Deployment was never so simple!

## 12.0

- Async / await API for all SDKs
- Breaking API change: All time-related API now uses TimeSpan instead of long (milliseconds)
- Tag reader/writer - correct logo loading for some video formats
- Removed legacy DirectX 9 video effects
- Fixed audio conversion progress issue in Video Edit SDK .Net
- Improved .Net Core compatibility
- Virtual Camera SDK output added to Media Player SDK .Net (as one of the video renderers)
- NewTek NDI devices support added to Video Capture SDK .Net as a new engine for IP cameras
- Added Video\_Effects\_MergeImageLogos and Video\_Effects\_MergeTextLogos properties. If you have three or more logos, you can set these properties to true to optimize video effects' performance
- Added playlist type option for HLS network streaming
- Added integrated lightweight HTTP server for HLS network streaming
- Added VR 360° video support in Media Player SDK .Net
- Improved DirectX 11 video processing
- Added MPEG-TS AAC-only no video support for MPEG-TS output
- Improved What You Hear audio source
- Several new demo applications
- Improved MP4 v11 output
- Separate capture for MP4 v11 can split files without frame lose
- Many minor bugfixes
- .Net Core assemblies updated to .Net Core 3.1 LTS
- Updated demos repository on GitHub

## 11.4

- Added ASP.Net MVC video conversion demo app to Video Edit SDK .Net
- Alternative OSD implementation to handle Windows 10 changes
- Updated GPU video effects
- Updated memory source in Media Player SDK .Net
- Updated OSD API
- Resolved issues with video encryption using binary keys
- Update screen capture demos for Video Capture SDK .Net, added window selection to capture. You can capture any window, including windows in the background
- Mosaic effect added for Computer Vision demo in Video Capture SDK .Net
- Added Multiple IP Cameras Demo (WPF) in Video Capture SDK .Net
- Added custom video resize option for MP4v11 output
- Merge module (MSM) redists added to all SDKs
- Updated FFMPEG.exe output using pipes instead of virtual devices
- Resolved issue with PIP custom output resolution option in Video Capture SDK .Net
- Resolved issue with file lock using LAV engine in Media Player SDK .Net
- Added DirectX11-based GPU video processing

## 11.3

- Resolved issue with audio renderer connection if Virtual Camera SDK output enabled in Video Capture SDK
- Improved subtitles support with autoloading in Media Player SDK .Net
- Updated audio fade-in/fade-out effects
- Added MIDI and KAR files support in Media Player SDK .Net
- Added CDG karaoke files support (and new demo application) in Media Player SDK .Net
- Added Async playback in Media Player SDK .Net
- Updated integrated JSON serializer
- Added optional GPU decoding in Media Player SDK .Net. Available decoding engines: DXVA2, Direct3D 11, nVidia CUVID, Intel QuickSync
- Added .Net Core 3.0 support, including WinForms and WPF demo apps (Windows only)

## 11.2

- Added Loop property to Video Edit SDK .Net
- Updated audio enhancer
- Updated RTSP Low Latency source
- Resolved crop issue for Decklink source
- Added property to use TCP or UDP in RTSP Low Latency engine
- Deployment without COM registration and admin rights for Video Edit SDK and Media Player SDK (BETA)
- Updated video mixer with improved performance
- Added YouTube playback code snippet
- Added method to move OSD

## 11.1

- Fixed seeking issue with some MP4 files in Video Edit SDK
- Fixed stretch/letterbox issue in the WPF version of all SDKs
- Fixed issue with an equalizer on sample rate 16000 or less
- Fixed problem with sample grabber for DirectShow source in Media Player SDK
- Fixed encrypted files playback in Media Player SDK
- Added DVDInfoReader class to read info about DVD files
- Resolved issue with wrong file name in OnSeparateCaptureStopped event
- Improved barcode detection quality for rotated images
- The minimal .Net Framework version is .Net 4.5 now
- Improved YouTube playback in Media Player SDK. Added OnYouTubeVideoPlayback event to select video quality for playback
- Added the `Play_PauseAtFirstFrame` property to the Media Player SDK .Net. If true playback will be paused on the first frame
- Multiple screen support in Screen Capture demo in Video Capture SDK .Net
- Resolved issue with network stream playback in Media Player SDK .Net WPF applications
- Added low latency HTTP MJPEG stream playback (IP cameras or other sources) in Video Capture SDK .Net
- Added Fake Audio Source DirectShow filter, which produces a tone signal
- Updated Computer Vision demo in Video Capture SDK .Net
- Added Frame\_GetCurrentFromRenderer method to all SDKs. Using this method, you can get the currently rendered video frame directly from the video renderer.
- Added low latency RTSP source playback in Video Capture SDK .Net

## 11.0

- Fixed bug with MP4 v11 output, custom GOP settings
- Updated MJPEG Decoder
- Fixed bug with MP4 v11 output. Added Windows 7 full support
- OnStop event of Video Edit SDK returns a successful status
- Video Capture SDK Main Demo update - multiscreen can automatically use connected external displays
- Media Player SDK Main Demo update - multiscreen can automatically use connected external displays
- Added fade-in / fade-out for text logo
- Updated Decklink output
- Video Edit SDK can fast-cut files from network sources (HTTP/HTTPS)
- Added Computer Vision demo, with cars/pedestrian counter and face/eyes/nose/mouth detector/tracker
- Updated MP4 output to use alternative muxer that provides constant frame rate
- Added MPEG-TS output
- Added MOV output

---END OF PAGE---


## Deploy VisioForge .NET SDK on Android — NuGet & Setup
**URL:** https://www.visioforge.com/help/docs/dotnet/deployment-x/Android/
**Description:** Deploy VisioForge .NET SDK apps on Android. NuGet packages, VideoView integration, ARM64/x86 architecture support, and permissions configuration.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Android, C#, NuGet
**API:** VideoView, VideoPlayerActivity

# Android Implementation and Deployment Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to VisioForge SDKs for Android

Android developers working with .NET technologies can leverage the powerful capabilities of VisioForge SDKs to integrate advanced media functionality into their applications. The SDKs provide robust solutions for media manipulation, playback, capture, and editing on the Android platform using .NET technologies.

The VisioForge SDK for Android offers powerful capabilities for video processing, capturing, editing, and playback, all optimized for the Android platform while maintaining a consistent cross-platform development experience.

The Android deployment process requires special consideration for package management, device compatibility, permissions, and performance optimization. This document provides detailed instructions to ensure your application runs smoothly on Android devices.

## System Requirements

Before beginning your Android implementation and deployment process, ensure your development environment meets the following requirements:

### Device Requirements

- Android device running Android 9.0 (API level 28) or later
- ARM or ARM64 processor architecture
- Sufficient storage space for application assets and media processing
- Camera and microphone hardware (if using video/audio capture features)

### Development Environment Requirements

- Windows, Linux, or macOS computer
- Visual Studio with .NET MAUI or Xamarin workloads installed, JetBrains Rider, or Visual Studio Code
- .Net 8.0 SDK or later (latest stable version recommended)
- Android SDK with appropriate API levels installed
- Java Development Kit (JDK) 11 or later
- Basic knowledge of .NET development for Android

## Architecture Support

The VisioForge SDK for Android provides native support for common Android device architectures:

### ARM64 Support

- Optimized for modern Android devices
- Hardware-accelerated video processing
- Enhanced performance for media operations
- Primary target for most applications

### ARM/ARMv7 Support

- Compatibility with older Android devices
- Software fallbacks for hardware acceleration when needed
- Balanced performance and compatibility approach

## Installation and Setup Process

Follow these steps to properly set up and deploy your VisioForge-powered Android application:

1. Create a new Android project in your preferred IDE (Visual Studio or JetBrains Rider recommended).
2. Add the required NuGet packages to your project (detailed in the next section).
3. Configure necessary permissions in your AndroidManifest.xml file.
4. Implement your application logic using the VisioForge SDK components.
5. Build, sign, and deploy your application to test devices.

### NuGet Package Management

The VisioForge SDK for Android is distributed through NuGet packages. Add the following packages to your Android project:

- [VisioForge.DotNet.Core](https://www.nuget.org/packages/VisioForge.DotNet.Core) - Main managed SDK package (core classes, VideoCaptureCoreX / MediaPlayerCoreX / MediaBlocksPipeline).
- [VisioForge.CrossPlatform.Core.Android](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.Android) - Contains the redistribution components (native libraries) required for Android applications.

You can add these packages using the NuGet Package Manager in your IDE or by adding the following to your project file (use the latest versions):

```
<ItemGroup Condition="$(TargetFramework.Contains('-android'))">
  <PackageReference Include="VisioForge.DotNet.Core" Version="2026.*" />
  <PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.*" />
</ItemGroup>
```

Note: Replace version numbers with the latest available releases on NuGet.org.

The `VisioForge.CrossPlatform.Core.Android` package carries the native libraries for all four Android ABIs (`armeabi-v7a`, `arm64-v8a`, `x86`, `x86_64`) and wires them into the build automatically - no manual copy step is required. Two of them are only used by USB camera capture:

- `libVisioForge_UVC.so` - the USB Video Class bridge, with libuvc (BSD 3-Clause) compiled in.
- `libusb1.0.so` - libusb 1.0.30, dynamically linked and licensed under the LGPL v2.1 or later.

The full notices, including both licence texts, ship with the package as `THIRD-PARTY-NOTICES.txt`.

### USB camera permissions

Capturing from a USB (UVC) camera attached over OTG needs its own manifest entries in addition to the packages above:

```
<uses-permission android:name="android.permission.CAMERA" />
<uses-feature android:name="android.hardware.camera" android:required="false" />
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />
<uses-feature android:name="android.hardware.usb.host" android:required="true" />
```

Android refuses to hand a USB video device to an app that does not hold `android.permission.CAMERA`, even when the Android camera API is never used. Declaring that permission also makes a built-in camera an implied *requirement*, which would hide the app on Google Play from devices whose only camera arrives over USB - hence the explicit `required="false"`.

USB camera capture requires **Android 9 (API level 28) or newer**. For the full walkthrough see [USB camera capture on Android](../../general/guides/android-usb-camera/).

## Java Bindings Library Integration

Android applications using VisioForge SDK require a custom Java Bindings Library for proper functionality. This essential step ensures proper communication between the .NET framework and Android's Java-based environment.

Follow these detailed steps to integrate it:

1. Clone the binding-library repository from [GitHub](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/AndroidDependency).
2. Pick the binding project that matches the .NET target you build against — the folder ships one `VisioForge.Core.Android.X{N}.csproj` per supported .NET version (e.g., `VisioForge.Core.Android.X9.csproj` for .NET 9, `VisioForge.Core.Android.X10.csproj` for .NET 10). If your .NET target isn't listed, pick the closest supported one.
3. Add a reference to the binding project from your app's .csproj:

```
<ItemGroup>
  <ProjectReference Include="..\AndroidDependency\VisioForge.Core.Android.X10.csproj" />
</ItemGroup>
```

> **Note:** Make sure to adjust the relative path to match your project structure

## Implementing VideoView in Your Application

### Adding VideoView to Your Layout

The `VideoView` control is the primary interface for displaying video content in your Android application. To integrate it into your app, follow these steps:

1. Open your Activity or Fragment layout file (typically an `.axml` or `.xml` file)
2. Add the VideoView element as shown in the example below:

```
<VisioForge.Core.UI.Android.VideoView
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:minWidth="25px"
    android:minHeight="25px"
    android:id="@+id/videoView" />
```

### Initializing VideoView in Code

After adding the VideoView to your layout, you'll need to initialize it in your Activity or Fragment code:

```
using VisioForge.Core.UI.Android;

namespace YourApp
{
    [Activity(Label = "VideoPlayerActivity")]
    public class VideoPlayerActivity : Activity
    {
        private VideoView _videoView;

        protected override void OnCreate(Bundle savedInstanceState)
        {
            base.OnCreate(savedInstanceState);
            SetContentView(Resource.Layout.your_layout);

            // Initialize the video view
            _videoView = FindViewById<VideoView>(Resource.Id.videoView);
        }
    }
}
```

## Performance Considerations

Use physical Android devices for testing whenever possible. Simulators may not accurately represent real-world performance, especially for hardware-accelerated video operations.

## Application Signing and Publishing

### Application Signing

For distributing your Android application, you need to sign it with a digital certificate:

1. Create a keystore file if you don't already have one:

```
keytool -genkey -v -keystore your-app-key.keystore -alias your-app-alias -keyalg RSA -keysize 2048 -validity 10000
```

1. Configure signing in your project:

Add the following to your `android/app/build.gradle` file:

```
android {
    ...

    signingConfigs {
        release {
            storeFile file("your-app-key.keystore")
            storePassword "your-store-password"
            keyAlias "your-app-alias"
            keyPassword "your-key-password"
        }
    }

    buildTypes {
        release {
            signingConfig signingConfigs.release
            ...
        }
    }
}
```

For .NET MAUI or Xamarin.Android projects, configure signing in your .csproj file:

```
<PropertyGroup Condition="$(TargetFramework.Contains('-android')) and '$(Configuration)' == 'Release'">
    <AndroidKeyStore>True</AndroidKeyStore>
    <AndroidSigningKeyStore>your-app-key.keystore</AndroidSigningKeyStore>
    <AndroidSigningStorePass>your-store-password</AndroidSigningStorePass>
    <AndroidSigningKeyAlias>your-app-alias</AndroidSigningKeyAlias>
    <AndroidSigningKeyPass>your-key-password</AndroidSigningKeyPass>
</PropertyGroup>
```

### Publishing to Google Play Store

1. Generate an AAB (Android App Bundle) for distribution:

```
dotnet build -f net8.0-android -c Release /p:AndroidPackageFormat=aab
```

1. Create a developer account on the Google Play Console if you don't already have one.
2. Create a new application on the Google Play Console.
3. Upload your AAB file to the production track.
4. Complete the store listing information.
5. Submit for review.

## Troubleshooting

### Common Issues

1. **Missing Permissions**: Ensure all required permissions are declared in the AndroidManifest.xml and requested at runtime.
2. **Architecture Compatibility**: Verify your application supports the target device's architecture (ARM/ARM64).
3. **Memory Constraints**: Monitor memory usage and implement proper resource management.
4. **Performance Issues**: Use hardware acceleration and optimize media operations for mobile devices.
5. **Java Bindings Errors**: When facing issues with Java bindings:
6. Confirm you're using the correct binding library version
7. Check for version mismatches between .NET and the binding library
8. Verify all dependencies are properly referenced

### Getting Help

If you encounter issues with your VisioForge SDK deployment on Android, please consult:

- [Support Portal](https://support.visioforge.com)
- [GitHub Samples](https://github.com/visioforge/.Net-SDK-s-samples)

## Conclusion

Implementing and deploying VisioForge SDK applications to Android devices requires careful attention to platform-specific considerations. By following the guidelines in this document, you can ensure a smooth development and deployment process and deliver high-quality video applications to your Android users.

Remember to test thoroughly on target devices, especially for performance-intensive operations like video capture and processing. With proper implementation, the VisioForge SDK enables powerful media applications across the Android ecosystem.

---END OF PAGE---


## VisioForge Computer Vision NuGet Packages for .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/deployment-x/computer-vision/
**Description:** Deploy VisioForge CV and CVD NuGet packages for .NET computer vision on Windows, Linux, and macOS. Face detection, object recognition, and more.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows

# Computer Vision Implementation Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net), [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net), [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Overview of Available Packages

Our SDK provides two NuGet packages that deliver computer-vision capabilities for your applications:

1. **[VisioForge.DotNet.Core.CV](https://www.nuget.org/packages/VisioForge.DotNet.Core.CV/)** — Windows-only CV package.
2. **[VisioForge.DotNet.Core.CVD](https://www.nuget.org/packages/VisioForge.DotNet.Core.CVD/)** — Cross-platform CV package for Windows, Linux, and macOS.

Both packages provide a consistent API for integrating computer-vision features directly into your .NET applications.

## Deployment Requirements

### Windows-Specific CV Package

#### Installation Process

The Windows-specific CV package is designed for seamless integration:

- Simply install the NuGet package through your preferred package manager
- No additional deployment steps are necessary
- Ready to use immediately after installation

### Cross-Platform CVD Package

Our cross-platform CVD package requires specific configurations based on your operating system:

#### Windows Environment Setup

When deploying on Windows systems:

- Install the NuGet package through Visual Studio or the .NET CLI
- No additional dependencies or configurations are required
- Works out of the box with standard Windows installations

#### Ubuntu Linux Configuration

For Ubuntu Linux systems, install the following dependencies:

```
sudo apt-get install libgdiplus libopenblas-dev libx11-6
```

These packages provide essential functionalities:

- `libgdiplus`: Provides System.Drawing compatibility
- `libopenblas-dev`: Optimizes matrix operations for computer vision algorithms
- `libx11-6`: Handles X Window System protocol client library

#### macOS Setup Instructions

For macOS environments, use Homebrew to install the required dependencies:

```
brew install --cask xquartz
brew install mono-libgdiplus
```

These components enable:

- XQuartz: Provides X11 functionality on macOS
- mono-libgdiplus: Ensures compatibility with System.Drawing

## Additional Resources

For implementation examples and technical guidance:

- Visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) for extensive code samples
- Explore practical implementations across various use cases
- Access community-contributed examples and solutions

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## VisioForge .NET SDK Cross-Platform Deployment Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/deployment-x/
**Description:** Deploy .NET applications on Windows, macOS, iOS, Android, and Linux with native libraries, platform dependencies, and UI framework integration.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS

# Cross-Platform Deployment Guide for VisioForge .NET SDK

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to VisioForge SDK Deployment

The VisioForge SDK suite provides powerful multimedia capabilities for .NET applications, supporting video capture, editing, playback, and advanced media processing across multiple platforms. Proper deployment is critical to ensure your applications function correctly and leverage the full potential of these SDKs.

This comprehensive guide outlines the deployment process for applications built with VisioForge's cross-platform .NET SDKs, helping you navigate the specific requirements of each supported operating system.

## Deployment Overview

Deploying applications built with VisioForge SDKs requires careful consideration of platform-specific dependencies and configurations. The deployment process varies significantly depending on your target platform due to differences in:

- Native library requirements
- Media framework dependencies
- Hardware access mechanisms
- Package distribution methods

### Key Deployment Considerations

Before beginning the deployment process, consider these critical factors:

1. **Target Platform Architecture**: Ensure you select the appropriate architecture (x86, x64, ARM64) for your deployment platform
2. **Required Dependencies**: Some platforms require additional libraries that aren't included in NuGet packages
3. **Framework Compatibility**: Verify compatibility between your .NET version and the target operating system
4. **Native Library Integration**: Understand how native libraries are integrated and loaded on each platform
5. **UI Framework Selection**: Choose the appropriate UI integration package for your selected framework

## Platform-Specific Deployment

### Windows Deployment

Windows deployment is the most straightforward, with comprehensive NuGet package support covering all dependencies:

- **Package Distribution**: All components available via NuGet
- **Architecture Support**: Both x86 and x64 architectures fully supported
- **Native Libraries**: Automatically deployed alongside your application
- **UI Framework Options**: Windows Forms, WPF, WinUI, Avalonia, Uno, and MAUI supported

For detailed Windows deployment instructions, see the [Windows deployment guide](Windows/).

### Android Deployment

Android deployment requires specific configuration for native library extraction and permissions:

- **Package Distribution**: Core components available via NuGet
- **Architecture Support**: ARM64, ARMv7, and x86\_64 architectures supported
- **Native Libraries**: Requires proper configuration for extraction to the correct location
- **Permissions**: Camera, microphone, and storage permissions must be explicitly requested
- **UI Integration**: Android-specific video view controls required

Android applications use a single native library that must be correctly deployed. Review the [Android deployment guide](Android/) for complete instructions.

### macOS Deployment

macOS deployment requires additional GStreamer library installation:

- **Package Distribution**: Core components available via NuGet, GStreamer requires manual installation
- **Architecture Support**: Intel (x64) and Apple Silicon (ARM64) architectures supported
- **Native Libraries**: Multiple unmanaged libraries required
- **Framework Options**: Native macOS, MAUI, and Avalonia supported
- **Bundle Integration**: Special attention needed for proper app bundle structure

macOS deployments may require specific entitlements and permissions configurations. See the [macOS deployment guide](macOS/) for detailed instructions.

### iOS Deployment

iOS deployment involves unique challenges related to Apple's platform restrictions:

- **Package Distribution**: Core components available via NuGet
- **Architecture Support**: ARM64 architecture supported
- **App Store Guidelines**: Special considerations for App Store submissions
- **Native Libraries**: Single unmanaged binary library to deploy
- **UI Integration**: iOS-specific video view controls required

iOS applications require proper provisioning profiles and entitlements. The [iOS deployment guide](iOS/) provides comprehensive instructions.

### Ubuntu/Linux Deployment

Linux deployment requires manual installation of GStreamer dependencies:

- **Package Distribution**: Core components available via NuGet, GStreamer requires system packages
- **Architecture Support**: x64 architecture primarily supported
- **System Dependencies**: Required packages must be installed on the target system
- **Distribution Considerations**: Different Linux distributions may require different dependency packages
- **UI Options**: Primarily Avalonia UI framework supported

Linux deployment often involves distribution-specific package management. The [Ubuntu deployment guide](Ubuntu/) provides instructions for Ubuntu-based distributions.

### Uno Platform Deployment

Uno Platform enables deploying applications from a single codebase to multiple platforms:

- **Package Distribution**: Core components available via NuGet with platform-specific redistributables
- **Supported Platforms**: Windows, Android, iOS, macOS (Catalyst), WebAssembly, and Linux Desktop
- **Architecture Support**: Varies by target platform
- **Native Libraries**: Platform-specific redistributables required for each target
- **UI Integration**: Uno-specific VideoView control adapts to each platform

Uno Platform simplifies multi-platform development while leveraging native capabilities. See the [Uno Platform deployment guide](uno/) for comprehensive instructions.

### Runtime Requirements

Target devices must meet these minimum requirements:

- **Windows**: Windows 7 or later (x86 or x64)
- **macOS**: macOS 10.15 (Catalina) or later (x64 or ARM64)
- **iOS**: iOS 14.0 or later (ARM64)
- **Android**: Android 7.0 (API level 24) or later
- **Linux**: Ubuntu 20.04 LTS or later (x64 or ARM64)

## Common Deployment Challenges

### Native Library Loading Issues

One of the most common deployment problems involves native library loading failures:

- **Symptoms**: Runtime exceptions mentioning DllNotFoundException or similar
- **Causes**: Incorrect architecture, missing dependencies, or improper extraction
- **Solutions**: Verify package references, check deployment configuration, ensure libraries are in the correct location

### Permission and Security Constraints

Modern operating systems enforce strict security policies:

- **Camera Access**: Requires explicit permission on all mobile platforms
- **Storage Access**: File system restrictions vary by platform
- **Network Usage**: May require specific entitlements or manifest entries
- **Background Operation**: Platform-specific rules for background media processing

### Performance Considerations

Media processing can be resource-intensive:

- **CPU Usage**: Implement appropriate threading to avoid UI freezing
- **Memory Management**: Monitor and optimize memory usage for large media files
- **Power Consumption**: Balance quality settings with battery life considerations

## Deployment Checklist

Use this checklist to ensure a successful deployment:

- ✅ Correct NuGet packages selected for target platform and architecture
- ✅ Platform-specific dependencies installed and configured
- ✅ SDK properly initialized and cleaned up
- ✅ Appropriate video view controls integrated
- ✅ Required permissions requested and justified
- ✅ Application tested on target platform under realistic conditions
- ✅ Performance metrics validated for acceptable user experience
- ✅ Error handling implemented for graceful recovery

## Computer Vision Deployment

Computer Vision SDK is a separate NuGet package. Check the [Computer Vision deployment guide](computer-vision/) for more information.

## Additional Resources

- [VisioForge GitHub Repository](https://github.com/visioforge/.Net-SDK-s-samples) - Code samples and example projects
- [API Documentation](https://api.visioforge.org/dotnet/) - Comprehensive API reference
- [Support Portal](https://support.visioforge.com/) - Technical support and knowledge base

---END OF PAGE---


## iOS Deployment Guide for VisioForge .NET Video SDKs
**URL:** https://www.visioforge.com/help/docs/dotnet/deployment-x/iOS/
**Description:** Deploy .NET apps to iOS with VisioForge SDK integration, permissions, architecture support, and cross-platform deployment best practices.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, VideoCaptureCoreX, iOS, MAUI, Capture, Encoding, C#, NuGet, Entitlements
**API:** VideoView, IVideoView, VideoCaptureCoreX

# Apple iOS Deployment Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Overview

This comprehensive guide walks you through the process of deploying VisioForge SDK-powered applications to Apple iOS devices. The VisioForge SDK provides a powerful framework for building media-rich applications on iOS, offering robust support for video capture, editing, playback, and processing capabilities.

The iOS deployment process involves several key considerations, from package management to permission handling and performance optimization. This document will guide you through each step to ensure a smooth deployment experience.

## System Requirements

Before beginning your iOS deployment process, ensure your development environment meets the following requirements:

### Hardware Requirements

- Apple Mac computer for development (required for iOS app signing)
- iOS device for testing (strongly recommended over simulators)
- Sufficient storage space for development tools and application assets

### Software Requirements

- Apple iOS device running iOS 12 or later (latest version recommended)
- Xcode 12 or later with iOS SDK installed
- Apple Developer account (required for app signing and distribution)
- Visual Studio for Mac, JetBrains Rider, or Visual Studio Code
- .Net 7.0 SDK or later (we recommend the latest stable version)

## Architecture Support

The VisioForge SDK for iOS provides native support for both major iOS device architectures:

### ARM64 Support

- Compatible with all modern iOS devices (iPhone X and newer)
- Optimized native libraries for maximum performance
- Hardware-accelerated video processing where supported by the device

## Installation Process

Follow these steps to properly set up and deploy your VisioForge-powered iOS application:

1. Install the .Net SDK for iOS development
2. Create a new iOS project in your preferred IDE (Visual Studio for Mac or JetBrains Rider recommended)
3. Add the required NuGet packages to your project (detailed in the next section)
4. Configure the necessary permissions and entitlements in your app's Info.plist file
5. Implement your application logic using the VisioForge SDK components
6. Build, sign, and deploy your application to test devices

## NuGet Packages

The VisioForge SDK for iOS is distributed through NuGet packages:

### Core Packages

- [VisioForge.DotNet.Core](https://www.nuget.org/packages/VisioForge.DotNet.Core) - Core package containing core classes and UI controls, including video playback and display components. This is platform-independent and can be used in any .Net project.

### UI Packages

Each UI package has the same VideoView controls but different implementations for the target platform:

#### .Net iOS target platform

- [VisioForge.Core](https://www.nuget.org/packages/VisioForge.DotNet.Core) - Contains UI controls and all core classes for the iOS platform.

#### .Net MAUI target platform

- [VisioForge.DotNet.Core.UI.MAUI](https://www.nuget.org/packages/VisioForge.DotNet.Core.UI.MAUI) - Contains UI controls for the MAUI platform.

### Redist Packages

- [VisioForge.CrossPlatform.Core.iOS](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.iOS) - Contains the core redistribution components required for any iOS application using VisioForge technologies.

You can add these packages using the NuGet Package Manager in your IDE or by adding the following to your project file (use the latest versions):

```
<ItemGroup Condition="$(TargetFramework.Contains('-ios'))">
  <PackageReference Include="VisioForge.DotNet.Core" Version="2026.*" />
  <!-- The iOS redist version trails the SDK version on purpose - it tracks the
       GStreamer-iOS rebuild cadence, not the wrapper release. Do not bump it to
       match VisioForge.DotNet.*; there is no 2026.x on nuget.org. -->
  <PackageReference Include="VisioForge.CrossPlatform.Core.iOS" Version="2025.12.0" />
</ItemGroup>
```

Note: Replace version numbers with the latest available releases.

## Required Permissions and Entitlements

iOS applications require explicit permissions for accessing device features like cameras, microphones, and the photo library. Configure these permissions in your app's Info.plist file:

### Camera Access

Required for video capture functionality:

```
<key>NSCameraUsageDescription</key>
<string>This app requires camera access for video recording</string>
```

### Microphone Access

Required for audio recording:

```
<key>NSMicrophoneUsageDescription</key>
<string>This app requires microphone access for audio recording</string>
```

### Photo Library Access

Required for saving videos to the device's photo library:

```
<key>NSPhotoLibraryUsageDescription</key>
<string>This app requires access to the photo library to save videos</string>
```

### Example Info.plist Configuration

Here's a complete example of an Info.plist file with all necessary permissions:

```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>LSRequiresIPhoneOS</key>
    <true/>
    <key>UIDeviceFamily</key>
    <array>
        <integer>1</integer>
        <integer>2</integer>
    </array>
    <key>UIRequiredDeviceCapabilities</key>
    <array>
        <string>arm64</string>
    </array>
    <key>UISupportedInterfaceOrientations</key>
    <array>
        <string>UIInterfaceOrientationPortrait</string>
        <string>UIInterfaceOrientationLandscapeLeft</string>
        <string>UIInterfaceOrientationLandscapeRight</string>
    </array>
    <key>UISupportedInterfaceOrientations~ipad</key>
    <array>
        <string>UIInterfaceOrientationPortrait</string>
        <string>UIInterfaceOrientationPortraitUpsideDown</string>
        <string>UIInterfaceOrientationLandscapeLeft</string>
        <string>UIInterfaceOrientationLandscapeRight</string>
    </array>
    <key>XSAppIconAssets</key>
    <string>Assets.xcassets/appicon.appiconset</string>
    <key>NSCameraUsageDescription</key>
    <string>Camera access is required for video recording</string>
    <key>NSMicrophoneUsageDescription</key>
    <string>Microphone access is required for audio recording</string>
    <key>NSPhotoLibraryUsageDescription</key>
    <string>Photo library access is required to save videos</string>
</dict>
</plist>
```

## Runtime Permission Handling

In addition to declaring permissions in your Info.plist file, you should also request permissions at runtime. Here's an example of how to request camera and microphone permissions:

```
using System.Diagnostics;
using Photos;

// Request camera permission
private async Task RequestCameraPermissionAsync()
{
    var status = await Permissions.RequestAsync<Permissions.Camera>();
    if (status != PermissionStatus.Granted)
    {
        // Handle permission denial
        Debug.WriteLine("Camera permission denied");
    }
}

// Request microphone permission
private async Task RequestMicrophonePermissionAsync()
{
    var status = await Permissions.RequestAsync<Permissions.Microphone>();
    if (status != PermissionStatus.Granted)
    {
        // Handle permission denial
        Debug.WriteLine("Microphone permission denied");
    }
}

// Request photo library permission (iOS specific)
private void RequestPhotoLibraryPermission()
{
    PHPhotoLibrary.RequestAuthorization(status =>
    {
        if (status == PHAuthorizationStatus.Authorized)
        {
            Debug.WriteLine("Photo library access granted");
        }
        else
        {
            Debug.WriteLine("Photo library access denied");
        }
    });
}
```

## SDK Initialization

Properly initialize the VisioForge SDK in your application's lifecycle:

```
// In your AppDelegate or application startup code
public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
    // Initialize the VisioForge SDK
    VisioForge.Core.VisioForgeX.InitSDK();

    // Your other initialization code

    return true;
}

// Clean up on application termination
public override void WillTerminate(UIApplication application)
{
    // Clean up VisioForge SDK resources
    VisioForge.Core.VisioForgeX.DestroySDK();

    // Your other cleanup code
}
```

## Implementation Best Practices

### Using VideoView Controls

The VisioForge SDK provides a `VideoView` control for displaying video content. On iOS `VideoView` is a Metal-accelerated `MTKView` subclass that implements `IVideoView` directly (use `VideoViewGL` if you need the legacy OpenGL-backed `UIView` variant):

```
// Create a VideoView instance — VideoView implements IVideoView, so no casting/helper call is needed
var videoView = new VisioForge.Core.UI.Apple.VideoView(new CGRect(0, 0, UIScreen.MainScreen.Bounds.Width, UIScreen.MainScreen.Bounds.Height));
View.AddSubview(videoView);

// Pass the videoView itself where an IVideoView is expected
var captureCore = new VideoCaptureCoreX(videoView);
```

You can add the VideoView using a storyboard or code.

### Resource Management

iOS devices have limited resources compared to desktop computers. Follow these best practices:

1. Release resources when not in use
2. Use lower resolution settings for real-time processing
3. Implement proper lifecycle management in your ViewControllers
4. Test on actual devices, not just simulators

## Testing and Debugging

### Physical Device Testing

While the iOS simulator can be useful for basic interface testing, it has significant limitations for media applications:

- Simulator may have performance issues during video encoding at high resolutions
- Camera and microphone are not available in the simulator
- Hardware acceleration features may not be available or may behave differently

**Always test your media application on physical iOS devices before release.**

### Common Performance Considerations

When deploying media applications to iOS, consider these performance factors:

1. **Resolution and frame rate:** Lower these settings for better performance on older devices
2. **Encoder selection:** Use hardware-accelerated encoders when available
3. **Memory management:** Implement proper disposal of large objects and monitor memory usage
4. **Battery impact:** Media processing is power-intensive; implement power-saving measures

## Troubleshooting Common Issues

### Permission Denials

If your app can't access the camera or microphone:

1. Verify all required permissions are in your Info.plist
2. Check that you're requesting permissions at runtime before attempting to use the hardware
3. Test if the user has manually denied permissions in iOS Settings

### Library Loading Errors

If you encounter errors loading native libraries:

1. Verify all required NuGet packages are properly installed
2. Check for conflicting package versions
3. Ensure you're targeting the correct iOS architecture (ARM64)

## Additional Resources

- Visit the [VisioForge GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) for code samples and example projects
- Browse the [VisioForge API documentation](https://api.visioforge.org/dotnet/api/index.html) for comprehensive SDK reference

---

By following this deployment guide, you should be able to successfully create, configure, and deploy VisioForge-powered applications to iOS devices. For specific questions or advanced configuration needs, please contact VisioForge technical support.

---END OF PAGE---


## Deploy VisioForge .NET SDK on macOS — Intel & Apple Silicon
**URL:** https://www.visioforge.com/help/docs/dotnet/deployment-x/macOS/
**Description:** Deploy VisioForge .NET SDK apps on macOS. NuGet packages, NSView integration, App Store publishing, and native library setup for x64 and ARM64.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, macOS, MAUI, GStreamer, C#, NuGet, Entitlements
**API:** VideoView, VideoViewGL

# Apple macOS Deployment Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction

VisioForge's powerful .NET SDKs provide comprehensive media processing capabilities for macOS developers. Whether you're building video capture applications, media players, video editors, or complex media processing pipelines, our SDKs offer the tools you need to deliver high-quality solutions on Apple's platforms.

The VisioForge SDK provides comprehensive support for macOS application development using .NET technologies. You can leverage this SDK to build robust media processing applications that run natively on macOS, including support for both Intel (x64) and Apple Silicon (ARM64) architectures.

This guide covers everything you need to know to set up, configure, and deploy applications for macOS and MacCatalyst environments using the VisioForge SDK. Whether you're building traditional macOS applications or cross-platform solutions using frameworks like MAUI or Avalonia, this document will help you navigate the installation and deployment process.

## System Requirements

Before starting the installation and deployment process, ensure your development environment meets the following requirements:

### Hardware Requirements

- Mac computer with Intel processor (x64) or Apple Silicon (ARM64)
- Minimum 8GB RAM (16GB recommended for video processing)
- Sufficient disk space for development tools and application assets

### Software Requirements

- macOS 10.15 (Catalina) or later (latest version recommended)
- macOS Monterey (12.x)
- macOS Ventura (13.x)
- macOS Sonoma (14.x)
- Future macOS releases (with ongoing updates)
- Xcode 12 or later with Command Line Tools installed
- .NET 6.0 SDK or later
- Visual Studio for Mac or JetBrains Rider (recommended IDEs)

To install XCode Command Line Tools, run the following in Terminal:

```
xcode-select --install
```

## Architecture Support

The VisioForge SDK for macOS supports both major processor architectures:

### Intel (x64) Support

- Compatible with all Intel-based Mac computers
- Uses native x64 libraries for optimal performance
- Full feature support across all SDK components

### Apple Silicon (ARM64) Support

- Native support for M1, M2, and newer Apple Silicon chips
- Optimized ARM64 native libraries for maximum performance
- Hardware acceleration leveraging Apple's Neural Engine where applicable

### Universal Binary Considerations

When targeting both architectures, consider building universal binaries that include both x64 and ARM64 code. This approach ensures your application runs natively on either platform without relying on Rosetta 2 translation.

For universal binary builds targeting both Intel and Apple Silicon:

```
<PropertyGroup>
  <RuntimeIdentifiers>osx-x64;osx-arm64</RuntimeIdentifiers>
  <UseHardenedRuntime>true</UseHardenedRuntime>
</PropertyGroup>
```

## Core Technologies

VisioForge .NET SDKs leverage several key technologies to deliver high-performance media capabilities on macOS:

### GStreamer Integration

All VisioForge SDKs utilize GStreamer as the underlying framework for video/audio playback and encoding. GStreamer provides:

- Hardware-accelerated media processing
- Broad format compatibility
- Optimized playback pipeline
- Efficient encoding capabilities

The GStreamer components are automatically installed through our redistributable packages, eliminating the need for manual configuration.

## Installation and NuGet Package Deployment

The primary method for deploying VisioForge SDK components to macOS applications is through NuGet packages. These packages include all necessary managed and unmanaged libraries required for your application.

### Essential NuGet Packages

For native macOS applications, add these core packages:

1. **Main SDK Package** (based on your needs):
2. `VisioForge.DotNet.VideoCapture` for camera capture applications
3. `VisioForge.DotNet.VideoEdit` for video editing applications
4. `VisioForge.DotNet.MediaPlayer` for media playback applications
5. `VisioForge.DotNet.MediaBlocks` for advanced media processing pipelines
6. **UI Package**:
7. `VisioForge.DotNet.Core` includes Apple-specific UI controls
8. **Platform Redistributable**:
9. `VisioForge.CrossPlatform.Core.macOS` for native libraries and dependencies

### macOS Applications

For standard macOS applications targeting the `netX.0-macos` framework (where X represents the .NET version), use the following NuGet package:

- [VisioForge.CrossPlatform.Core.macOS](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.macOS)

This package contains:

- Native libraries for media processing
- GStreamer components for media playback and encoding
- Interface assemblies for .NET integration
- Both x64 and ARM64 binaries

### Computer Vision with OpenCV

For applications requiring advanced image processing and computer vision capabilities, add:

- [VisioForge.CrossPlatform.OpenCV.macOS](https://www.nuget.org/packages/VisioForge.CrossPlatform.OpenCV.macOS)

The package ships one universal (x64 + ARM64) GStreamer plugin with OpenCV linked into it, so there are no separate OpenCV libraries to deploy, plus the Haar cascade files `CVFaceDetectBlock`, `CVFaceBlurBlock` and `CVHandDetectBlock` load by default. It provides the Media Blocks in the `VisioForge.Core.MediaBlocks.OpenCV` namespace:

- Image transformation: `CVDewarpBlock`, `CVDilateBlock`, `CVErodeBlock`
- Edge and feature detection: `CVEdgeDetectBlock`, `CVLaplaceBlock`, `CVSobelBlock`
- Face processing: `CVFaceBlurBlock`, `CVFaceDetectBlock`
- Motion detection: `CVMotionCellsBlock`
- Object recognition: `CVTemplateMatchBlock`, `CVHandDetectBlock`
- Image enhancement: `CVEqualizeHistogramBlock`, `CVSmoothBlock`
- Tracking and overlay: `CVTrackerBlock`, `CVTextOverlayBlock`
- Stabilization: `VideoStabilizationBlock`

### Getting Started with Native macOS Projects

To begin developing native macOS applications with VisioForge SDKs:

1. **Create a new macOS project** in your preferred IDE (Visual Studio for Mac or JetBrains Rider)
2. **Add required NuGet packages** (as detailed above)
3. **Configure project settings** for your target architecture

## MacCatalyst and MAUI Applications

### Cross-Platform Development with .NET MAUI

.NET Multi-platform App UI (MAUI) enables developing applications that run seamlessly across macOS, iOS, Android, and Windows from a single codebase. VisioForge provides comprehensive support for MAUI development through specialized packages and controls.

For MacCatalyst applications (including MAUI projects) targeting the `netX.0-maccatalyst` framework, use:

- [VisioForge.CrossPlatform.Core.macCatalyst](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.macCatalyst)

### MAUI Package Configuration

For MAUI projects targeting macOS (through MacCatalyst), add these packages:

```
<ItemGroup Condition="$(TargetFramework.Contains('-maccatalyst'))">
  <PackageReference Include="VisioForge.CrossPlatform.Core.macCatalyst" Version="2026.8.5" />
  <PackageReference Include="VisioForge.DotNet.Core.UI.MAUI" Version="2026.8.16" />
</ItemGroup>
```

### MAUI Project Setup

1. **Initialize SDK in MauiProgram.cs**:

```
builder
  .UseMauiApp<App>()
  .UseSkiaSharp()
  .ConfigureMauiHandlers(handlers => handlers.AddVisioForgeHandlers());
```

1. **Add VideoView Control in XAML**:

```
xmlns:vf="clr-namespace:VisioForge.Core.UI.MAUI;assembly=VisioForge.Core.UI.MAUI"

<vf:VideoView Grid.Row="0"
              HorizontalOptions="FillAndExpand"
              VerticalOptions="FillAndExpand"
              x:Name="videoView"
              Background="Black"/>
```

MacCatalyst applications require additional configuration to ensure native libraries are properly included in the application bundle. Add the following custom build target to your project file:

```
<Target Name="CopyNativeLibrariesToMonoBundle" AfterTargets="Build" Condition="$(TargetFramework.Contains('-maccatalyst'))">
    <Message Text="Starting CopyNativeLibrariesToMonoBundle target..." Importance="High"/>

    <PropertyGroup>
        <AppBundleDir>$(OutputPath)$(AssemblyName).app</AppBundleDir>
        <MonoBundleDir>$(AppBundleDir)/Contents/MonoBundle</MonoBundleDir>
    </PropertyGroup>

    <Message Text="AppBundleDir: $(AppBundleDir)" Importance="High"/>
    <Message Text="MonoBundleDir: $(MonoBundleDir)" Importance="High"/>

    <MakeDir Directories="$(MonoBundleDir)" Condition="!Exists('$(MonoBundleDir)')"/>

    <Copy SourceFiles="@(None-&gt;'%(FullPath)')" DestinationFolder="$(MonoBundleDir)" Condition="'%(Extension)' == '.dylib' Or '%(Extension)' == '.so'">
        <Output TaskParameter="CopiedFiles" ItemName="CopiedNativeFiles"/>
    </Copy>

    <Message Text="Copied native files:" Importance="High" Condition="@(CopiedNativeFiles) != ''"/>
    <Message Text=" - %(CopiedNativeFiles.Identity)" Importance="High" Condition="@(CopiedNativeFiles) != ''"/>

    <Message Text="Finished CopyNativeLibrariesToMonoBundle target." Importance="High"/>
</Target>
```

This target performs several crucial tasks:

1. Identifies the application bundle directory
2. Creates the MonoBundle directory if it doesn't exist
3. Copies all `.dylib` and `.so` native libraries to the MonoBundle directory
4. Outputs diagnostic information for troubleshooting

For complete MAUI integration details, see our dedicated [MAUI](../../install/maui/) documentation page.

## UI Framework Options

The VisioForge SDK supports multiple UI frameworks for macOS development:

### Native macOS UI

For traditional macOS applications, the SDK provides `VideoViewGL` controls that integrate with the native AppKit framework. These controls provide high-performance video rendering using OpenGL.

### MAUI

For cross-platform MAUI applications, use the [VisioForge.DotNet.Core.UI.MAUI](https://www.nuget.org/packages/VisioForge.DotNet.Core.UI.MAUI) package, which provides MAUI-compatible video views.

### Avalonia

For Avalonia UI applications, the [VisioForge.DotNet.Core.UI.Avalonia](https://www.nuget.org/packages/VisioForge.DotNet.Core.UI.Avalonia) package offers Avalonia-compatible video controls.

## Development Environment Setup

### JetBrains Rider Integration

JetBrains Rider provides an excellent development experience for macOS and iOS applications using VisioForge SDKs:

1. Create a new project in Rider targeting macOS or iOS
2. Add the required NuGet packages through the Package Manager
3. Configure project settings for your target platform
4. Add UI controls and implement SDK functionality

For detailed Rider setup instructions, see our [Rider integration guide](../../install/rider/).

### Visual Studio for Mac Setup

Despite its deprecation, Visual Studio for Mac still works for developing macOS and iOS applications with VisioForge SDKs:

1. Create a new project in Visual Studio for Mac
2. Add NuGet packages through the NuGet Package Manager
3. Configure necessary build settings
4. Add UI controls to your application's interface

For detailed Visual Studio for Mac instructions, see our [Visual Studio for Mac guide](../../install/visual-studio-mac/).

## SDK Initialization and Cleanup

X-engines in the VisioForge SDK require explicit initialization and cleanup to manage resources properly:

```
// Initialize SDK at application startup
VisioForge.Core.VisioForgeX.InitSDK();

// Use SDK components...

// Clean up resources before application exit
VisioForge.Core.VisioForgeX.DestroySDK();
```

For asynchronous initialization and cleanup, use the async variants:

```
// Async initialization
await VisioForge.Core.VisioForgeX.InitSDKAsync();

// Async cleanup
await VisioForge.Core.VisioForgeX.DestroySDKAsync();
```

## Troubleshooting Common Issues

### Native Library Loading Failures

If your application fails to load native libraries:

1. Verify all required NuGet packages are properly installed
2. Check the application bundle structure to ensure libraries are in the correct location
3. Use the `dtruss` or `otool` commands to diagnose library loading issues
4. Ensure XCode Command Line Tools are properly installed

### MacCatalyst-Specific Issues

For MacCatalyst deployment problems:

1. Verify the CopyNativeLibrariesToMonoBundle target is correctly implemented
2. Check that the MonoBundle directory contains all necessary native libraries
3. Ensure the application has appropriate entitlements for media access

### Performance Optimization

For optimal performance:

1. Enable hardware acceleration when available
2. Adjust video resolution based on device capabilities
3. Close and dispose of SDK objects when no longer needed

## Additional Resources

For code samples, example projects, and more technical resources:

- Visit the [VisioForge GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) for code samples
- Join the VisioForge developer community for support and discussions

Our samples repository contains comprehensive examples showing:

- Video capture from cameras
- Media playback implementations
- Video editing workflows
- Advanced media processing pipelines

## Conclusion

VisioForge .NET SDKs provide powerful media capabilities for macOS and iOS developers, enabling the creation of sophisticated multimedia applications. By following this installation and deployment guide, you've established the foundation for building high-performance media applications across Apple's platforms.

For any additional questions or support needs, please contact our technical support team or visit our forums for community assistance.

---

*This documentation is regularly updated to reflect the latest SDK features and compatibility information.*

---END OF PAGE---


## Deploy .NET Apps on Ubuntu with GStreamer and VisioForge SDK
**URL:** https://www.visioforge.com/help/docs/dotnet/deployment-x/Ubuntu/
**Description:** Deploy .NET multimedia apps on Ubuntu Linux with GStreamer setup, hardware configuration, and cross-platform performance optimization.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Linux, GStreamer, NuGet

# Ubuntu Deployment Guide for VisioForge SDK Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction

Deploying .NET applications with VisioForge SDKs on Ubuntu Linux offers multiple benefits, including cross-platform compatibility, access to Linux-specific hardware, and the ability to run your multimedia applications on environments ranging from server infrastructure to edge devices. This comprehensive guide will walk you through the complete process of configuring your Ubuntu environment, installing the necessary dependencies, and deploying your VisioForge-powered .NET application.

The VisioForge SDK family works on Ubuntu and other Linux distributions that support `GStreamer` libraries. Additional supported platforms include `Nvidia Jetson` devices and `Raspberry Pi`, making it perfect for a wide range of applications from desktop multimedia software to IoT solutions.

## System Requirements

Before deploying your application, ensure your Ubuntu environment meets these minimum requirements:

- Ubuntu 20.04 LTS or later (22.04 LTS and later recommended)
- .NET 7.0 or later runtime
- At least 4GB RAM (8GB recommended for video processing)
- x86\_64 or ARM64 architecture
- Internet connection for package installation

## Installation and Setup

### Installing .NET

Download the latest [.NET installer](https://dotnet.microsoft.com/en-us/download/dotnet) package from the Microsoft website and follow the installation instructions.

## GStreamer Installation

GStreamer forms the multimedia backbone for VisioForge SDKs on Linux platforms. It provides essential functionality for audio and video capture, processing, and playback.

### Required GStreamer Packages

Install the following GStreamer packages using apt-get. We require v1.22.0 or later, though v1.24.0+ is highly recommended for access to the latest features and optimizations:

- `gstreamer1.0-plugins-base`: Essential baseline plugins
- `gstreamer1.0-plugins-good`: High-quality, well-tested plugins
- `gstreamer1.0-plugins-bad`: Newer plugins of varying quality
- `gstreamer1.0-alsa`: ALSA audio support
- `gstreamer1.0-gl`: OpenGL rendering support
- `gstreamer1.0-pulseaudio`: PulseAudio integration
- `libges-1.0-0`: GStreamer Editing Services
- `gstreamer1.0-libav`: FFMPEG integration (OPTIONAL but recommended for broader format support)

### Complete Installation Script

The following commands will update your package repositories and install all required GStreamer components:

```
sudo apt update
```

```
sudo apt install gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-alsa gstreamer1.0-gl gstreamer1.0-pulseaudio gstreamer1.0-libav libges-1.0-0
```

### Raspberry Pi Additional Requirements

For Raspberry Pi, additionally, you need to install the following packages:

```
sudo apt install gstreamer1.0-libcamera
```

### Verifying GStreamer Installation

After installation, verify your GStreamer setup by running:

```
gst-inspect-1.0 --version
```

This should display the installed GStreamer version. Ensure it meets the minimum requirement (1.22.0+) or ideally shows 1.24.0 or later.

## Required NuGet Packages

When deploying your .NET application to Ubuntu, you'll need to include additional platform-specific NuGet packages that provide the necessary native libraries and bindings.

### Additional Core Linux Package

The [VisioForge.CrossPlatform.Core.Linux.x64](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.Linux.x64) package contains essential native libraries and bindings for the .NET Linux platform. This package is mandatory for all VisioForge SDK deployments on Ubuntu.

### Development Environment

You can use Rider to develop your project in Linux. Please check the [Rider](../../install/rider/) installation page for more information.

## Application Deployment

Follow these steps to deploy your application on Ubuntu:

### Publishing Your Application

To create a self-contained deployment that includes all .NET runtime dependencies:

```
dotnet publish -c Release -r linux-x64 --self-contained true
```

For smaller deployments where the target machine already has .NET installed:

```
dotnet publish -c Release -r linux-x64 --self-contained false
```

### Deployment Structure

Your deployment folder should contain:

- Your application executable
- Application DLLs
- VisioForge SDK assemblies
- Native Linux libraries from the VisioForge NuGet packages

### Setting Execution Permissions

Ensure your application executable has the proper permissions:

```
chmod +x ./YourApplicationName
```

## Hardware Considerations

### Camera Support

Ubuntu supports various camera types:

- **USB Webcams**: Most USB webcams work out of the box
- **IP Cameras**: Supported via RTSP, HTTP streams
- **Professional Cameras**: Many professional cameras with Linux drivers are supported
- **Virtual Devices**: v4l2loopback can be used for virtual camera creation

To list available camera devices:

```
v4l2-ctl --list-devices
```

### Audio Devices

Audio capture and playback is supported through:

- ALSA (Advanced Linux Sound Architecture)
- PulseAudio

To list available audio devices:

```
arecord -L  # For recording devices
aplay -L    # For playback devices
```

## Troubleshooting

### Permission Issues

Camera or audio device access issues can often be resolved by adding your user to the appropriate groups:

```
sudo usermod -a -G video,audio $USER
```

Remember to log out and back in for group changes to take effect.

### Performance Optimization

For optimal performance on Ubuntu:

- Use the latest GStreamer version (1.24.0+)
- Enable hardware acceleration where available
- For NVIDIA GPUs, install the appropriate CUDA and nvcodec packages
- Adjust process priority using `nice` for resource-intensive applications

## Conclusion

Deploying VisioForge SDK applications on Ubuntu provides a powerful, flexible environment for multimedia applications. By following this guide, you can ensure that your .NET application leverages the full capabilities of the VisioForge SDK ecosystem on Linux platforms.

For specific deployment scenarios or troubleshooting assistance, refer to the comprehensive documentation available on the VisioForge website or contact our technical support team.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Uno Platform Deployment Guide for VisioForge .NET SDKs
**URL:** https://www.visioforge.com/help/docs/dotnet/deployment-x/uno/
**Description:** VisioForge .NET SDK Uno Platform deployment with VideoView integration, multi-platform support for Windows, Android, iOS, macOS, and Linux.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, C++, Windows, macOS, Linux, Android, iOS, Uno, GStreamer, Streaming, Webcam, C#, NuGet

# Uno Platform Implementation and Deployment Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to VisioForge SDKs for Uno Platform

Uno Platform is a powerful cross-platform UI framework that enables developers to build native applications for Windows, Android, iOS, macOS, and Linux from a single codebase. VisioForge provides comprehensive support for Uno Platform applications through the `VisioForge.DotNet.Core.UI.Uno` package, which contains specialized UI controls designed specifically for the Uno Platform.

The Uno Platform deployment process requires special consideration for each target platform. This document provides detailed instructions to ensure your application runs smoothly across all supported platforms.

## Supported Platforms

VisioForge SDKs support the following Uno Platform targets:

| Platform | Framework Target | Status |
| --- | --- | --- |
| Windows Desktop | net10.0-windows10.0.19041.0 | ✔ Full Support |
| Android | net10.0-android | ✔ Full Support |
| iOS | net10.0-ios | ✔ Full Support |
| macOS (Catalyst) | net10.0-maccatalyst | ✔ Full Support |
| Linux Desktop (Skia) | net10.0-desktop | ✔ Full Support |

## System Requirements

Before beginning your Uno Platform implementation, ensure your development environment meets the following requirements:

### Development Environment Requirements

- Windows, Linux, or macOS computer
- Visual Studio 2022 with Uno Platform extension, JetBrains Rider, or Visual Studio Code
- .NET 10.0 SDK or later (latest stable version recommended)
- Uno Platform templates installed

### Platform-Specific Requirements

#### Windows

- Windows 10 version 17763 or later
- Windows App SDK 1.4+

#### Android

- Android SDK with appropriate API levels
- Android 5.0 (API 21) or later device
- Java Development Kit (JDK) 11 or later

#### iOS/macOS

- Mac computer with Xcode 15+ installed (for iOS/macOS builds)
- Apple Developer account (for device deployment)
- iOS 15.0 or later / macOS 10.15 or later

#### Linux

- GStreamer runtime installed
- X11 or Wayland display server

## Installation and Setup Process

Follow these steps to properly set up and deploy your VisioForge-powered Uno Platform application:

### 1. Install Uno Platform Templates

```
dotnet new install Uno.Templates
```

### 2. Install Required Workloads

```
# For Android
dotnet workload install android

# For iOS/macOS
dotnet workload install ios maccatalyst
```

### 3. Create a New Uno Platform Project

```
dotnet new unoapp -o MyMediaApp
```

### 4. Add VisioForge NuGet Packages

Add the following packages to your project:

```
<ItemGroup>
  <PackageReference Include="VisioForge.DotNet.Core.UI.Uno" Version="2025.12.9" />
  <PackageReference Include="VisioForge.DotNet.Core" Version="2025.4.10" />
</ItemGroup>
```

### Platform-Specific Redistributables

Add platform-specific redistributable packages to your project:

#### Windows

```
<ItemGroup Condition="$(TargetFramework.Contains('-windows'))">
  <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.8.251106002" />
  <PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
  <PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />
</ItemGroup>
```

#### Android

```
<ItemGroup Condition="$(TargetFramework.Contains('-android'))">
  <PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.7.27" />
</ItemGroup>
```

Additionally, you'll need to add the Java Bindings Library. Clone it from our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/AndroidDependency) and add a reference:

```
<ItemGroup Condition="$(TargetFramework.Contains('-android'))">
  <ProjectReference Include="..\AndroidDependency\VisioForge.Core.Android.X10.csproj" />
</ItemGroup>
```

#### iOS

```
<ItemGroup Condition="$(TargetFramework.Contains('-ios'))">
  <PackageReference Include="VisioForge.CrossPlatform.Core.iOS" Version="2025.12.0" />
</ItemGroup>
```

#### macOS (Catalyst)

```
<ItemGroup Condition="$(TargetFramework.Contains('-maccatalyst'))">
  <PackageReference Include="VisioForge.CrossPlatform.Core.macCatalyst" Version="2026.8.5" />
</ItemGroup>
```

For macOS Catalyst, you also need to add a custom MSBuild target to copy native libraries to the app bundle:

```
<Target Name="CopyNativeLibrariesToMonoBundle" AfterTargets="Build" Condition="$(TargetFramework.Contains('-maccatalyst'))">
  <PropertyGroup>
    <AppBundleDir>$(OutputPath)$(AssemblyName).app</AppBundleDir>
    <MonoBundleDir>$(AppBundleDir)/Contents/MonoBundle</MonoBundleDir>
  </PropertyGroup>
  <MakeDir Directories="$(MonoBundleDir)" Condition="!Exists('$(MonoBundleDir)')" />
  <Copy SourceFiles="@(None->'%(FullPath)')" DestinationFolder="$(MonoBundleDir)"
        Condition="'%(Extension)' == '.dylib' Or '%(Extension)' == '.so'">
    <Output TaskParameter="CopiedFiles" ItemName="CopiedNativeFiles" />
  </Copy>
</Target>
```

#### Linux Desktop

For Linux, you need to install GStreamer runtime on your system:

```
# Ubuntu/Debian
sudo apt-get install gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly gstreamer1.0-libav

# Fedora
sudo dnf install gstreamer1-plugins-base gstreamer1-plugins-good gstreamer1-plugins-bad-free gstreamer1-plugins-ugly-free
```

### Complete Sample Project File

Here is a complete example `.csproj` file for an Uno Platform application with VisioForge SDK:

```
<Project Sdk="Uno.Sdk">
  <PropertyGroup>
    <!-- Target frameworks based on build OS -->
    <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('windows'))">net10.0-windows10.0.19041;net10.0-android</TargetFrameworks>
    <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('osx'))">net10.0-maccatalyst;net10.0-ios;net10.0-android</TargetFrameworks>
    <OutputType>Exe</OutputType>
    <UnoSingleProject>true</UnoSingleProject>
    <UseCurrentXcodeSDKVersion>true</UseCurrentXcodeSDKVersion>

    <!-- Application settings -->
    <ApplicationTitle>MyMediaApp</ApplicationTitle>
    <ApplicationId>com.yourcompany.mymediaapp</ApplicationId>
    <ApplicationDisplayVersion>1.0</ApplicationDisplayVersion>
    <ApplicationVersion>1</ApplicationVersion>
    <ApplicationPublisher>Your Company</ApplicationPublisher>
    <Description>Media application powered by Uno Platform and VisioForge.</Description>

    <UnoFeatures></UnoFeatures>
  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
    <CodesignKey>Apple Development</CodesignKey>
  </PropertyGroup>

  <!-- VisioForge Core References -->
  <ItemGroup>
    <PackageReference Include="VisioForge.DotNet.Core.UI.Uno" Version="2025.12.9" />
    <PackageReference Include="VisioForge.DotNet.Core" Version="2025.4.10" />
  </ItemGroup>

  <!-- Windows Platform -->
  <ItemGroup Condition="$(TargetFramework.Contains('-windows'))">
    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.8.251106002" />
    <PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
    <PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />
  </ItemGroup>

  <!-- Android Platform -->
  <ItemGroup Condition="$(TargetFramework.Contains('-android'))">
    <PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.7.27" />
    <ProjectReference Include="..\AndroidDependency\VisioForge.Core.Android.X10.csproj" />
  </ItemGroup>

  <!-- iOS Platform -->
  <ItemGroup Condition="$(TargetFramework.Contains('-ios'))">
    <PackageReference Include="VisioForge.CrossPlatform.Core.iOS" Version="2025.12.0" />
  </ItemGroup>

  <!-- macOS Catalyst Platform -->
  <ItemGroup Condition="$(TargetFramework.Contains('-maccatalyst'))">
    <PackageReference Include="VisioForge.CrossPlatform.Core.macCatalyst" Version="2026.8.5" />
  </ItemGroup>

  <!-- macOS: Copy native libraries to app bundle -->
  <Target Name="CopyNativeLibrariesToMonoBundle" AfterTargets="Build"
          Condition="$(TargetFramework.Contains('-maccatalyst'))">
    <PropertyGroup>
      <AppBundleDir>$(OutputPath)$(AssemblyName).app</AppBundleDir>
      <MonoBundleDir>$(AppBundleDir)/Contents/MonoBundle</MonoBundleDir>
    </PropertyGroup>
    <MakeDir Directories="$(MonoBundleDir)" Condition="!Exists('$(MonoBundleDir)')" />
    <Copy SourceFiles="@(None->'%(FullPath)')" DestinationFolder="$(MonoBundleDir)"
          Condition="'%(Extension)' == '.dylib' Or '%(Extension)' == '.so'">
      <Output TaskParameter="CopiedFiles" ItemName="CopiedNativeFiles" />
    </Copy>
  </Target>
</Project>
```

## Platform-Specific Configuration

### Windows Configuration

Windows applications use native WinUI 3 rendering and support hardware acceleration via DirectX.

#### Required Capabilities

Add required capabilities to your `Package.appxmanifest`:

```
<Capabilities>
    <Capability Name="internetClient" />
    <uap:Capability Name="videosLibrary" />
    <uap:Capability Name="musicLibrary" />
    <DeviceCapability Name="microphone" />
    <DeviceCapability Name="webcam" />
</Capabilities>
```

### Android Configuration

#### Permissions

Add the necessary permissions to your `AndroidManifest.xml`:

```
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
```

#### Runtime Permission Requests

Request permissions at runtime in your code:

```
private async Task RequestPermissionsAsync()
{
    var status = await Permissions.RequestAsync<Permissions.Camera>();
    if (status != PermissionStatus.Granted)
    {
        // Handle permission denial
    }

    status = await Permissions.RequestAsync<Permissions.Microphone>();
    if (status != PermissionStatus.Granted)
    {
        // Handle permission denial
    }
}
```

### iOS Configuration

#### Info.plist Settings

Add required usage descriptions to your `Info.plist`:

```
<key>NSCameraUsageDescription</key>
<string>This app requires camera access for video capture</string>
<key>NSMicrophoneUsageDescription</key>
<string>This app requires microphone access for audio recording</string>
<key>NSPhotoLibraryUsageDescription</key>
<string>This app requires photo library access to save media</string>
```

#### App Transport Security

For HTTP streaming sources, configure App Transport Security:

```
<key>NSAppTransportSecurity</key>
<dict>
    <key>NSAllowsArbitraryLoads</key>
    <true/>
</dict>
```

### macOS (Catalyst) Configuration

macOS Catalyst applications share configuration with iOS. Additionally, configure runtime identifiers for both Intel and Apple Silicon:

```
<PropertyGroup Condition="$([MSBuild]::IsOSPlatform('osx')) AND '$([System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture)' == 'X64' AND $(TargetFramework.Contains('-maccatalyst'))">
  <RuntimeIdentifier>maccatalyst-x64</RuntimeIdentifier>
</PropertyGroup>
<PropertyGroup Condition="$([MSBuild]::IsOSPlatform('osx')) AND '$([System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture)' == 'Arm64' AND $(TargetFramework.Contains('-maccatalyst'))">
  <RuntimeIdentifier>maccatalyst-arm64</RuntimeIdentifier>
</PropertyGroup>
```

### Linux Desktop Configuration

For Linux desktop applications using Skia:

1. Ensure GStreamer is installed on the target system
2. Set appropriate environment variables if needed:

```
export GST_PLUGIN_PATH=/usr/lib/x86_64-linux-gnu/gstreamer-1.0
```

## Building for Different Platforms

### Windows

```
dotnet build -c Release -f net10.0-windows10.0.19041.0
```

### Android

```
dotnet build -c Release -f net10.0-android
```

### iOS

```
dotnet build -c Release -f net10.0-ios
```

### macOS

```
dotnet build -c Release -f net10.0-maccatalyst
```

### Linux Desktop

```
dotnet build -c Release -f net10.0-desktop
```

## Performance Considerations

- **Hardware Acceleration**: Enable hardware-accelerated rendering where available (Windows DirectX, Apple VideoToolbox, Android MediaCodec)
- **Physical Devices**: Always test on physical devices, especially for mobile platforms. Simulators may not accurately represent real-world performance
- **Memory Management**: Monitor memory usage, particularly on mobile devices when processing large media files
- **Network Streaming**: Use appropriate buffer sizes for network streaming to balance latency and smoothness

## Troubleshooting Common Issues

### Video Not Displaying

1. Verify the VideoView is properly initialized and added to the visual tree
2. Check that platform-specific redistributables are correctly installed
3. Ensure permissions are granted on mobile platforms

### Performance Issues

1. Check that hardware acceleration is enabled
2. Reduce video resolution for lower-powered devices
3. Monitor memory usage and optimize buffer sizes

### Build Errors

1. Verify all required workloads are installed
2. Check for NuGet package version compatibility
3. Ensure target framework versions match across all project references

---END OF PAGE---


## Windows Deployment Guide for VisioForge Cross-Platform SDK
**URL:** https://www.visioforge.com/help/docs/dotnet/deployment-x/Windows/
**Description:** VisioForge SDK .NET deployment for Windows with NuGet packages, dependencies, and x86/x64 architecture configuration for multimedia apps.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, USB3 Vision / GigE, NuGet
**API:** AWSS3SinkBlock, CVDewarpBlock, CVDilateBlock, CVErodeBlock

# Windows Installation and Deployment Guide for VisioForge Cross-Platform SDK

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to VisioForge SDK Installation and Deployment

The VisioForge SDK suite provides powerful multimedia capabilities for your .NET applications, supporting video capture, editing, playback, and advanced media processing across multiple platforms. This comprehensive guide covers both installation and deployment for Windows applications.

## Installation

SDKs are accessible in two forms: a setup file and NuGet packages. The setup file provides a straightforward installation process, ensuring that all necessary components are correctly configured. On the other hand, NuGet packages offer a flexible and modular approach to incorporating SDKs into your projects, allowing for easy updates and dependency management. We highly recommend utilizing NuGet packages due to their convenience and efficiency in managing project dependencies and updates.

When building your application, you have the option to create both x86 and x64 versions. This allows your application to run on a wider range of systems, accommodating different hardware architectures. However, it's important to note that the setup file is exclusively available for the x64 architecture. This means that while you can develop and compile x86 builds, the initial setup and installation process will require an x64 system.

### IDEs

For development, you can use powerful integrated development environments (IDEs) like JetBrains Rider or Visual Studio. Both IDEs offer robust tools and features to streamline the development process on Windows. To ensure a smooth setup, please refer to the respective installation guides. The [Rider installation page](../../install/rider/) provides detailed instructions for setting up JetBrains Rider, while the [Visual Studio installation page](../../install/visual-studio/) offers comprehensive guidance on installing and configuring Visual Studio. These resources will help you get started quickly and effectively, leveraging the full capabilities of these development environments.

## Distribution and Package Management

VisioForge SDK components for Windows are distributed as NuGet packages, making integration straightforward with modern .NET development environments. You can add these packages to your project using any of the following tools:

- Visual Studio Package Manager
- JetBrains Rider NuGet Manager
- Visual Studio Code with NuGet extensions
- Direct command-line integration using the .NET CLI

## Required Base Packages

Every Windows application built with VisioForge SDK requires the appropriate base package according to your application's target architecture. These packages contain the essential components for SDK functionality.

### Core Platform Packages

- [VisioForge.CrossPlatform.Core.Windows.x86](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.Windows.x86) - For 32-bit Windows applications
- [VisioForge.CrossPlatform.Core.Windows.x64](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.Windows.x64) - For 64-bit Windows applications

> **Note**: For applications targeting multiple architectures, you should include both packages and implement appropriate runtime selection logic.

## Optional Component Packages

Depending on your application's requirements, you may need to include additional packages for specialized functionality. These optional components extend the SDK's capabilities in various domains.

### FFMPEG Media Processing (Recommended)

These packages provide comprehensive codec support for a wide range of media formats through the FFMPEG library integration:

- [VisioForge.CrossPlatform.Libav.Windows.x86](https://www.nuget.org/packages/VisioForge.CrossPlatform.Libav.Windows.x86) - 32-bit FFMPEG support
- [VisioForge.CrossPlatform.Libav.Windows.x64](https://www.nuget.org/packages/VisioForge.CrossPlatform.Libav.Windows.x64) - 64-bit FFMPEG support

For applications with size constraints, compressed versions of these packages utilizing UPX compression are available:

- [VisioForge.CrossPlatform.Libav.Windows.x86.UPX](https://www.nuget.org/packages/VisioForge.CrossPlatform.Libav.Windows.x86.UPX) - Compressed 32-bit FFMPEG support
- [VisioForge.CrossPlatform.Libav.Windows.x64.UPX](https://www.nuget.org/packages/VisioForge.CrossPlatform.Libav.Windows.x64.UPX) - Compressed 64-bit FFMPEG support

### Cloud Integration - Amazon Web Services

For applications requiring cloud storage integration with AWS S3:

- [VisioForge.CrossPlatform.AWS.Windows.x86](https://www.nuget.org/packages/VisioForge.CrossPlatform.AWS.Windows.x86) - 32-bit AWS support
- [VisioForge.CrossPlatform.AWS.Windows.x64](https://www.nuget.org/packages/VisioForge.CrossPlatform.AWS.Windows.x64) - 64-bit AWS support

When using these packages, the following Media Block becomes available:

- `AWSS3SinkBlock` - For storing media in S3 buckets

### Computer Vision with OpenCV

For applications requiring advanced image processing and computer vision capabilities:

- [VisioForge.CrossPlatform.OpenCV.Windows.x86](https://www.nuget.org/packages/VisioForge.CrossPlatform.OpenCV.Windows.x86) - 32-bit OpenCV support
- [VisioForge.CrossPlatform.OpenCV.Windows.x64](https://www.nuget.org/packages/VisioForge.CrossPlatform.OpenCV.Windows.x64) - 64-bit OpenCV support

The OpenCV integration provides access to Media Blocks in the `VisioForge.Core.MediaBlocks.OpenCV` namespace, including:

- Image transformation: `CVDewarpBlock`, `CVDilateBlock`, `CVErodeBlock`
- Edge and feature detection: `CVEdgeDetectBlock`, `CVLaplaceBlock`, `CVSobelBlock`
- Face processing: `CVFaceBlurBlock`, `CVFaceDetectBlock`
- Motion detection: `CVMotionCellsBlock`
- Object recognition: `CVTemplateMatchBlock`, `CVHandDetectBlock`
- Image enhancement: `CVEqualizeHistogramBlock`, `CVSmoothBlock`
- Tracking and overlay: `CVTrackerBlock`, `CVTextOverlayBlock`

## Specialized Hardware Support Packages

VisioForge SDK provides integration with professional camera systems and specialized hardware. Include the appropriate package when working with specific device types.

### Allied Vision Cameras

For integrating with professional Allied Vision camera hardware:

- [VisioForge.CrossPlatform.AlliedVision.Windows.x64](https://www.nuget.org/packages/VisioForge.CrossPlatform.AlliedVision.Windows.x64)

### Basler Cameras

For applications working with Basler industrial cameras:

- [VisioForge.CrossPlatform.Basler.Windows.x64](https://www.nuget.org/packages/VisioForge.CrossPlatform.Basler.Windows.x64)

### Teledyne/FLIR Cameras (Spinnaker SDK)

For thermal imaging and specialized FLIR cameras:

- [VisioForge.CrossPlatform.Spinnaker.Windows.x64](https://www.nuget.org/packages/VisioForge.CrossPlatform.Spinnaker.Windows.x64)

### GenICam Protocol Support (GigE/USB3 Vision)

For cameras utilizing the standardized GenICam protocol:

- [VisioForge.CrossPlatform.GenICam.Windows.x64](https://www.nuget.org/packages/VisioForge.CrossPlatform.GenICam.Windows.x64)

## Deployment Best Practices

When deploying VisioForge-based applications for Windows, consider these recommendations:

1. Choose the appropriate architecture packages (x86 or x64) based on your target platform
2. Include the FFMPEG packages for comprehensive media format support
3. Only include specialized hardware packages when needed to minimize deployment size
4. For security-sensitive applications, consider using the UPX compressed versions to obfuscate native libraries
5. Always test your deployment on a clean system to ensure all dependencies are properly resolved

## The shared native plugin cache

At start-up the SDK does not load its GStreamer libraries from your application's output folder directly. It mirrors that folder's `x64`, `x86` or `arm64` subfolder into a shared location and loads from there:

```
%PUBLIC%\.gstreamer\<sdk-version>-<native-set>\<arch>
```

GStreamer keeps a plugin registry that records each plugin by its **absolute path**. A single canonical folder therefore lets every VisioForge application on the machine share one warm registry, so only the first start after an SDK upgrade pays the cost of scanning the plugin set; every later start on any application reuses it. The folder also stays writable, which an installed application's own directory under `Program Files` is not.

The folder is keyed to the SDK version **and** to a stamp of the core and Libav redistributables the application actually deployed - the `VisioForge.CrossPlatform.*` packages version independently of the managed SDK - so applications carrying different redistributables no longer overwrite each other's libraries on every start. Two deployments differing only in a package neither marker covers (OpenCV, AWS, a camera vendor's) do still share a folder; the file names in those packages are disjoint from everything else, so the effect is a few files being re-copied, not a wrong library being loaded. A cache the SDK created and nothing has started for 30 days is removed; a folder left by an older SDK that used the previous shared layout is left alone, because applications built on that release still load from it.

Two consequences worth knowing when you test a deployment:

- The cache accumulates the libraries of every application of that SDK version on the machine. A development box that has run a fuller package set can therefore satisfy a dependency your application does not actually ship - and the same application then fails on a clean machine.
- Clearing `%PUBLIC%\.gstreamer` is safe at any time; the next start rebuilds it.

To take the shared cache out of the picture and load exactly what your application deployed, point `VisioForgeX.CacheFolder` at your own native folder **before** calling `InitSDK`:

```
VisioForgeX.CacheFolder = Path.Combine(AppContext.BaseDirectory, "x64");
VisioForgeX.InitSDK();
```

This is the right setting for verifying that a redistributable is complete, and for an application that must not write outside its own directory. The cost is that the application no longer shares the machine-wide registry and scans the plugin set itself on every first start.

MAUI, WinUI 3 and Unity applications always load in place and never use the shared cache.

## Troubleshooting Common Issues

### Deployment Issues

If you encounter issues after deployment:

1. Verify all required NuGet packages are properly included
2. Check that the architecture (x86/x64) matches your application target
3. Ensure native libraries are being extracted to the correct locations
4. Review Windows security and permission settings that might restrict media functionality

### WinForms RESX Files Build Issue

Sometimes you can get the following error:

`Error MSB3821: Couldn't process file Form1.resx due to its being in the Internet or Restricted zone or having the mark of the web on the file. Remove the mark of the web if you want to process these files.`

Error MSB3821 occurs when Visual Studio or MSBuild cannot process a `.resx` resource file because it is marked as untrusted. This happens when the file has the "Mark of the Web" (MOTW), a security feature that flags files downloaded from the internet or received from untrusted sources. The MOTW places the file in the Internet or Restricted security zone, preventing it from being processed during a build.

#### How to Fix It

To resolve this error, you need to remove the MOTW from the affected file:

##### Unblock the File Manually

- Right-click on Form1.resx in File Explorer.
- Select Properties.
- In the General tab, check for an Unblock button or checkbox at the bottom.
- Click Unblock, then click OK.

##### Unblock via PowerShell (for multiple files)

- Open PowerShell.
- Navigate to your project directory.
- Run the command: Get-ChildItem -Path . -Recurse | Unblock-File

##### Unblock the ZIP Before Extraction

- If you downloaded the project as a ZIP file, right-click the ZIP file.
- Select Properties.
- Click Unblock, then extract the files.

By unblocking the file, you remove the MOTW, allowing Visual Studio to process it normally during the build.

For additional assistance, visit the [VisioForge support site](https://support.visioforge.com/) or consult the [API documentation](https://api.visioforge.org/dotnet/api/index.html).

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Audio Event Detection SDK for .NET — YAMNet AudioSet
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/audio-event-detection/
**Description:** Detect real-world sounds — siren, dog bark, glass break, alarm, music, speech — in live or file audio on-device with a YAMNet AudioSet classifier.
**Tags:** .NET, AI, YAMNet, AudioSet, Audio Event Detection, Sound Classification, Sound Recognition, Surveillance, VideoCaptureCoreX, MediaPlayerCoreX
**API:** AudioEventDetectorBlock, AudioEventDetectorSettings, AudioEventArgs, AudioEventScore, AudioScoresEventArgs

# Audio Event Detection — AudioEventDetectorBlock

`AudioEventDetectorBlock` is an audio-only Media Block from `VisioForge.DotNet.Core.AI`. It taps the audio stream, resamples it to 16 kHz mono, and runs a **YAMNet** (Google, AudioSet) ONNX classifier over short windows to recognize real-world sounds — siren, dog bark, glass break, alarm, music, speech and hundreds more (521 AudioSet classes). Audio passes through unchanged. The block implements `IAudioProcessingBlock`, so it can be inserted into a manual pipeline or registered on `VideoCaptureCoreX`/`MediaPlayerCoreX`. This is a natural companion to the object-analytics and PTZ features for surveillance and monitoring.

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.Types.X.AI;
using VisioForge.Core.Types.X.Sources;
```

## Basic block setup

```
var settings = new AudioEventDetectorSettings(yamnetModelPath)
{
    Threshold = 0.5f,        // confidence a class must reach to fire
    SmoothingWindows = 3,    // moving average that suppresses one-window blips
};

var detector = new AudioEventDetectorBlock(settings);
detector.OnAudioEvent += (sender, e) =>
{
    // Raised on a background worker thread — marshal to the UI thread before touching UI.
    Console.WriteLine($"{e.Label} ({e.Confidence:F2}) [{e.Start:mm\\:ss} - {e.End:mm\\:ss}]");
};
```

Wire it between an audio source and a sink (or any downstream audio block):

```
var source = new UniversalSourceBlock(
    await UniversalSourceSettings.CreateAsync(mediaFile, renderVideo: false, renderAudio: true));

// Unsynced: an offline file is analyzed as fast as the model allows.
// Keep IsSync = true (the default) for a live source you also want to monitor.
var sink = new NullRendererBlock(MediaBlockPadMediaType.Audio) { IsSync = false };

pipeline.Connect(source.AudioOutput, detector.Input);
pipeline.Connect(detector.Output, sink.Input);

await pipeline.StartAsync();
```

## Using it with VideoCaptureCoreX and MediaPlayerCoreX

`AudioEventDetectorBlock` implements `IAudioProcessingBlock`, so instead of building a manual pipeline you can register it on an X engine. The block **must be added before the session starts** — the processing block list is consumed while the pipeline is built, and a block added later is ignored.

For capture, terminate the audio chain with a non-synced null renderer if you want analysis without speaker monitoring or recording:

```
core.Audio_Source = microphoneSettings;
core.Audio_OutputBlock = new NullRendererBlock(MediaBlockPadMediaType.Audio)
{
    IsSync = false,
};

var detector = new AudioEventDetectorBlock(settings);
detector.OnAudioEvent += Detector_OnAudioEvent;

core.Audio_Processing_AddBlock(detector); // before StartAsync
await core.StartAsync();
```

For playback, `Audio_Play` must be `true` for the audio chain to be built:

```
player.Audio_Play = true;
player.Audio_OutputBlock = new NullRendererBlock(MediaBlockPadMediaType.Audio)
{
    IsSync = false,
};

var detector = new AudioEventDetectorBlock(settings);
detector.OnAudioEvent += Detector_OnAudioEvent;

player.Audio_Processing_AddBlock(detector); // before OpenAsync / PlayAsync
await player.OpenAsync(source);
await player.PlayAsync();
```

See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the full `Audio_Processing_*`/`Audio_OutputBlock` API and lifecycle rules.

## How events are raised

The block classifies each `WindowSeconds` window, averages the model's per-frame scores, and smooths them with a moving average over `SmoothingWindows` windows. A per-class **hysteresis** (Schmitt trigger) then collapses one continuous sound into a single event: a class enters at `Threshold` and leaves at `Threshold * ReleaseRatio` (0.7 by default). `OnAudioEvent` fires **once per sound**, when it ends (drops below the release threshold) or at end-of-stream, carrying the full `Start`..`End` span and the peak `Confidence`. This means one continuous siren yields a single event with a duration, not a stream of duplicates.

`Start` and `End` are measured over the audio the block has actually analysed, counting from zero when the pipeline starts — they are not media positions. For straight-through playback or capture from the beginning the two are the same. They part company once audio is skipped or replayed underneath the block: seeking a `MediaPlayerCoreX` does not reset this clock, so after a seek the reported times no longer line up with positions in the file, and a gap in a live source leaves every later time early by the missing duration.

Inference runs on a dedicated background worker fed by an **unbounded** sample queue, so the streaming thread is never blocked and **the queue never discards samples to bound its own growth**: a source that outruns the worker (a live source on a slow provider, or a file decoded at full speed by an unsynced renderer) simply grows the backlog — 64 KB per buffered second at 16 kHz mono — which drains as soon as the worker catches up. Two designed exits stop the analysis instead of quietly dropping a fraction of it; both are described in the notes below. YAMNet is tiny — on the CPU, roughly 0.6 ms for the default 0.975 s window and 1.8 ms for the 5 s maximum (the cost follows the window's frame count), over 1000× real time either way, so the CPU provider is usually sufficient.

## Key settings

`AudioEventDetectorSettings(yamnetModelPath)`. Unlike the vision AI settings, this type does **not** derive from `OnnxInferenceSettings` — YAMNet consumes an audio waveform, not an image. Every property below is read **once, when the block is built** during `StartAsync` — set them before you start the pipeline; mutating the settings object afterwards has no effect.

| Property | Default | Description |
| --- | --- | --- |
| `ModelPath` | — | Absolute path to the YAMNet ONNX model. Required. |
| `Threshold` | 0.5 | Confidence a class must reach to start an event, clamped to 0.01–1 (a threshold of 0 could never be released and would latch every class). |
| `ReleaseRatio` | 0.7 | An active event ends below `Threshold * ReleaseRatio` (hysteresis), clamped to 0.01–1 for the same reason. |
| `SmoothingWindows` | 3 | Windows the scores are averaged over (1 disables smoothing). |
| `WindowSeconds` | 0.975 | Inference window length — one 0.96 s YAMNet patch plus a small margin; clamped 0.96–5 s. |
| `ClassFilter` | null | Optional allowlist of AudioSet class names (e.g. `"Siren"`, `"Dog"`). |
| `Provider` | `Auto` | ONNX execution provider (CPU is usually enough). |
| `EnableScoresEvent` | false | Raise `OnScores` (top-K) for every window, for a live meter. |
| `TopK` | 5 | Number of classes reported in the scores event. |

## Filtering to specific sounds

Pass a `ClassFilter` allowlist to report only the sounds you care about — for example an alarm watchdog that ignores everything else:

```
var settings = new AudioEventDetectorSettings(yamnetModelPath)
{
    ClassFilter = new[] { "Siren", "Emergency vehicle", "Police car (siren)", "Alarm", "Glass", "Gunshot, gunfire" },
};
```

Class names are the AudioSet display names and must match one exactly (case is ignored, but a typo, a singular/plural difference or an abbreviation is not). Unknown names are ignored with a warning **as long as at least one name resolves**. A non-empty filter in which **no** name resolves fails the block's build — `StartAsync` returns `false` and an error naming the unresolved entries is reported — rather than silently falling back to detecting all 521 classes.

## Live scores meter

Enable `OnScores` to receive the top-K class scores for every processed window (useful for a live level meter or a debugging view):

```
var settings = new AudioEventDetectorSettings(yamnetModelPath)
{
    EnableScoresEvent = true, // read once, when the pipeline starts — set it before StartAsync
    TopK = 5,
};

var detector = new AudioEventDetectorBlock(settings);
detector.OnScores += (sender, e) =>
{
    foreach (var s in e.Scores)
    {
        Console.WriteLine($"  {s.Label}: {s.Confidence:F2}");
    }
};
```

## Model

The block uses **YAMNet**, Google's MobileNet-v1 audio classifier trained on [AudioSet](https://research.google.com/audioset/), predicting 521 classes from the AudioSet ontology. The model consumes a 16 kHz mono waveform (the block handles resampling and down-mixing) and returns per-frame class scores. The weights are Apache-2.0. Your application supplies the model file and points `ModelPath` at it: the SDK NuGet packages ship neither the weights nor a downloader, and the block never fetches anything itself. The demo below has a **Download** button that fetches the model once and caches it; nothing is downloaded unless you click it.

**For production, convert the official Google TF-Hub model to ONNX yourself** rather than relying on a third-party ONNX export. The conversion is a format change only and does not alter the Apache-2.0 weights license:

```
pip install tensorflow tensorflow-hub tf2onnx onnx
python -c "import tensorflow_hub as hub, tensorflow as tf; m=hub.load('https://tfhub.dev/google/yamnet/1'); tf.saved_model.save(m, 'yamnet_tf')"
python -m tf2onnx.convert --saved-model yamnet_tf --output yamnet.onnx --opset 13
```

If you use a community ONNX export instead, pin it to an immutable revision and verify its SHA-256 — the WPF [Audio Event Detection Demo](#demos) downloads a pinned export of the Apache-2.0 weights and verifies the hash after download.

> Sound event recognition uses the AudioSet ontology and the YAMNet model by Google, released under the Apache-2.0 license.

## Demos

The `Audio Event Detection Demo` (WPF Media Blocks — model download with SHA-256 verification, class filter, live event log) is in the SDK's demo set and will be linked here once published to the public samples repository.

## Notes

- `OnAudioEvent` and `OnScores` are raised on the inference worker thread; marshal to the UI thread before updating UI. A throwing handler is caught and logged, never propagated onto the worker.
- At end-of-stream the trailing window and any still-active events are flushed before teardown.
- Under normal operation the block never drops audio — neither from the *pass-through* path nor from the analysis path. The internal analysis queue is unbounded: a source that outruns the worker grows the backlog instead of discarding samples, and the audio still passes downstream untouched.
- Two designed exits end the analysis rather than lose audio silently, and neither ever touches the *pass-through* path: if the backlog no longer fits in memory, the block reports an error once and stops analyzing that stream (use a GPU execution provider or faster hardware); and an explicit stop abandons the backlog the worker has not reached yet — only a natural end-of-stream drains it in full.

---END OF PAGE---


## AI Video Auto-Reframe SDK for .NET — AutoReframeBlock
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/auto-reframe/
**Description:** AI auto-reframe SDK for .NET — turn landscape footage into vertical 9:16 Shorts/Reels/TikTok video that follows the subject, on-device with ONNX YOLO.
**Tags:** .NET, AI, ONNX, Auto Reframe, Vertical Video, Reframe, YOLO, Shorts, Reels, Media Blocks SDK
**API:** AutoReframeBlock, AutoReframeSettings, AutoReframeTargetSelection, ReframeEventArgs

# AI Auto-Reframe (Subject-Following Vertical Video) — AutoReframeBlock

`AutoReframeBlock` converts landscape footage into a fixed output aspect ratio — typically vertical 9:16 for Shorts, Reels, and TikTok — by dynamically cropping around a detected subject and scaling the crop to the configured output resolution. It runs object detection on a sampled stream, follows the selected subject, smooths the crop position over time so it glides instead of jittering, and eases back to the frame center when no subject is present.

```
graph LR;
    Source-->AutoReframeBlock;
    AutoReframeBlock-->H264EncoderBlock;
    H264EncoderBlock-->MP4SinkBlock;
```

The block lives in `VisioForge.Core.AI` (`VisioForge.DotNet.Core.AI`), uses `AutoReframeSettings`, and has one video `Input` and one video `Output`. Internally it is a chain of an RGBA sample grabber (for detection) → `videocrop` → `videoscale` → `capsfilter` (output size) → `videoconvert`. Detection runs on the pipeline streaming thread, so a slow model can throttle the pipeline; keep `DetectionInterval` at a few frames to spread the cost.

## How it works

1. On each frame the block taps the RGBA pixels. Every `DetectionInterval` frames it runs the YOLO detector and picks a subject according to `TargetSelection` and `ClassLabelFilter`.
2. A crop window is centered on that subject. The crop window size is fixed for the whole run (it depends only on the source size, the source **pixel aspect ratio**, and the **output aspect ratio**), so only the crop **position** moves and downstream caps do not renegotiate per frame. Anamorphic (non-square-pixel) sources are cropped PAR-aware: the crop is sized in pixel space so its display aspect matches the output aspect, and the scale to the square-pixel output restores true display proportions.
3. The crop position is smoothed with an exponential moving average (`Smoothing`) and a dead zone (`DeadZoneFraction`) that suppresses micro-jitter, then clamped so the crop stays fully inside the frame.
4. The crop is applied live to `videocrop`, and `videoscale` + `capsfilter` scale it to `OutputWidth` x `OutputHeight`.
5. When no subject has been seen for longer than `LostTargetTimeout`, the crop eases back to the frame center.

## Settings

`AutoReframeSettings` is constructed with a `YoloDetectorSettings` (the detector used to locate subjects).

| Property | Default | Description |
| --- | --- | --- |
| `OutputWidth` | `1080` | Output width in pixels (positive, even). |
| `OutputHeight` | `1920` | Output height in pixels (positive, even). `1080x1920` is 9:16. |
| `DetectionInterval` | `5` | Run detection every N frames; the smoothed crop keeps gliding in between. |
| `Smoothing` | `0.85` | EMA retention factor in `[0, 1)`. Higher glides more slowly. |
| `DeadZoneFraction` | `0.05` | Dead-zone half-width as a fraction of the frame dimension; suppresses micro-moves. |
| `TargetSelection` | `Largest` | `Largest` (biggest box), `FirstDetected`, or `ClassLabel` (highest-confidence of the class). |
| `ClassLabelFilter` | `"person"` | Only detections with this label are candidates; set to `null` to follow any class. |
| `LostTargetTimeout` | `1 s` | How long the subject may be absent before the crop eases to center. |

The detector's `ConfidenceThreshold` and `IoUThreshold` are used for detection. The block always runs detection with drawing disabled, so detection boxes are never baked into the output frame — `YoloDetectorSettings.DrawDetections` has no effect here.

Model licenses

The SDK does not ship model weights. Supply your own YOLO `.onnx` file and verify its license (training code, weights, and dataset) separately — the ONNX format does not change a model's license.

## Example: landscape file to vertical 9:16 MP4

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.Types.X;
using VisioForge.Core.Types.X.AI;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.VideoEncoders;

var pipeline = new MediaBlocksPipeline();

// Video-only: the audio stream is not connected, so do not render it.
var source = new UniversalSourceBlock(
    await UniversalSourceSettings.CreateAsync("landscape.mp4", renderVideo: true, renderAudio: false));

var detector = new YoloDetectorSettings(@"C:\models\yolox_nano.onnx")
{
    Model = ObjectDetectorModel.YOLOX,
};

var reframeSettings = new AutoReframeSettings(detector)
{
    OutputWidth = 1080,
    OutputHeight = 1920,      // 9:16
    DetectionInterval = 5,
    Smoothing = 0.85,
    ClassLabelFilter = "person",
    TargetSelection = AutoReframeTargetSelection.Largest,
};

var reframe = new AutoReframeBlock(reframeSettings);
reframe.OnReframeUpdated += (s, e) =>
{
    if (e.HasTarget)
    {
        Console.WriteLine(
            $"Following {e.TrackedLabel} ({e.Confidence:P0}); crop {e.CropRect} at {e.Timestamp}");
    }
};

var h264 = new H264EncoderBlock(new OpenH264EncoderSettings());
var mp4 = new MP4SinkBlock(new MP4SinkSettings("vertical.mp4"));

pipeline.Connect(source.VideoOutput, reframe.Input);
pipeline.Connect(reframe.Output, h264.Input);
pipeline.Connect(h264.Output, mp4.CreateNewInput(MediaBlockPadMediaType.Video));

var eosReached = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
pipeline.OnStop += (s, e) => eosReached.TrySetResult(true);

if (!await pipeline.StartAsync())
{
    Console.WriteLine("Pipeline failed to start (check the model path and source file).");
    await pipeline.DisposeAsync();
    return;
}

// Wait for end-of-stream (the pipeline stops itself and the muxer finalizes the MP4),
// then release the pipeline.
await eosReached.Task;
await pipeline.StopAsync();
await pipeline.DisposeAsync();
```

## The OnReframeUpdated event

`OnReframeUpdated` fires on every processed frame with a `ReframeEventArgs`:

| Member | Description |
| --- | --- |
| `CropRect` | The crop window applied to the source frame, in source-frame pixel coordinates (pre-PAR-correction). On anamorphic sources its width:height ratio deliberately differs from the output aspect ratio — account for this when drawing overlay geometry. |
| `HasTarget` | Whether a subject was being followed on this frame. |
| `TargetBox` | The followed subject box in source coordinates, or `null`. |
| `TrackedLabel` | The followed subject class label, or `null`. |
| `Confidence` | The followed subject confidence (0..1), or `0`. |
| `Timestamp` | The source frame timestamp. |

Use it to drive an on-screen overlay of the crop region, to log which subject is being followed, or to render a side-by-side preview of the original and the reframed output.

## Tips

- **Aspect ratios.** `1080x1920` is 9:16; `1080x1080` is 1:1; `1080x1350` is 4:5. Any even `OutputWidth`/`OutputHeight` works.
- **Smoothness vs. responsiveness.** Raise `Smoothing` (for example `0.9`) for slower, calmer motion; lower it (for example `0.7`) to track a fast-moving subject more tightly.
- **Jitter.** If the crop twitches on a nearly-static subject, increase `DeadZoneFraction`.
- **Class.** Set `ClassLabelFilter` to follow a specific class (for example `"person"`, `"dog"`, `"sports ball"`), or `null` to follow whatever is largest.
- **Cost.** Detection is the main cost. Increase `DetectionInterval` to run it less often; the crop still glides on the frames in between.

---END OF PAGE---


## Background Removal SDK for .NET — BackgroundRemovalBlock
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/background-removal/
**Description:** Background removal SDK for .NET — blur, replace, or make video backgrounds transparent on-device with BackgroundRemovalBlock and ONNX matting models.
**Tags:** .NET, AI, ONNX, Background Removal, Background Removal SDK, Virtual Background, Matting, Green Screen, VideoCaptureCoreX, MediaPlayerCoreX
**API:** BackgroundRemovalBlock, BackgroundRemovalSettings, BackgroundRemovalModel, BackgroundReplacementMode

# AI Background Removal (Matting) — BackgroundRemovalBlock

`BackgroundRemovalBlock` runs an ONNX segmentation or matting model on RGBA video frames, estimates a per-pixel foreground alpha mask, and composites a replacement background into the frame. Use it for portrait matting, virtual background blur, virtual green-screen output, static background replacement, or transparent RGBA output.

```
graph LR;
    Source-->BackgroundRemovalBlock;
    BackgroundRemovalBlock-->VideoRendererBlock;
```

The block lives in `VisioForge.Core.AI` (`VisioForge.DotNet.Core.AI`), uses `BackgroundRemovalSettings` (which extends `OnnxInferenceSettings`), and has one video `Input` and one video `Output`. It uses an internal sample grabber for RGBA frames and runs inference on the pipeline streaming thread, so a slow model can throttle the pipeline. It does not raise a recognition event — the output is the processed video frame.

## Models and licensing

Set `BackgroundRemovalSettings.Model` to the family that matches the supplied `.onnx` file. The SDK does not ship model weights in the NuGet package; your application supplies the `.onnx` file.

| Model | Expected input and output | Notes |
| --- | --- | --- |
| `BackgroundRemovalModel.MODNet` (default) | Square input, default `512x512`; direct resize; RGB normalized to -1..1; output alpha matte `[1, 1, H, W]` in 0..1. | Portrait matting, Apache-2.0. |
| `BackgroundRemovalModel.PPMattingV2` | Model fixed size; direct resize; RGB normalized to -1..1; output alpha matte `[1, 1, H, W]` in 0..1. | Real-time human matting from PaddleSeg, Apache-2.0. |
| `BackgroundRemovalModel.U2Net` | `320x320`; direct resize; RGB ImageNet mean/std normalization; first output is rescaled per frame to 0..1. | Salient-object / portrait segmentation, Apache-2.0. Set `InputWidth`/`InputHeight` to `320` if the model uses dynamic input dimensions. |
| `BackgroundRemovalModel.BiRefNet` | Typically `1024x1024`; direct resize; RGB ImageNet mean/std normalization; raw logits are mapped through sigmoid to 0..1. | Higher accuracy and heavier. Code is MIT; verify the specific checkpoint because some weights are trained on non-commercial data. Set `InputWidth`/`InputHeight` to `1024` if the model uses dynamic input dimensions. |
| `BackgroundRemovalModel.Custom` | Uses `InputWidth`, `InputHeight`, and `NormalizeTo01` from `BackgroundRemovalSettings`. | For a model that does not match the built-in conventions. |

Model licenses

A model's license is set by its origin (training code, weights, and dataset), not by the ONNX format. `MODNet`, `PPMattingV2`, and `U2Net` are Apache-2.0. `BiRefNet` code is MIT, but you must verify the license of the exact checkpoint you ship.

## How the matting pipeline works

`BackgroundRemovalBlock` is a frame processor, not a separate source or renderer. The upstream block delivers RGBA frames to an internal sample grabber, the block runs the configured ONNX model when the frame is selected for inference, and the output frame is pushed downstream with the same video timing.

The ONNX model input size is resolved from the model metadata when the model has fixed dimensions. If the model uses dynamic dimensions, `InputWidth` and `InputHeight` from `BackgroundRemovalSettings` are used instead — these default to `512x512` (tuned for `MODNet`) and are **not** adjusted per-model automatically, so set them yourself for `U2Net` (`320x320`) or `BiRefNet` (`1024x1024`). The frame is resized directly to that tensor size and converted from RGBA pixels to an RGB `NCHW` floating-point tensor. The model family controls the normalization:

- `MODNet` and `PPMattingV2` use RGB values normalized to `-1..1`.
- `U2Net` and `BiRefNet` use ImageNet-style RGB mean/std normalization.
- `Custom` uses the generic `NormalizeTo01`, `InputWidth`, and `InputHeight` settings.

After inference, the block reads the first float output as a foreground matte. The last two output dimensions are treated as matte height and width. `MODNet`, `PPMattingV2`, and `Custom` outputs are expected to already be in `0..1`; `U2Net` is min/max-normalized per frame; `BiRefNet` raw logits are converted with sigmoid. If `MaskFeatherAmount` is greater than `0`, the matte is blurred at model resolution before compositing.

The compositor samples that matte back onto the original frame with bilinear interpolation. For `Blur`, `SolidColor`, and `Image`, each pixel is blended as `foreground * alpha + background * (1 - alpha)`. `MaskThreshold` can harden uncertain edges by forcing very low alpha values to background and very high values to foreground. For `Transparent`, the block keeps the foreground RGB pixels and writes the matte into the output alpha channel, so the visible result depends on the downstream renderer or encoder preserving RGBA alpha.

### Choosing a matting model

Use `MODNet` or `PPMattingV2` first for real-time portrait background replacement. They are designed for human matting and have lower input sizes than high-accuracy salient-object models. `U2Net` is a good fallback when the subject is not always a person, but its output is a segmentation-style matte that may need `MaskFeatherAmount` for soft edges. `BiRefNet` is the heavier quality option: it can produce better fine detail, but its typical `1024x1024` input size is much more expensive, especially on CPU. Use `Custom` only when your ONNX model follows a different preprocessing or output convention and you have verified those settings against the exported model.

## Replacement modes

`BackgroundRemovalSettings.ReplacementMode` selects how low-alpha background pixels are replaced.

| Mode | Settings used | Result |
| --- | --- | --- |
| `BackgroundReplacementMode.Blur` (default) | `BlurRadius` | Replaces the background with a blurred copy of the original frame. |
| `BackgroundReplacementMode.SolidColor` | `ReplacementColor` | Fills the background with a solid color; defaults to green (a virtual green screen). |
| `BackgroundReplacementMode.Image` | `BackgroundImagePath`, `ReplacementColor` fallback | Loads a static image and scales it to the frame size. If the image cannot be loaded, the block falls back to `ReplacementColor`. |
| `BackgroundReplacementMode.Transparent` | Foreground alpha mask | Writes the mask to the frame alpha channel. Use an RGBA renderer, encoder, or downstream compositor that preserves alpha. |

Additional matte controls:

| Property | Default | Description |
| --- | --- | --- |
| `MaskThreshold` | `0` | Optional edge hardening. Effective range 0..0.5 (values above 0.5 are clamped). Values at or below the threshold become background, and values at or above `1 - threshold` become foreground. `0` keeps the model's raw soft matte unchanged. |
| `MaskFeatherAmount` | `0` | Optional matte-space blur radius, in matte (model-resolution) pixels, that softens foreground/background edges — the opposite control to `MaskThreshold`. |
| `FramesToSkip` | `0` | Inherited from `OnnxInferenceSettings`. The model runs every `FramesToSkip + 1` frames, while the last matte is composited on every frame. |
| `Provider` / `DeviceId` | `Auto` / `0` | ONNX execution provider and hardware device index. |
| `InputWidth` / `InputHeight` | `512` / `512` | Used for dynamic-input matting models. Fixed-size models report their own input size. |

## Pipeline example

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.X.AI;

var settings = new BackgroundRemovalSettings(modelPath)
{
    Model = BackgroundRemovalModel.PPMattingV2,
    ReplacementMode = BackgroundReplacementMode.Blur,
    BlurRadius = 15f,
    MaskFeatherAmount = 2,
    Provider = OnnxExecutionProvider.Auto,
    FramesToSkip = 2,
    MaskThreshold = 0.05f,
};

var backgroundRemoval = new BackgroundRemovalBlock(settings);

var videoRenderer = new VideoRendererBlock(pipeline, videoView) { IsSync = false };

pipeline.Connect(source.Output, backgroundRemoval.Input);
pipeline.Connect(backgroundRemoval.Output, videoRenderer.Input);

await pipeline.StartAsync();

Console.WriteLine($"Active provider: {backgroundRemoval.ActiveProvider}");
```

Performance

The model is not run on every frame when `FramesToSkip` is greater than `0`, but the block still composites the replacement background on every frame from the cached matte. This lowers CPU/GPU cost without flickering back to the original background between inference frames.

## Use with VideoCaptureCoreX and MediaPlayerCoreX

```
var backgroundRemoval = new BackgroundRemovalBlock(settings);

core.Video_Processing_AddBlock(backgroundRemoval); // before StartAsync (VideoCaptureCoreX)
// player.Video_Processing_AddBlock(backgroundRemoval); // before OpenAsync/PlayAsync (MediaPlayerCoreX)

await core.StartAsync();
```

See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the full processing-block API, insertion order, and lifecycle rules shared by every video AI block.

## Use cases

- **Video conferencing and webcam apps** — virtual green screen or background blur without a physical green screen.
- **Livestreaming and broadcast overlays** — composite a presenter over a branded background or scene.
- **Virtual studio / product photography video** — replace a plain backdrop with a custom scene.
- **Privacy blurring** — blur the background in a recording so only the foreground subject is sharp.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| Edges around hair/fingers look hard or blocky | Matte edges not softened | Raise `MaskFeatherAmount`. |
| Background bleeds through solid areas (semi-transparent artifacts) | Matte is too soft for a high-contrast scene | Raise `MaskThreshold` (effective range 0..0.5) to harden the foreground/background split. |
| Wrong crop/scale in the output | `InputWidth`/`InputHeight` don't match the model | For a dynamic-input model, set them to that model's expected size (`320` for `U2Net`, `1024` for `BiRefNet`); a fixed-size model reports and uses its own size regardless. |
| `Transparent` mode shows an opaque background | Downstream renderer/encoder doesn't preserve alpha | Use an RGBA-capable renderer/encoder/compositor; `Transparent` only writes the alpha channel, it doesn't force the rest of the pipeline to honor it. |
| High CPU/GPU usage | Matting model running on every frame | Raise `FramesToSkip` — the last matte is still composited every frame, so motion doesn't flicker back to the original background between inference frames. |

## Frequently Asked Questions

### Which matting model should I start with?

`MODNet` (the default) or `PPMattingV2` for real-time portrait/webcam scenarios — both are tuned for human matting at a relatively low input size. Use `BiRefNet` only if you need higher fine-detail accuracy and can afford its heavier `1024x1024` input cost.

### Can I use a virtual green screen without a physical one?

Yes — set `ReplacementMode = BackgroundReplacementMode.SolidColor` (it defaults to green) instead of `Blur`, `Image`, or `Transparent`.

### Does this block require a GPU?

No, but a GPU execution provider reduces per-frame latency, which matters most for `BiRefNet`'s larger input size or for high frame-rate live video.

### Can I output a transparent (alpha) video instead of compositing a background?

Yes — set `ReplacementMode = BackgroundReplacementMode.Transparent`. The block writes the foreground alpha into the frame's alpha channel; your renderer, encoder, or downstream compositor must preserve RGBA to make use of it.

## Demo

- **[Background Removal Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Background%20Removal%20Demo)** — WPF demo with webcam, file, and RTSP sources, downloadable matting models, blur, solid color, image, and transparent replacement modes.

---END OF PAGE---


## Face Recognition SDK for .NET and C# — FaceRecognitionBlock
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/face-recognition/
**Description:** Face Recognition SDK for .NET and C# — FaceRecognitionBlock detects and identifies faces on-device (YuNet + SFace/ArcFace ONNX), cross-platform, no cloud.
**Tags:** .NET, AI, ONNX, Face Recognition, Face Recognition SDK, Face Detection, Facial Recognition, YuNet, SFace, Biometrics, VideoCaptureCoreX, MediaPlayerCoreX
**API:** FaceRecognitionBlock, FaceRecognitionSettings, FaceGallery, FaceEmbeddingModel, FaceRecognitionResult

# Face Recognition SDK for .NET — FaceRecognitionBlock

`FaceRecognitionBlock` is the face recognition SDK component of VisioForge's .NET AI packages — it recognizes **who** is in the frame, on-device, with no cloud API. It runs a two-stage pipeline: a YuNet detector finds faces and their five landmarks, each face is aligned to a canonical 112x112 crop and turned into an embedding (SFace or ArcFace), and the embedding is matched 1:N against an enrolled `FaceGallery` by cosine similarity. Recognition runs on a background thread, so live video never stalls; the streaming thread only draws the most recent results.

```
graph LR;
    Source-->FaceRecognitionBlock;
    FaceRecognitionBlock-->VideoRendererBlock;
    FaceRecognitionBlock-. OnFacesIdentified .->App[Your app];
```

## Enroll and recognize

```
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.Types.X.AI;

var settings = new FaceRecognitionSettings(
    "face_detection_yunet_2023mar.onnx",
    "face_recognition_sface_2021dec.onnx")
{
    EmbeddingModel = FaceEmbeddingModel.SFace, // or ArcFace for a 512-D recognizer
    RecognitionThreshold = 0.36f,              // cosine similarity for a match
    DrawResults = true,
};

var face = new FaceRecognitionBlock(settings);

// Enroll identities from a file path or an in-memory SKBitmap (several photos per person are allowed).
face.Enroll("Alice", "alice.jpg");
face.Enroll("Bob", "bob.jpg");
face.Gallery.Save("faces.dat"); // reload later with face.Gallery.Load("faces.dat")

face.OnFacesIdentified += (sender, e) =>
{
    foreach (var f in e.Faces)
    {
        var who = string.IsNullOrEmpty(f.Identity) ? "Unknown" : f.Identity;
        Console.WriteLine($"{who} ({f.Similarity:P0}) at {f.BoundingBox}");
    }
};

pipeline.Connect(source.Output, face.Input);
pipeline.Connect(face.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

The default models — [YuNet](https://github.com/opencv/opencv_zoo) (MIT) and [SFace](https://github.com/opencv/opencv_zoo) (Apache-2.0) — are designed to work together (SFace aligns with YuNet's five landmarks). The embedding length is read from the model, so an ArcFace-style recognizer (for example [AuraFace](https://huggingface.co/fal/AuraFace-v1), Apache-2.0, 512-D) drops in by switching `EmbeddingModel` to `FaceEmbeddingModel.ArcFace`. Keep one gallery per embedding model — embeddings from different models are not comparable. Model weights are not shipped in the NuGet package.

Each `FaceRecognitionResult` carries the matched `Identity` (`null` when unknown), `Similarity` (cosine similarity of the best gallery match), `DetectionScore`, the axis-aligned `BoundingBox`, the box-corner `Polygon`, the five facial `Landmarks`, and the raw L2-normalized `Embedding` vector.

## Face recognition settings

`FaceRecognitionSettings(detectorModelPath, embeddingModelPath)`:

| Property | Default | Description |
| --- | --- | --- |
| `DetectorModelPath` | — | Face detection ONNX model path, usually YuNet. Required. |
| `EmbeddingModelPath` | — | Face embedding ONNX model path, usually SFace or ArcFace-style. Required. |
| `EmbeddingModel` | `SFace` | Selects the aligned-crop preprocessing for the embedding model family (`SFace` or `ArcFace`). |
| `Gallery` | `null` | Enrolled identities used for 1:N matching. When `null`/empty, faces are detected and embedded but reported as unknown. `FaceRecognitionBlock.Gallery` exposes the active gallery. |
| `Provider` / `DeviceId` | `Auto` / `0` | ONNX execution provider and hardware device index. |
| `FramesToSkip` | `0` | Skip frames between recognition runs on live video. |
| `DetectionInputSize` | `320` | Square detector input size. YuNet requires a multiple of 32; non-multiples are rounded up internally. |
| `DetectionConfidenceThreshold` | `0.6` | Minimum face detector score. |
| `NmsThreshold` | `0.3` | IoU threshold for suppressing overlapping face boxes. |
| `MaxFaces` | `20` | Maximum faces detected per frame. |
| `RecognitionThreshold` | `0.36` | Minimum cosine similarity for reporting a known identity (the SFace same-identity threshold). |
| `DrawResults` / `DrawLandmarks` | `true` / `false` | Draw boxes, labels, and optionally the five facial landmarks. |
| `BoxColor` / `BoxThickness` / `LabelFontSize` | LimeGreen / `2` / `0` | Overlay styling; `LabelFontSize = 0` auto-scales to frame height. |

## FaceGallery

`FaceGallery` is a thread-safe, in-memory gallery of enrolled identities. Each identity can hold several L2-normalized embeddings (enroll multiple photos per person for robustness); a query matches by the maximum cosine similarity across all stored embeddings of all identities.

- `Add(name, embedding)` — enrolls a normalized copy of the embedding; throws if its length doesn't match the embeddings already in the gallery (a different embedding model).
- `Identify(embedding, threshold, out score)` — returns the best-matching identity name when its score meets `threshold`, otherwise `null`; `score` always receives the best score found.
- `Remove(name)`, `Clear()`, `Count`, `GetNames()`.
- `Save(path)` / `Load(path)` — persist to and restore from a versioned binary file.

`FaceRecognitionBlock.Enroll(name, imagePath)` and `Enroll(name, SKBitmap)` compute the embedding for you and call `Gallery.Add` internally.

Privacy

Face recognition processes biometric data. Ensure your use complies with the applicable privacy and data-protection laws (GDPR, BIPA, CCPA, and similar) in your jurisdiction.

## Use with VideoCaptureCoreX and MediaPlayerCoreX

```
var face = new FaceRecognitionBlock(settings);
face.Enroll("Alice", "alice.jpg");
face.OnFacesIdentified += Face_OnFacesIdentified;

core.Video_Processing_AddBlock(face); // before StartAsync (VideoCaptureCoreX)
// player.Video_Processing_AddBlock(face); // before OpenAsync/PlayAsync (MediaPlayerCoreX)

await core.StartAsync();
```

See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the full processing-block API, insertion order, and lifecycle rules shared by every video AI block.

## Use cases

- **Access control and attendance** — recognize enrolled employees or residents at a door camera or kiosk, on-device, without sending faces to a third-party cloud service.
- **Personalization** — greet a returning, enrolled user by name in a kiosk or smart-mirror app.
- **VIP / watchlist alerts** — raise an application event when a specific enrolled identity is seen.
- **Deduplicating footage** — group video segments by which enrolled identities appear in them.

`FaceRecognitionBlock` is a *1:N identification* component (who is this, out of a known gallery), not a *1:1 verification* or liveness/anti-spoofing system — build additional checks on top if your scenario needs them (for example, payment authorization).

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| Everyone is reported as "Unknown" | `RecognitionThreshold` too high, or the gallery is empty/not assigned | Confirm `Gallery` has enrolled identities; lower `RecognitionThreshold` slightly if enrollment photos are lower quality. |
| Wrong identity reported for a known face | Embedding model mismatch between the gallery and the recognizer, or too few enrollment photos | Never mix embeddings from different `EmbeddingModel` values in one gallery; enroll 2-3 photos per person from different angles/lighting. |
| Faces are missed entirely | `DetectionConfidenceThreshold` too high, or faces smaller than `DetectionInputSize` can resolve | Lower `DetectionConfidenceThreshold`; raise `DetectionInputSize` (must stay a multiple of 32) for small/distant faces. |
| `FaceGallery.Load` throws `InvalidDataException` | The file wasn't written by `FaceGallery.Save`, or is from an incompatible SDK version | Only load files your own app wrote with `Save`; the format is versioned and rejects corrupt/foreign files by design. |
| High CPU usage with several faces on screen | Recognition runs per detected face | Lower `MaxFaces`, raise `FramesToSkip`, or use a GPU execution provider. |

## Frequently Asked Questions

### Is this face recognition SDK cloud-based or on-device?

Fully on-device. `FaceRecognitionBlock` runs YuNet detection and SFace/ArcFace embedding through local ONNX Runtime inference — no frame or embedding is sent to an external service.

### Can I use this face recognition SDK from C#?

Yes — the entire SDK, including `FaceRecognitionBlock`, `FaceRecognitionSettings`, and `FaceGallery`, is a native C#/.NET API (`VisioForge.DotNet.Core.AI`), usable from any .NET application on Windows, macOS, Linux, Android, or iOS.

### How do I enroll a new person?

Call `FaceRecognitionBlock.Enroll(name, imagePath)` or `Enroll(name, SKBitmap)` with one or more clear photos of the person; the block computes the embedding and adds it to `Gallery` for you. Persist the gallery with `FaceGallery.Save(path)` and restore it later with `FaceGallery.Load(path)`.

### Does the SDK include face detection without recognition?

Yes, indirectly — `FaceRecognitionResult` reports `DetectionScore` and `BoundingBox` for every detected face, whether or not it matches a gallery entry. Leave `Gallery` empty to use the block as a pure face detector.

### Is SFace or ArcFace better?

SFace (the default, 128-D, Apache-2.0) pairs directly with the YuNet detector's five landmarks and is lighter. ArcFace-style recognizers (for example AuraFace, 512-D) can be more accurate for some datasets. Benchmark both against your own enrollment photos and target hardware before choosing.

## Demos

- **[Face Recognition Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Face%20Recognition%20Demo)** — WPF Media Blocks demo with enrollment and live 1:N face identity.
- **[Face Recognition MB](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/MAUI/Face%20Recognition%20MB)** — the same Media Blocks demo for MAUI (Android, iOS, Windows, macOS).
- **[Face Recognition CLI](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/Console/Face%20Recognition%20CLI)** — headless console demo.

Dedicated `VideoCaptureCoreX`/`MediaPlayerCoreX` face-recognition demos (`Capture Face Recognition X`, `Capture Face Recognition X WPF`, `Player Face Recognition X`, `Player Face Recognition X WPF`) are in the SDK's demo set and will be linked here once published to the public samples repository.

---END OF PAGE---


## AI SDK for .NET — On-Device Video AI and Speech-to-Text
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/
**Description:** On-device AI SDK for .NET — OCR, object detection, face recognition, ANPR, background removal, and Whisper speech-to-text. Cross-platform, no cloud.
**Tags:** .NET, AI, AI SDK, Computer Vision, ONNX, Whisper, Media Blocks, VideoCaptureCoreX, MediaPlayerCoreX, Windows, macOS, Linux, Android, iOS
**API:** OcrBlock, YOLOObjectDetectorBlock, ObjectAnalyticsBlock, FaceRecognitionBlock, LicensePlateRecognizerBlock, PIIRedactionBlock, OpenVocabularyDetectorBlock, VLMBlock, VideoEmbeddingBlock, BackgroundRemovalBlock, AutoReframeBlock, OnnxInferenceBlock, SpeechToTextBlock

# AI in VisioForge .NET SDK

VisioForge AI support is implemented as ordinary Media Blocks. The same block instances can be placed in a manual `MediaBlocksPipeline`, inserted into `VideoCaptureCoreX`, or inserted into `MediaPlayerCoreX`.

The AI packages do not replace the media engines. They add pass-through processing blocks: media continues downstream, optional overlays are drawn into the frame, and the block raises its own event with recognition results.

## Why on-device AI

Every block on this page runs locally, in-process, on ONNX Runtime (video) or Whisper.net/GGML (speech) — there is no cloud API call, no per-request billing, and no network dependency at inference time. That matters for three common scenarios:

- **Privacy and compliance** — video and audio frames never leave the device, which simplifies GDPR/CCPA/BIPA reviews for camera and microphone applications (see the [privacy note](face-recognition/) on face recognition specifically).
- **Offline and edge deployments** — kiosks, industrial cameras, vehicles, and field devices can run recognition without connectivity.
- **Predictable cost and latency** — throughput depends on the hardware you run on, not on a third-party API's rate limits or per-call pricing.

Each block accepts an `OnnxExecutionProvider` (`Auto`, `CPU`, `CUDA`, `DirectML`, `CoreML`) and a `DeviceId`, so the same code can run CPU-only in a CI pipeline and take advantage of an NVIDIA, DirectX 12, or Apple GPU on a deployed machine without a code change. `Auto` picks the best provider present in the loaded ONNX Runtime native build at run time.

## Packages

| Package | Main purpose |
| --- | --- |
| `VisioForge.DotNet.Core.AI` | ONNX video AI: OCR, object detection, analytics, face recognition, license plates, background removal, and custom inference. |
| `VisioForge.DotNet.Core.AI.Whisper` | Local speech-to-text with Whisper ASR and Silero VAD. |

Both packages reference the core SDK types. Add the same native runtime packages that your host application already uses for Media Blocks, Video Capture X, or Media Player X.

## Blocks

| Block | Media | Event | Typical use | Details |
| --- | --- | --- | --- | --- |
| `OcrBlock` | Video | `OnTextDetected` | Recognize text regions with PaddleOCR models. | [OCR](ocr/) |
| `YOLOObjectDetectorBlock` | Video | `OnObjectsDetected` | Run standalone object detection on each frame. | [Object detection](object-detection/) |
| `ObjectAnalyticsBlock` | Video | `OnAnalyticsUpdated` | Track objects over time, count line crossings, and monitor polygon zones. | [Object analytics](object-analytics/) |
| `FaceRecognitionBlock` | Video | `OnFacesIdentified` | Detect faces and match them against an enrolled gallery. | [Face recognition](face-recognition/) |
| `LicensePlateRecognizerBlock` | Video | `OnPlateRecognized` | Detect and read license plates. | [License plate recognition](license-plate-recognition/) |
| `PIIRedactionBlock` | Video | `OnRegionsRedacted` | Blur, pixelate, or fill faces, license plates, and on-screen text. | [PII redaction](pii-redaction/) |
| `OpenVocabularyDetectorBlock` | Video | `OnObjectsDetected` | Detect objects by free-text prompt (zero-shot). | [Open vocabulary detection](open-vocabulary-detection/) |
| `VLMBlock` | Video | `OnResultGenerated` | Caption, describe, ground, or OCR frames with a vision-language model. | [VLM captioning](vlm-captioning/) |
| `VideoEmbeddingBlock` | Video | `OnFrameEmbedding` | Embed frames with CLIP for semantic video search. | [Semantic video search](semantic-video-search/) |
| `BackgroundRemovalBlock` | Video | none | Replace, blur, or make the background transparent. | [Background removal](background-removal/) |
| `AutoReframeBlock` | Video | `OnReframeUpdated` | Reframe landscape footage into subject-following vertical 9:16 video. | [Auto reframe](auto-reframe/) |
| `OnnxInferenceBlock` | Video | `OnInference` | Run a custom ONNX model and receive raw output tensors. | [ONNX inference](onnx-inference/) |
| `SpeechToTextBlock` | Audio | `OnSpeechRecognized` | Transcribe live or file audio with Whisper. | [Speech-to-text](speech-to-text/) |

## Video understanding and search

Three of the AI blocks turn raw footage into something you can search and act on — the difference is whether you want to *detect*, *describe*, or *find* content:

- **Detect** specific things, even ones no model was trained on, with [open-vocabulary detection](open-vocabulary-detection/) — or [object detection](object-detection/) for known classes at high frame rate.
- **Describe** what's on screen — captions, descriptions, and in-frame text — with [VLM captioning](vlm-captioning/).
- **Search** recorded video by meaning, jumping straight to a moment you describe in plain text, with [semantic video search](semantic-video-search/).

They compose: index a library for [semantic search](semantic-video-search/), then run a [detector](open-vocabulary-detection/) or a [VLM](vlm-captioning/) on the moments it surfaces to confirm or label them.

## Choosing the right AI block

- **Need to read text in a frame** (signage, documents, screens)? Use [`OcrBlock`](ocr/).
- **Need to read a specific vehicle license plate**, not general text? Use [`LicensePlateRecognizerBlock`](license-plate-recognition/) — it runs a dedicated plate detector plus a plate-specific OCR head, which is both more accurate and faster than pointing generic OCR at a whole scene.
- **Need to anonymize video for privacy or compliance** (blur faces, plates, or on-screen text)? Use [`PIIRedactionBlock`](pii-redaction/) — it detects and obscures all three PII categories in-place, on-device, and never identifies or exports the content.
- **Need boxes and labels for objects, one frame at a time**? Use [`YOLOObjectDetectorBlock`](object-detection/).
- **Need to detect objects you can only describe in words** (not a fixed trained class list)? Use [`OpenVocabularyDetectorBlock`](open-vocabulary-detection/) — it detects anything you name in a text prompt, at a higher per-frame cost than YOLO.
- **Need a natural-language description, caption, or in-frame reading** of the scene? Use [`VLMBlock`](vlm-captioning/) — a Florence-2 vision-language model that captions, detects, grounds phrases, and reads text.
- **Need to search recorded video by meaning** ("find where someone rides a bicycle")? Use [`VideoEmbeddingBlock`](semantic-video-search/) — it indexes frames as CLIP embeddings you can query with plain text.
- **Need to count people/vehicles crossing a line, or track dwell time in a zone**, not just per-frame boxes? Use [`ObjectAnalyticsBlock`](object-analytics/) — it adds ByteTrack tracking, tripwires, and polygon zones on top of the same detector families.
- **Need to know *who* is in frame**, not just *that* a person is in frame? Use [`FaceRecognitionBlock`](face-recognition/).
- **Need a virtual background, blur, or transparent output** for a call or stream? Use [`BackgroundRemovalBlock`](background-removal/).
- **Have a custom ONNX model** that isn't one of the built-in detector or matting families? Use [`OnnxInferenceBlock`](onnx-inference/) and own the post-processing yourself.
- **Need a transcript, live captions, or SRT/VTT subtitles** from audio? Use [`SpeechToTextBlock`](speech-to-text/).

## Supported integration paths

Use a manual Media Blocks pipeline when you need full topology control:

```
flowchart LR
    Source["Source block"] --> AI["AI processing block"]
    AI --> Sink["Renderer or output block"]
    AI -. "event" .-> App["Application code"]
```

Use `VideoCaptureCoreX` when the application already uses the high-level capture engine and only needs to insert one or more AI blocks into the capture graph. Register video or audio blocks before `StartAsync`.

Use `MediaPlayerCoreX` when the application already uses the high-level playback engine. Register video or audio blocks before `OpenAsync` / `PlayAsync`.

## Lifecycle rules

AI blocks must be registered before the engine builds the pipeline:

- `VideoCaptureCoreX`: add blocks before `StartAsync`.
- `MediaPlayerCoreX`: add blocks before `OpenAsync` / `PlayAsync`.
- Manual Media Blocks: connect the block before `StartAsync`.

After the pipeline starts, the pipeline owns wired block instances and disposes them when the session stops. Create a fresh block instance for the next capture or playback session.

Block events are raised from pipeline or block worker threads. Keep handlers short and marshal UI updates to the UI dispatcher or main thread.

## More detail

Video AI blocks (`VisioForge.DotNet.Core.AI`):

- [OCR — text recognition](ocr/)
- [Object detection](object-detection/)
- [Object analytics — tracking, tripwires, and polygon zones](object-analytics/)
- [Face recognition](face-recognition/)
- [License plate recognition (ANPR)](license-plate-recognition/)
- [PII redaction — blur faces, plates, and on-screen text](pii-redaction/)
- [Open vocabulary detection](open-vocabulary-detection/)
- [VLM captioning](vlm-captioning/)
- [Semantic video search](semantic-video-search/)
- [Background removal (matting)](background-removal/)
- [Auto reframe — subject-following vertical video](auto-reframe/)
- [Generic ONNX inference](onnx-inference/)

Speech-to-text (`VisioForge.DotNet.Core.AI.Whisper`):

- [Speech-to-text and live subtitles](speech-to-text/)

Engine integration:

- [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](x-engines/)

## Frequently Asked Questions

### Do the AI blocks require an internet connection to run?

No. Inference is entirely local, using ONNX Runtime (video blocks) or Whisper.net/GGML (`SpeechToTextBlock`). No frame or audio sample is sent to a cloud service at inference time.

### Which platforms do the AI blocks support?

The same cross-platform blocks used in Media Blocks pipelines, `VideoCaptureCoreX`, and `MediaPlayerCoreX` — Windows, macOS, Linux, Android, and iOS.

### Do I need a GPU?

No. Every block defaults to `OnnxExecutionProvider.Auto`, which runs on the CPU when no GPU provider is available. Setting `Provider` to `CUDA`, `DirectML`, or `CoreML` accelerates inference when the corresponding GPU and ONNX Runtime build are present.

### Where do I get the ONNX and Whisper model files?

Model weights are not shipped inside the `VisioForge.DotNet.Core.AI` / `VisioForge.DotNet.Core.AI.Whisper` NuGet packages. Your application supplies the `.onnx` / `.bin` files — point the block's settings at a local path. The SDK's own demos download the models they use from GitHub Releases on first run and cache them locally.

### What license applies to the models the demos use?

It varies by model family and is independent of the SDK's own license — see the "Models and licensing" section on each block's page ([OCR](ocr/#models-and-licensing), [object detection](object-detection/#supported-detector-families), [face recognition](face-recognition/), [background removal](background-removal/#models-and-licensing)). In short: PP-OCR, YOLOX, RT-DETR, YuNet, SFace, and the FastALPR ANPR models are Apache-2.0/MIT; stock Ultralytics YOLOv8 weights are AGPL-3.0 and need a commercial Ultralytics license in a closed-source product; Whisper GGML weights are MIT.

### Can I run more than one AI block in the same pipeline?

Yes. Chain multiple video blocks (for example `OcrBlock` then `BackgroundRemovalBlock`) by connecting `Output` to `Input` in sequence, or register several video/audio blocks on `VideoCaptureCoreX`/`MediaPlayerCoreX` with `Video_Processing_AddBlock`/`Audio_Processing_AddBlock`. Each block adds its own inference cost to the pipeline, so measure end-to-end performance on your target hardware when combining several.

---END OF PAGE---


## ANPR/LPR SDK for .NET — LicensePlateRecognizerBlock
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/license-plate-recognition/
**Description:** ANPR/LPR SDK for .NET — read vehicle license plates with LicensePlateRecognizerBlock (FastALPR detector + plate-OCR ONNX models), on-device, cross-platform.
**Tags:** .NET, AI, ONNX, ANPR, ANPR SDK, LPR, License Plate Recognition, Vehicle Recognition, VideoCaptureCoreX, MediaPlayerCoreX
**API:** LicensePlateRecognizerBlock, LicensePlateRecognizerSettings, LicensePlateResult

# License Plate Recognition (ANPR) — LicensePlateRecognizerBlock

`LicensePlateRecognizerBlock` reads vehicle license plates with a specialized two-stage pipeline: a dedicated license-plate detector (YOLO) locates plates in the frame, then a plate-specific OCR model reads the characters of each cropped plate. Both models come from the FastALPR family (MIT): a YOLOv9-T plate detector and a `fast-plate-ocr` recognition head. A global head covers the USA and 90+ countries; a European head is tuned for EU plates. The recognition model's geometry and alphabet are read from the model itself, so selecting a region is simply a matter of pointing `RecognitionModelPath` at that head.

```
graph LR;
    Source-->LicensePlateRecognizerBlock;
    LicensePlateRecognizerBlock-->VideoRendererBlock;
    LicensePlateRecognizerBlock-. OnPlateRecognized .->App[Your app];
```

## Usage

```
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.Types.X.AI;

var settings = new LicensePlateRecognizerSettings(detectorModelPath, recognitionModelPath)
{
    Provider = OnnxExecutionProvider.Auto,
    DetectionConfidenceThreshold = 0.35f,
    OcrConfidenceThreshold = 0.3f,
    DrawResults = true,
};

var anpr = new LicensePlateRecognizerBlock(settings);
anpr.OnPlateRecognized += (sender, e) =>
{
    foreach (var plate in e.Plates)
    {
        Console.WriteLine($"Plate: {plate.Text} ({plate.Confidence:P0}) at {plate.BoundingBox}");
    }
};

pipeline.Connect(source.Output, anpr.Input);
pipeline.Connect(anpr.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

Each `LicensePlateResult` carries the recognized `Text` (normalized: uppercased, non-alphanumeric characters stripped), the mean `Confidence` (0..1), the axis-aligned `BoundingBox`, and the detection `Polygon` (four `OcrPoint` vertices), all in source-frame pixels.

## Key settings

`LicensePlateRecognizerSettings(detectorModelPath, recognitionModelPath)`:

| Property | Default | Description |
| --- | --- | --- |
| `DetectorModelPath` | — | License-plate detection ONNX model (FastALPR YOLOv9-T end-to-end). Required. |
| `RecognitionModelPath` | — | Plate-OCR ONNX model (FastALPR `fast-plate-ocr` head, global or EU). Required. |
| `Provider` / `DeviceId` | `Auto` / `0` | ONNX execution provider and hardware device index. |
| `FramesToSkip` | `0` | Skip frames between recognition runs on live video. |
| `DetectionInputSize` | `640` | Square input size for the detection model (dynamic-shape models). |
| `DetectionConfidenceThreshold` | `0.35` | Minimum detector score a plate box must reach. |
| `OcrConfidenceThreshold` | `0.3` | Minimum mean OCR confidence a recognized plate must reach to be reported. |
| `MaxDetections` | `10` | Maximum plates detected per frame. |
| `DrawResults` | `true` | Draw plate boxes and text into the video frame. |
| `BoxColor` / `BoxThickness` | Yellow / `3` | Overlay styling. |
| `LabelFontSize` | `0` | `0` auto-scales to frame height. |

## Models and licensing

Both the detector and the recognition head are MIT-licensed FastALPR models; the SDK does not ship model weights in the NuGet package. For higher accuracy on busy scenes with many small or distant plates, run a dedicated general-purpose vehicle detector (for example [`YOLOObjectDetectorBlock`](../object-detection/)) upstream to crop vehicle regions before ANPR.

## Use with VideoCaptureCoreX and MediaPlayerCoreX

```
var anpr = new LicensePlateRecognizerBlock(settings);
anpr.OnPlateRecognized += Anpr_OnPlateRecognized;

core.Video_Processing_AddBlock(anpr); // before StartAsync (VideoCaptureCoreX)
// player.Video_Processing_AddBlock(anpr); // before OpenAsync/PlayAsync (MediaPlayerCoreX)

await core.StartAsync();
```

See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the full processing-block API, insertion order, and lifecycle rules shared by every video AI block.

## Use cases

- **Parking access and payment** — recognize a plate at a gate camera to open a barrier or start a parking session.
- **Toll and access-control logging** — record which plates passed a fixed camera and when.
- **Fleet and yard management** — track vehicles entering/leaving a private lot or depot.
- **Traffic enforcement support tooling** — flag plates for manual review (final enforcement decisions should always have a human-review step).

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| Plates aren't detected at all | `DetectionConfidenceThreshold` too high, or plate too small relative to `DetectionInputSize` | Lower `DetectionConfidenceThreshold`; raise `DetectionInputSize` for distant/small plates, or crop closer to the vehicle upstream. |
| Plate detected but text is wrong/empty | `OcrConfidenceThreshold` too high, or wrong regional recognition head | Lower `OcrConfidenceThreshold`; confirm `RecognitionModelPath` matches your region (global vs. EU head). |
| Only some plates in a busy scene are reported | `MaxDetections` reached | Raise `MaxDetections` if you expect more than 10 plates per frame. |
| Plate text includes stray characters | Read directly from `LicensePlateResult.Text`, expecting raw OCR | `Text` is already normalized (uppercased, non-alphanumeric characters stripped) — if you still see noise, check that the correct regional recognition head is loaded. |

## Frequently Asked Questions

### Does this ANPR SDK work outside the USA and Europe?

The FastALPR global recognition head covers the USA and 90+ countries; a separate European head is tuned for EU plates. Point `RecognitionModelPath` at whichever head matches your target region.

### Do I need to train my own plate-detection model?

No — `LicensePlateRecognizerBlock` uses the FastALPR YOLOv9-T detector and `fast-plate-ocr` recognition head out of the box; you only need to supply the two `.onnx` files.

### Can I use LicensePlateRecognizerBlock on a wide traffic scene with many vehicles?

Yes, up to `MaxDetections` plates per frame (default 10, configurable). For very busy scenes with small/distant plates, consider running a vehicle detector ([`YOLOObjectDetectorBlock`](../object-detection/)) upstream to crop vehicle regions first.

### Is license plate data considered personal/biometric data?

License plates are commonly treated as personal data under privacy regulations (though not biometric in the same sense as a face embedding). Review the applicable regulations (GDPR, state ANPR laws, and similar) for your jurisdiction and use case before deploying.

## Demos

- **[License Plate Recognition Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/License%20Plate%20Recognition%20Demo)** — WPF Media Blocks pipeline demo.

---END OF PAGE---


## Object Tracking SDK for .NET — ObjectAnalyticsBlock
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/object-analytics/
**Description:** Object tracking SDK for .NET — ByteTrack multi-object tracking, line-crossing tripwires, and polygon-zone occupancy with ObjectAnalyticsBlock.
**Tags:** .NET, AI, ONNX, Object Tracking, Object Tracking SDK, ByteTrack, Tripwire, Polygon Zone, People Counting, VideoCaptureCoreX, MediaPlayerCoreX
**API:** ObjectAnalyticsBlock, ObjectAnalyticsSettings, ByteTrackerSettings, DetectionFilterSettings, ObjectAnalyticsOverlaySettings, LineZoneSettings, PolygonZoneSettings, LineCrossingResult, PolygonZoneSnapshot

# Object Analytics — Multi-Object Tracking, Tripwires, and Polygon Zones

`ObjectAnalyticsBlock` performs stable multi-object tracking (ByteTrack), directed tripwire line crossing, and polygon-zone occupancy on top of any supported ONNX object detector (YOLOv8, YOLOX, RT-DETR). It draws overlays (boxes, labels, track IDs, traces, lines, zones, counters) and raises an `OnAnalyticsUpdated` event with tracked objects, crossing events, and zone snapshots.

```
graph LR;
    Source-->ObjectAnalyticsBlock;
    ObjectAnalyticsBlock-->VideoRendererBlock;
    ObjectAnalyticsBlock-. OnAnalyticsUpdated .->App[Your app];
```

## Usage

```
using SkiaSharp;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.Types.X.AI;

// Detector settings — reuse any supported YOLO model.
var detector = new YoloDetectorSettings("yolox_nano.onnx")
{
    Model = ObjectDetectorModel.YOLOX,
    ConfidenceThreshold = 0.6f,
    DrawDetections = false, // The analytics renderer draws instead.
};

var settings = new ObjectAnalyticsSettings(detector);

// Add a tripwire line (directed Start -> End).
settings.Lines.Add(new LineZoneSettings
{
    Id = "door",
    Start = new SKPoint(200, 200),
    End = new SKPoint(400, 200),
    Anchor = DetectionAnchor.BottomCenter, // Feet contact.
});

// Add a polygon zone.
settings.Zones.Add(new PolygonZoneSettings
{
    Id = "area",
    Points = new[]
    {
        new SKPoint(100, 100), new SKPoint(300, 100),
        new SKPoint(300, 300), new SKPoint(100, 300),
    },
});

var analytics = new ObjectAnalyticsBlock(settings);
analytics.OnAnalyticsUpdated += (s, e) =>
{
    foreach (var obj in e.Objects)
        Console.WriteLine($"ID #{obj.TrackerId}: {obj.Label} {obj.Confidence:P0}");

    foreach (var c in e.LineCrossings)
        Console.WriteLine($"{c.LineId}: {c.Label}#{c.TrackerId} {c.Direction}");
};

pipeline.Connect(source.Output, analytics.Input);
pipeline.Connect(analytics.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

The block runs inference synchronously on the pipeline streaming thread. Use `FramesToSkip` on the detector settings to reduce inference frequency; on skipped frames only static geometry and counters are redrawn — no stale object boxes or traces.

## Polygon zones — occupancy from tracked boxes

Polygon zones are part of `ObjectAnalyticsBlock`, not standalone `YOLOObjectDetectorBlock` output — the detector produces ordinary `OnnxDetection` objects with an axis-aligned box, not a polygon per object. The polygon describes an application-defined area, such as a doorway, queue area, parking bay, or restricted region.

```
settings.Zones.Add(new PolygonZoneSettings
{
    Id = "checkout",
    Points = new[]
    {
        new SKPoint(0.15f, 0.25f),
        new SKPoint(0.85f, 0.25f),
        new SKPoint(0.80f, 0.80f),
        new SKPoint(0.20f, 0.80f),
    },
    UseNormalizedCoordinates = true,
    Anchor = DetectionAnchor.BottomCenter,
    Color = SKColors.Cyan,
});
```

`Points` must contain at least three finite, distinct vertices and must form a non-zero-area, non-self-intersecting polygon. By default points are source-frame pixel coordinates. Set `UseNormalizedCoordinates = true` for `0..1` coordinates, resolved to frame pixels on every processed frame, so the same zone works across different source resolutions.

For each tracked object, the block resolves the selected `DetectionAnchor` (`Center` or the default `BottomCenter`, which better represents a person's feet or a vehicle's contact point) from the object's bounding box and tests it against the polygon. A point on the polygon edge counts as inside.

Zone state is tracker-based: when a track's anchor moves from outside to inside, its tracker ID is reported in `PolygonZoneSnapshot.EnteredTrackerIds`; when it moves from inside to outside, it appears in `ExitedTrackerIds`. `TrackerIds` and `CurrentCount` describe the tracks currently inside the zone. If a track disappears while still inside, it is reported in `ExpiredTrackerIds` (see `ZoneExitReason.TrackExpired`) — this avoids silently leaving the zone occupied forever when the detector loses an object.

The overlay renderer draws configured polygons and counters when `ObjectAnalyticsOverlaySettings` `DrawZones` and `DrawZoneCounts` are enabled (both default `true`).

## Line crossings

Line zones are directed tripwires. The direction is defined by `LineZoneSettings.Start -> End`. When a tracked object's anchor crosses the finite segment from the negative side to the positive side, the result is `LineCrossingDirection.In`; the opposite movement is `Out`. Reversing `Start` and `End` reverses the reported direction. `LineZoneSettings.DeadbandPixels` suppresses jitter near the line by keeping the last stable side until the anchor moves far enough away from the tripwire.

`ObjectAnalyticsEventArgs` contains:

| Property | Description |
| --- | --- |
| `Objects` | Tracked `OnnxDetection[]` observed in the current processed frame; each `TrackerId` is assigned by ByteTrack. |
| `LineCrossings` | `LineCrossingResult[]` with `LineId`, `TrackerId`, `ClassId`, `Label`, and `Direction`. |
| `Zones` | `PolygonZoneSnapshot[]` with `ZoneId`, `CurrentCount`, `TrackerIds`, `EnteredTrackerIds`, `ExitedTrackerIds`, and `ExpiredTrackerIds`. |

## Analytics settings

`ObjectAnalyticsSettings(YoloDetectorSettings detector)` combines detector, tracker, filter, overlay, and zone configuration; `Tracker`, `Filter`, and `Overlay` each default to a new settings instance.

Detector confidence is overridden

At runtime the analytics block lowers the effective detector confidence to `ByteTrackerSettings.LowConfidenceThreshold` (default `0.1`) so ByteTrack can use low-confidence detections in its second association pass — a high-confidence-only detector would miss recovering temporarily occluded tracks.

`ByteTrackerSettings` (ByteTrack multi-object tracker):

| Property | Default | Description |
| --- | --- | --- |
| `LowConfidenceThreshold` | `0.1` | Minimum confidence for a detection to be considered at all. |
| `HighConfidenceThreshold` | `0.25` | Confidence above which a detection joins the first (high-confidence) association stage. |
| `NewTrackThreshold` | `0.35` | Minimum confidence a high-confidence detection must reach to start a new track. |
| `FirstAssociationThreshold` | `0.8` | Maximum accepted cost for the first association stage. |
| `SecondAssociationThreshold` | `0.5` | Maximum accepted cost for the second (low-confidence) association stage. |
| `UnconfirmedAssociationThreshold` | `0.7` | Maximum accepted cost for matching unconfirmed tracks against remaining high-confidence detections. |
| `LostTrackBuffer` | `30` | Number of tracker `Update` calls (not seconds) a track may stay lost before it expires. |
| `FuseDetectionScore` | `true` | Fuse detection confidence into the association cost (`1 - IoU * confidence`). |
| `ClassAwareMatching` | `true` | When enabled, a track and a detection with different class IDs get an unmatchable cost. |

`DetectionFilterSettings` (applied before tracking; confidence filtering belongs to the tracker):

| Property | Default | Description |
| --- | --- | --- |
| `IncludedClassIds` | `null` | When non-empty, only these class IDs are retained. |
| `ExcludedClassIds` | `null` | Class IDs to reject. Exclusion wins when an ID appears in both lists. |
| `MinimumBoxArea` | `0` | Minimum bounding-box pixel area (`width * height`); smaller boxes are rejected. |

`ObjectAnalyticsOverlaySettings` (controls only the rendered overlay — events are still raised when drawing is disabled):

| Property | Default | Description |
| --- | --- | --- |
| `DrawBoxes` / `DrawLabels` / `DrawTrackIds` | `true` / `true` / `true` | Draw boxes, labels + confidence, and tracker IDs. |
| `DrawTraces` | `true` | Draw movement traces. |
| `DrawLines` / `DrawZones` / `DrawZoneCounts` | `true` / `true` / `true` | Draw tripwire lines, polygon zones, and occupancy counts. |
| `BoxThickness` / `LineThickness` / `TraceThickness` | `2` / `3` / `2` | Overlay stroke thicknesses, in pixels. |
| `LabelFontSize` | `0` | `0` auto-scales to `max(20, frame.Height / 16)`. |
| `TraceLength` | `30` | Maximum points kept in a movement trace. |

`LineZoneSettings` (`Id`, `Start`, `End`, `Anchor`, `DeadbandPixels`, `UseNormalizedCoordinates`, `Color`) and `PolygonZoneSettings` (`Id`, `Points`, `Anchor`, `UseNormalizedCoordinates`, `Color`) configure individual zones as shown above.

## Direct C# analytics API

The pure C# analytics types (`ByteTracker`, `LineZone`, `PolygonZone`, `DetectionFilter`) are also available directly, without a Media Blocks pipeline:

```
using SkiaSharp;
using VisioForge.Core.AI;
using VisioForge.Core.AI.Analytics;
using VisioForge.Core.AI.Analytics.Tracking;
using VisioForge.Core.AI.Analytics.Zones;
using VisioForge.Core.Types.X.AI;

var tracker = new ByteTracker(new ByteTrackerSettings());
var filtered = DetectionFilter.Apply(detections, new DetectionFilterSettings
{
    IncludedClassIds = new[] { (int)CocoClass.Person },
    MinimumBoxArea = 1200,
});

var update = tracker.Update(filtered);
var zone = new PolygonZone(new PolygonZoneSettings
{
    Id = "area",
    Points = new[] { new SKPoint(100, 100), new SKPoint(500, 100), new SKPoint(500, 400), new SKPoint(100, 400) },
});

var snapshot = zone.Update(update);
Console.WriteLine($"Inside: {snapshot.CurrentCount}");
```

## Use with VideoCaptureCoreX and MediaPlayerCoreX

```
var analytics = new ObjectAnalyticsBlock(settings);
analytics.OnAnalyticsUpdated += Analytics_OnAnalyticsUpdated;

core.Video_Processing_AddBlock(analytics); // before StartAsync (VideoCaptureCoreX)
// player.Video_Processing_AddBlock(analytics); // before OpenAsync/PlayAsync (MediaPlayerCoreX)

await core.StartAsync();
```

See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the full processing-block API, insertion order, and lifecycle rules shared by every video AI block.

## Use cases

- **People counting and footfall analytics** — count entries/exits through a doorway with a [line zone](#line-crossings), or occupancy in a room/aisle with a [polygon zone](#polygon-zones-occupancy-from-tracked-boxes).
- **Queue and dwell-time monitoring** — track how long a `TrackerId` stays inside a zone using the `CurrentCount`/`TrackerIds` snapshot each frame.
- **Vehicle counting and traffic direction** — a directed tripwire reports `In`/`Out` per lane or driveway.
- **Restricted-area / perimeter alerts** — raise an alert in your app when `EnteredTrackerIds` is non-empty for a zone that should stay empty.
- **Retail heat-mapping** — accumulate `Objects` positions over time from `OnAnalyticsUpdated` to build a movement heat-map outside the block itself.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| Tracker IDs keep changing for the same object | `LostTrackBuffer` too low for the occlusion length, or `ClassAwareMatching` rejecting a borderline detection | Raise `ByteTrackerSettings.LostTrackBuffer`; confirm the detector reports a consistent `ClassId` for the object. |
| Objects flicker in and out of a zone at the boundary | No deadband/anchor mismatch | For lines, raise `LineZoneSettings.DeadbandPixels`. For zones, confirm `Anchor` matches your scenario (`BottomCenter` for feet/ground contact, `Center` otherwise). |
| A zone never reports an exit for an object that clearly left | The track was lost before it could report `Out`/exit — check `ExpiredTrackerIds` | This is expected: `PolygonZoneSnapshot.ExpiredTrackerIds` reports tracks that disappeared while still inside, distinct from `ExitedTrackerIds` (movement-based exits). |
| Line crossing direction is reversed from what you expect | `Start`/`End` order defines direction | Swap `Start` and `End` on the `LineZoneSettings`. |
| Overlay draws boxes/labels you don't want | Default `ObjectAnalyticsOverlaySettings` draws everything | Set the specific `Draw*` flags (`DrawBoxes`, `DrawTraces`, `DrawZoneCounts`, ...) to `false`; events are still raised regardless of overlay settings. |
| Coordinates don't line up across different camera resolutions | Zone/line points defined in fixed pixels | Set `UseNormalizedCoordinates = true` on the `LineZoneSettings`/`PolygonZoneSettings` and use `0..1` fractions instead. |

## Frequently Asked Questions

### What's the difference between a line zone and a polygon zone?

A line zone (`LineZoneSettings`) is a directed tripwire that reports a crossing event (`LineCrossingResult`) the instant a tracked object's anchor crosses it. A polygon zone (`PolygonZoneSettings`) is an area whose current occupancy (`PolygonZoneSnapshot`) is reported every update — use lines for counting crossings, zones for "who/how many are inside right now".

### Does ObjectAnalyticsBlock work with any object detector?

It works with any detector supported by `YoloDetectorSettings` — `YOLOv8`, `YOLOX`, and `RTDETR` — by wrapping that detector's settings in `ObjectAnalyticsSettings(detector)`.

### Can I use the tracker without a Media Blocks pipeline?

Yes — `ByteTracker`, `LineZone`, `PolygonZone`, and `DetectionFilter` are public C# types you can call directly against your own detections; see [Direct C# analytics API](#direct-c-analytics-api).

### How many lines and zones can one block track at once?

There's no fixed limit in the API — `ObjectAnalyticsSettings.Lines` and `.Zones` are plain lists you can add as many entries to as your scenario needs; each is evaluated independently against the same tracked objects every frame.

## Demos

- **[YOLO Object Detection Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/YOLO%20Object%20Detection%20Demo)** — includes both standalone object detection and object analytics modes.
- **[Polygon Zone Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Polygon%20Zone%20Demo)** — polygon occupancy with live current, entered, exited, and expired track events.
- **[Tripwire Analytics Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Tripwire%20Analytics%20Demo)** — directed line crossing and track IDs.

---END OF PAGE---


## Object Detection SDK for .NET — YOLOObjectDetectorBlock
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/object-detection/
**Description:** Object detection SDK for .NET — detect objects in video with YOLOObjectDetectorBlock. YOLOv8, YOLOX, and RT-DETR ONNX models, cross-platform, CPU or GPU.
**Tags:** .NET, AI, ONNX, YOLO, Object Detection, Object Detection SDK, Computer Vision, VideoCaptureCoreX, MediaPlayerCoreX
**API:** YOLOObjectDetectorBlock, YoloDetectorSettings, ObjectDetectorModel, OnnxDetection

# Object Detection — YOLOObjectDetectorBlock

`YOLOObjectDetectorBlock` detects objects directly in the video stream. It taps RGBA frames with an internal sample grabber, runs the configured ONNX detector, optionally draws boxes and labels into the frame, and raises `OnObjectsDetected` for processed frames that contain detections. Use it when you need boxes and labels without tracking, tripwires, or zone analytics — see [Object analytics](../object-analytics/) for tracked, zone-aware detection.

```
graph LR;
    Source-->YOLOObjectDetectorBlock;
    YOLOObjectDetectorBlock-->VideoRendererBlock;
    YOLOObjectDetectorBlock-. OnObjectsDetected .->App[Your app];
```

## Supported detector families

Set `YoloDetectorSettings.Model` to match the ONNX model layout.

| Model | Decoder and preprocessing | Licensing note |
| --- | --- | --- |
| `ObjectDetectorModel.YOLOv8` (default) | Ultralytics YOLOv8 / YOLO11 layout `[1, 4 + numClasses, numAnchors]`; centered letterbox, RGB, normalized to 0..1, class-wise NMS. | Ultralytics models are AGPL-3.0; a closed-source product requires a commercial Ultralytics license. |
| `ObjectDetectorModel.YOLOX` | YOLOX layout `[1, numAnchors, 5 + numClasses]`; top-left letterbox, BGR, no 0..1 normalization, class-wise NMS. | YOLOX model family is Apache-2.0. |
| `ObjectDetectorModel.RTDETR` | RT-DETR / D-FINE transformer layout with `logits` and `pred_boxes`; direct resize, RGB, normalized to 0..1, NMS-free. | RT-DETR / D-FINE model families are Apache-2.0. |

The SDK does not ship detector weights in the NuGet package. The `IoUThreshold` setting applies only to the NMS-based families (YOLOv8, YOLOX); RT-DETR is NMS-free and ignores it. `NormalizeTo01` is honored only by YOLOv8 — YOLOX and RT-DETR fix their normalization to their training convention.

Model licenses

A model's license is set by its origin (training code + published weights), not by the ONNX format. Avoid AGPL/GPL-licensed models (for example stock Ultralytics YOLO weights) in a closed-source product without a commercial license.

## Standalone or ObjectAnalyticsBlock?

Use `YOLOObjectDetectorBlock` when each frame can be handled independently: draw boxes, collect labels, trigger simple alerts, or feed detections into your own logic. Use [`ObjectAnalyticsBlock`](../object-analytics/) when you need stable tracker IDs, line-crossing events, polygon-zone occupancy, object traces, and counters. `ObjectAnalyticsBlock` internally reuses `YoloDetectorSettings` for its detector, but its renderer and event model are built around tracked objects rather than raw per-frame detections.

## Usage

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.VideoProcessing;
using VisioForge.Core.Types.X.AI;

var detectorSettings = new YoloDetectorSettings(modelPath)
{
    Model = ObjectDetectorModel.YOLOX,
    ConfidenceThreshold = 0.6f,
    IoUThreshold = 0.45f,
    DrawDetections = true,
    DrawLabels = true,
    FramesToSkip = 0,
    Provider = OnnxExecutionProvider.Auto,
};

var detector = new YOLOObjectDetectorBlock(detectorSettings);
detector.OnObjectsDetected += (sender, e) =>
{
    foreach (OnnxDetection obj in e.Objects)
    {
        Console.WriteLine($"{obj.Label} #{obj.ClassId} {obj.Confidence:P0} at {obj.Box}");
    }
};

var videoRenderer = new VideoRendererBlock(pipeline, videoView) { IsSync = false };

pipeline.Connect(source.Output, detector.Input);
pipeline.Connect(detector.Output, videoRenderer.Input);

await pipeline.StartAsync();

Console.WriteLine($"Active provider: {detector.ActiveProvider}");
```

Each `OnnxDetection` contains the bounding `Box` in source-frame pixel coordinates, `ClassId`, `Label`, `Confidence`, and `TrackerId`. In standalone detection `TrackerId` is always `-1` because no tracker has assigned an identity.

## Key settings

`YoloDetectorSettings` extends `OnnxInferenceSettings`.

| Property | Default | Description |
| --- | --- | --- |
| `ModelPath` | — | Absolute path to the detector `.onnx` file. Required. |
| `Model` | `ObjectDetectorModel.YOLOv8` | Selects the decoder and preprocessing convention. |
| `ConfidenceThreshold` | `0.60` | Minimum confidence for a reported detection. |
| `IoUThreshold` | `0.45` | Non-maximum suppression threshold for YOLOv8 and YOLOX. RT-DETR is NMS-free. |
| `Labels` | `null` | Optional class names. When `null`, the detector uses the default COCO-80 labels. |
| `DrawDetections` | `true` | Draw detection boxes into the video frame. |
| `BoxColor` / `BoxThickness` | Lime / `2` | Box overlay styling. |
| `DrawLabels` / `LabelFontSize` | `true` / `0` | Draw labels and confidence values. `0` auto-scales label text to frame height. |
| `InputWidth` / `InputHeight` | `640` / `640` | Used for dynamic-input models. Fixed-size models report their own input size. |
| `NormalizeTo01` | `true` | Honored by the YOLOv8 family only. |
| `Provider` / `DeviceId` | `Auto` / `0` | ONNX execution provider and hardware device index. |
| `FramesToSkip` | `0` | Skip frames between inference runs to reduce CPU/GPU load. |

`YOLOObjectDetectorBlock.ActiveProvider` reports the provider actually engaged after the block is built.

## Use with VideoCaptureCoreX and MediaPlayerCoreX

```
var detector = new YOLOObjectDetectorBlock(detectorSettings);
detector.OnObjectsDetected += Detector_OnObjectsDetected;

core.Video_Processing_AddBlock(detector); // before StartAsync (VideoCaptureCoreX)
// player.Video_Processing_AddBlock(detector); // before OpenAsync/PlayAsync (MediaPlayerCoreX)

await core.StartAsync();
```

See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the full processing-block API, insertion order, and lifecycle rules shared by every video AI block.

## Use cases

- **Security and surveillance** — flag the presence of people, vehicles, or specific object classes in a camera feed.
- **Retail analytics** — detect products, baskets, or people in a store aisle for a downstream business-logic layer.
- **Industrial and safety monitoring** — detect required PPE items, obstacles, or equipment in a frame (with a model trained for those classes).
- **Wildlife and traffic monitoring** — detect animals or vehicles in a fixed camera feed.
- **Pre-filtering for a heavier pipeline** — use standalone detection as a cheap first pass, and only run a more expensive block (OCR, face recognition) on frames or regions where something was detected.

Need identities that persist across frames, line-crossing counts, or zone occupancy instead of raw per-frame boxes? Use [Object analytics](../object-analytics/) — it wraps the same detector families with ByteTrack tracking, tripwires, and polygon zones.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| No detections at all | `ConfidenceThreshold` too high for the model/scene, or the wrong `Model` family selected for the ONNX file | Lower `ConfidenceThreshold`; confirm `Model` matches the exported model's layout (YOLOv8 vs YOLOX vs RT-DETR). |
| Too many false positives / duplicate boxes | `IoUThreshold` too high (weak suppression) — NMS-based families only | Lower `IoUThreshold`. Note RT-DETR is NMS-free and ignores this setting. |
| Boxes are offset from the real object | Wrong `Model` family for the ONNX file — each family uses a different letterbox/color-order convention | Set `Model` to match the exported model exactly; a mismatched decoder silently produces plausible-looking but wrong boxes. |
| Labels show numbers instead of names | `Labels` is `null` and the model isn't COCO-80 | Set `Labels` to the class-name array your model was trained with. |
| High CPU/GPU usage on live video | Inference running on every frame | Raise `FramesToSkip`; the block still passes every frame through, it just infers less often. |

## Frequently Asked Questions

### Which detector family should I start with?

`YOLOv8` (the default) if you're using stock Ultralytics-exported weights, but check the AGPL-3.0 licensing note first. `YOLOX` and `RT-DETR` are Apache-2.0 alternatives with no commercial-license requirement.

### Can I use my own trained YOLO model?

Yes — as long as it was exported in the layout of one of the three supported families (`YOLOv8`/`YOLOX`/`RTDETR`) and you set `Model` and `Labels` to match your training classes.

### Does YOLOObjectDetectorBlock track objects across frames?

No — each detection is independent per frame (`TrackerId` is always `-1`). Use [`ObjectAnalyticsBlock`](../object-analytics/) when you need stable identities, tripwires, or zones.

### Is a GPU required for real-time detection?

No, but a GPU execution provider (`CUDA`, `DirectML`, or `CoreML`) lowers per-frame latency compared to CPU, which matters most for high frame rates or larger detector models.

## Demos

- **[YOLO Object Detection Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/YOLO%20Object%20Detection%20Demo)** — WPF Media Blocks demo covering both standalone detection and object analytics modes.
- **[YOLO Object Detection MB](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/MAUI/YOLO%20Object%20Detection%20MB)** — the same Media Blocks demo for MAUI.

Dedicated `VideoCaptureCoreX`/`MediaPlayerCoreX` object-detection demos (`Capture Object Detection X`, `Capture Object Detection X WPF`, `Player Object Detection X`, `Player Object Detection X WPF`) are in the SDK's demo set and will be linked here once published to the public samples repository.

---END OF PAGE---


## OCR SDK for .NET — OcrBlock Text Recognition (PaddleOCR)
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/ocr/
**Description:** OCR SDK for .NET — recognize text in video and images with OcrBlock (ONNX Runtime + PaddleOCR). Cross-platform C# on Windows, macOS, Linux, Android, iOS.
**Tags:** .NET, AI, OCR, OCR SDK, ONNX, PaddleOCR, Text Recognition, Computer Vision, VideoCaptureCoreX, MediaPlayerCoreX
**API:** OcrBlock, OcrSettings, OcrTextRegion, OcrPoint

# OCR Text Recognition — OcrBlock

`OcrBlock` recognizes text in any video or image source. Internally it runs the multi-stage PP-OCR pipeline — text detection (DBNet) → optional 0°/180° angle classification → text-line recognition (CRNN/SVTR + CTC decoding) — on each processed frame, raises the recognized regions, and optionally draws them into the video. The block lives in `VisioForge.Core.AI` (`VisioForge.DotNet.Core.AI`), implements `IVideoProcessingBlock`, and has one video `Input` and one video `Output`.

```
graph LR;
    Source-->OcrBlock;
    OcrBlock-->VideoRendererBlock;
    OcrBlock-. OnTextDetected .->App[Your app];
```

## Usage

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.Types.X.AI;

var ocrSettings = new OcrSettings(
    detectionModelPath: "ch_PP-OCRv5_mobile_det.onnx",
    recognitionModelPath: "latin_PP-OCRv5_rec_mobile_infer.onnx",
    characterDictionaryPath: "ppocrv5_latin_dict.txt",
    classificationModelPath: "ch_ppocr_mobile_v2.0_cls_infer.onnx")
{
    Provider = OnnxExecutionProvider.Auto, // CPU / CUDA / DirectML / CoreML
    FramesToSkip = 3,                      // run OCR every 4th frame on live video
    DrawResults = true,                    // burn boxes + text into the frame
};

var ocr = new OcrBlock(ocrSettings);
ocr.OnTextDetected += (sender, e) =>
{
    foreach (var region in e.Regions)
    {
        Console.WriteLine($"{region.Text} ({region.Confidence:P0}) at {region.BoundingBox}");
    }
};

pipeline.Connect(source.Output, ocr.Input);
pipeline.Connect(ocr.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

Each `OcrTextRegion` carries the recognized `Text`, an average `Confidence` (0..1), an axis-aligned `BoundingBox` (`Rect`), and the detection `Polygon` — the detector's four `OcrPoint` vertices (top-left, top-right, bottom-right, bottom-left, in source-frame pixels), which may be rotated for slanted text.

## Key settings

`OcrSettings(detectionModelPath, recognitionModelPath, characterDictionaryPath, classificationModelPath = null)` sets `UseAngleClassifier` from whether a classification model path was supplied.

| Property | Default | Description |
| --- | --- | --- |
| `DetectionModelPath` | — | Text-detection (DBNet) ONNX model. Required. |
| `RecognitionModelPath` | — | Text-recognition (CRNN/SVTR) ONNX model. Required. |
| `CharacterDictionaryPath` | — | Recognizer character dictionary; must match the recognition model's language. Required. |
| `ClassificationModelPath` | `null` | Optional 0°/180° angle classifier. |
| `UseAngleClassifier` | `true` | Apply the angle classifier (needs `ClassificationModelPath`). |
| `Provider` | `Auto` | ONNX execution provider. |
| `DeviceId` | `0` | Device index for hardware execution providers. |
| `FramesToSkip` | `0` | Frames skipped between OCR runs. Use a non-zero value for live video. |
| `MaxSideLength` | `1024` | Detector input's longer side is resized to this value. `0` or negative uses the adaptive PP-OCRv5 resize path instead. |
| `BoxThreshold` | `0.3` | Binarization threshold applied to the detector probability map. |
| `BoxScoreThreshold` | `0.5` | Minimum mean probability a detected region must reach to be kept. |
| `UnclipRatio` | `1.6` | Expansion ratio used to grow detected text polygons. |
| `TextScoreThreshold` | `0.5` | Minimum average per-character recognition score for a line to be reported. |
| `DrawResults` | `true` | Draw boxes + text into the frame. |
| `BoxColor` | Lime | Region box/text color when `DrawResults` is enabled. |
| `BoxThickness` | `2` | Region box stroke thickness, in pixels. |
| `LabelFontSize` | `0` | Label font size in pixels; `0` auto-scales to frame height. |

## Models and licensing

`OcrBlock` runs third-party ONNX models; the SDK does not ship weights in the NuGet package. The demos ship the Apache-2.0 **PP-OCRv5 mobile** models (detection, angle classification, Latin recognition) and a Latin dictionary next to the sample executables. PP-OCR supports 100+ languages — download the matching recognition model and dictionary for other languages.

Model licenses

A model's license is set by its origin (training code + published weights), not by the ONNX format. Verify the license of any model — code, weights, and dataset — before shipping it. The bundled PP-OCR models are Apache-2.0.

## Use with VideoCaptureCoreX and MediaPlayerCoreX

`OcrBlock` implements `IVideoProcessingBlock`, so it can be registered directly on `VideoCaptureCoreX` or `MediaPlayerCoreX` instead of building a manual Media Blocks pipeline:

```
var ocr = new OcrBlock(ocrSettings);
ocr.OnTextDetected += Ocr_OnTextDetected;

core.Video_Processing_AddBlock(ocr); // before StartAsync (VideoCaptureCoreX)
// player.Video_Processing_AddBlock(ocr); // before OpenAsync/PlayAsync (MediaPlayerCoreX)

await core.StartAsync();
```

See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the full processing-block API, insertion order, and lifecycle rules shared by every video AI block.

## Use cases

- **Document and screen capture** — recognize text from scanned documents, ID cards, forms, or shared screens in a video conferencing pipeline.
- **Retail and warehouse automation** — read product labels, barcodes' printed text, or shelf tags from a fixed overhead or handheld camera.
- **Industrial inspection** — read serial numbers, batch codes, or printed labels on a production line.
- **Signage and broadcast monitoring** — verify that on-screen text (lower thirds, tickers, digital signage) matches expected content.
- **Accessibility tooling** — extract on-screen text for text-to-speech or translation pipelines.

For a specific, narrower case — reading vehicle license plates — use the purpose-built [License plate recognition (ANPR)](../license-plate-recognition/) block instead of general OCR; it is both more accurate and faster because it runs a plate-specific detector and OCR head rather than scanning the whole frame for any text.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| `OnTextDetected` never fires | No handler subscribed, or `FramesToSkip` combined with a very short clip | Subscribe before `StartAsync`/`OpenAsync`; lower `FramesToSkip`. |
| Recognized text is empty or garbled | `CharacterDictionaryPath` doesn't match `RecognitionModelPath`'s language | Use the dictionary shipped with that specific recognition model. |
| Slanted or rotated text is missed | `UseAngleClassifier` is `false`, or `ClassificationModelPath` wasn't supplied | Provide `ClassificationModelPath` and leave `UseAngleClassifier` at its default `true`. |
| Small text is missed on a large frame | `MaxSideLength` too low for the source resolution | Raise `MaxSideLength`, or set it to `0` to use the adaptive PP-OCRv5 resize path. |
| High CPU usage on live video | OCR running on every frame | Set `FramesToSkip` to a non-zero value; OCR is heavier per frame than a single-model detector. |
| `Provider = CUDA`/`DirectML` silently falls back to CPU | The corresponding native ONNX Runtime execution-provider package isn't referenced, or no compatible GPU is present | Add the matching native runtime package for your platform, or use `Auto` and let the block pick what's actually available. |

## Frequently Asked Questions

### What's the difference between OcrBlock and LicensePlateRecognizerBlock?

`OcrBlock` reads arbitrary text anywhere in the frame. `LicensePlateRecognizerBlock` is a dedicated two-stage pipeline (a plate detector plus a plate-specific OCR head) tuned only for vehicle plates — use it instead of `OcrBlock` for ANPR/LPR scenarios.

### Does OcrBlock support languages other than English?

Yes. PP-OCR supports 100+ languages. Point `RecognitionModelPath` and `CharacterDictionaryPath` at the recognition model and dictionary for your target language; both must match.

### Can I run OCR on a still image instead of a live video stream?

Yes — connect a file/image source to `OcrBlock.Input` in a `MediaBlocksPipeline`, or feed a single frame through the pipeline; the block processes whatever frames reach its input pad, live or file-based.

### Does OcrBlock need a GPU to run in real time?

No, but a GPU execution provider (`CUDA`, `DirectML`, or `CoreML`) reduces per-frame latency compared to CPU. For live video, combining `FramesToSkip` with CPU inference is also a common, GPU-free way to keep OCR from becoming the pipeline bottleneck.

## Demos

- **[OCR Text Recognition Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/OCR%20Text%20Recognition%20Demo)** — WPF Media Blocks pipeline demo.
- **[OCR Text Recognition MB](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/MAUI/OCR%20Text%20Recognition%20MB)** — the same Media Blocks demo for MAUI.

Dedicated `VideoCaptureCoreX`/`MediaPlayerCoreX` OCR demos (`Capture OCR X`, `Capture OCR X WPF`, `Player OCR X`, `Player OCR X WPF`) are in the SDK's demo set and will be linked here once published to the public samples repository.

---END OF PAGE---


## ONNX Runtime SDK for .NET — OnnxInferenceBlock Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/onnx-inference/
**Description:** Run any custom ONNX Runtime model over live video frames in .NET with OnnxInferenceBlock and get raw tensor outputs for your own post-processing.
**Tags:** .NET, AI, ONNX, ONNX Runtime, Inference, Custom Model, VideoCaptureCoreX, MediaPlayerCoreX
**API:** OnnxInferenceBlock, OnnxInferenceSettings, OnnxInferenceEventArgs, OnnxInferenceEngine

# Generic ONNX Inference — OnnxInferenceBlock

`OnnxInferenceBlock` is the lowest-level video AI block in `VisioForge.Core.AI` (`VisioForge.DotNet.Core.AI`). It taps RGBA video frames, preprocesses them into an ONNX Runtime input tensor, runs your model, and raises `OnInference` with the raw float outputs. The video frame passes through unchanged; the block does not draw overlays or interpret model-specific tensors.

Use this block when you have a custom ONNX model and want to own the decoder/post-processing logic in your application. Use [`YOLOObjectDetectorBlock`](../object-detection/) instead when the model is a supported object detector family, because the YOLO block already maps boxes back to the source frame and applies the correct decoder.

```
graph LR;
    Source-->OnnxInferenceBlock;
    OnnxInferenceBlock-->VideoRendererBlock;
    OnnxInferenceBlock-. OnInference .->App[Your app decoder];
```

## Pipeline example

```
using VisioForge.Core.AI;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.X.AI;

var settings = new OnnxInferenceSettings(modelPath)
{
    InputWidth = 224,
    InputHeight = 224,
    NormalizeTo01 = true,
    Provider = OnnxExecutionProvider.Auto,
    FramesToSkip = 2,
};

var inference = new OnnxInferenceBlock(settings);
inference.OnInference += (sender, e) =>
{
    foreach (var output in e.Outputs)
    {
        var name = output.Key;
        var values = output.Value;
        var shape = e.Shapes[name];

        Console.WriteLine($"{name} shape [{string.Join(",", shape)}], {values.Length} values");
    }
};

var videoRenderer = new VideoRendererBlock(pipeline, videoView) { IsSync = false };

pipeline.Connect(source.Output, inference.Input);
pipeline.Connect(inference.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

Inference is demand-driven

If no handler is attached to `OnInference`, the block skips inference because the frame is passed through unmodified and the output would be unobservable.

## How preprocessing works

The block uses `OnnxInferenceEngine` internally:

- The model file is loaded into an ONNX Runtime `InferenceSession`.
- `Provider = Auto` chooses CUDA, then DirectML, then CoreML, then CPU, from whichever providers are present in the loaded ONNX Runtime native build. One documented exception: open-vocabulary detection skips CoreML under `Auto`, because ONNX Runtime cannot map those graphs to it in fewer than a hundred partitions — see [Open-vocabulary detection](../open-vocabulary-detection/#why-does-auto-not-use-coreml-for-this-block).
- If the model declares a fixed input tensor size, that size overrides `InputWidth` and `InputHeight`.
- RGBA source frames are resized with a centered letterbox into the model input size.
- Pixels are converted to an RGB `NCHW` float tensor.
- `NormalizeTo01 = true` divides pixel values by 255; otherwise values stay in the 0..255 range.

The event payload keeps the model-specific work in your code. `OnnxInferenceEventArgs.Outputs` maps each output tensor name to a flattened row-major `float[]`, and `Shapes` maps the same name to the tensor dimensions. The meaning of those dimensions depends entirely on your model.

## Key settings

| Property | Default | Description |
| --- | --- | --- |
| `ModelPath` | — | Absolute path to the `.onnx` file. Required. |
| `InputWidth` / `InputHeight` | `640` / `640` | Used for dynamic-input models. Fixed-size models report their own input size. |
| `NormalizeTo01` | `true` | Divide RGB values by 255 during preprocessing. |
| `Provider` | `Auto` | ONNX execution provider. `Auto` tries hardware providers before CPU. |
| `DeviceId` | `0` | Hardware device index for CUDA/DirectML. |
| `FramesToSkip` | `0` | Run inference every `FramesToSkip + 1` frames. |

`OnnxInferenceBlock.ActiveProvider` reports the provider actually engaged after the block is built. `OnnxInferenceEngine.GetAvailableProviders()` can be called before building a pipeline to inspect the ONNX Runtime providers available in the current process.

## Direct engine API

Advanced integrations can use `OnnxInferenceEngine` directly outside a Media Blocks pipeline. It exposes `Initialize()`, `Preprocess(...)`, `Run(...)`, `OutputNames`, `InputWidth`, `InputHeight`, and `ActiveProvider`. `YoloDetector` is a public direct helper over the same engine for the supported detector families. Most applications should prefer the MediaBlocks wrappers because they handle pipeline pads, frame grabbing, and lifetime management.

## Use with VideoCaptureCoreX and MediaPlayerCoreX

```
var inference = new OnnxInferenceBlock(settings);
inference.OnInference += Inference_OnInference;

core.Video_Processing_AddBlock(inference); // before StartAsync (VideoCaptureCoreX)
// player.Video_Processing_AddBlock(inference); // before OpenAsync/PlayAsync (MediaPlayerCoreX)

await core.StartAsync();
```

See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the full processing-block API, insertion order, and lifecycle rules shared by every video AI block.

## Use cases

- **Custom classification models** — image classifiers, quality-control pass/fail models, or scene classifiers exported to ONNX from PyTorch/TensorFlow/scikit-learn.
- **Detector families the SDK doesn't decode yet** — run your model's raw tensors through `OnnxInferenceBlock` and write the decoder in your own code, exactly as [`YOLOObjectDetectorBlock`](../object-detection/) does internally for its three supported families.
- **Segmentation, depth, or pose models** — any single-input, tensor-output ONNX model can be wired up, as long as you own interpreting its output shape.
- **Prototyping** — validate a newly exported ONNX model against live or file video before committing to a purpose-built decoder.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| `OnInference` never fires | No handler subscribed | The block skips inference entirely when nothing observes the event — subscribe before `StartAsync`/`OpenAsync`. |
| Output values look wrong/saturated | `NormalizeTo01` doesn't match how the model was trained | Toggle `NormalizeTo01`; some models expect raw 0..255 pixel values instead of 0..1. |
| Model loads but every output is the same shape you didn't expect | The model has a fixed input size that overrides `InputWidth`/`InputHeight` | Check the model's declared input shape — a fixed-size model reports and uses its own size regardless of your settings. |
| `Provider = CUDA`/`DirectML` doesn't seem to engage | Missing native execution-provider package, or no compatible GPU | Check `OnnxInferenceBlock.ActiveProvider` after `StartAsync`, or call `OnnxInferenceEngine.GetAvailableProviders()` beforehand to see what's actually available in-process. |
| Boxes/keypoints look shifted from the source frame | Frame is letterbox-resized into the model's input size before inference | Map your model's normalized/model-space output coordinates back through the same letterbox transform before drawing on the source frame. |

## Frequently Asked Questions

### Can I use OnnxInferenceBlock for a model that isn't a YOLO detector?

Yes — that's exactly what it's for. Unlike `YOLOObjectDetectorBlock`, `OnnxInferenceBlock` doesn't assume any output layout; it hands you the raw named output tensors and shapes for any single-input model.

### Does OnnxInferenceBlock draw anything on the frame?

No. It passes the frame through unchanged and never draws overlays — your application interprets `OnnxInferenceEventArgs.Outputs`/`Shapes` and draws whatever it needs downstream.

### How do I know which ONNX Runtime execution providers are available?

Call the static `OnnxInferenceEngine.GetAvailableProviders()` before building a pipeline, or read `OnnxInferenceBlock.ActiveProvider` after the block is built to see which provider was actually engaged.

### My model has multiple inputs — does OnnxInferenceBlock support that?

`OnnxInferenceSettings`/`OnnxInferenceBlock` are built around a single RGBA video-frame input tensor. For a multi-input model, use `OnnxInferenceEngine` directly outside the Media Blocks pipeline, where you control the full `Run(...)` call.

## Demos

`OnnxInferenceBlock` doesn't have a dedicated sample yet — it's exercised indirectly through the `OnnxInferenceEngine` used internally by [`YOLOObjectDetectorBlock`](../object-detection/) and [`ObjectAnalyticsBlock`](../object-analytics/). If you're prototyping a custom model, adapt the "Pipeline example" above with your own model path and output decoder.

---END OF PAGE---


## Detect Objects Without Training — Open Vocabulary .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/open-vocabulary-detection/
**Description:** Detect any object in video by naming it in text — zero-shot, no training data. On-device open-vocabulary detection for .NET (OWLv2, Grounding DINO).
**Tags:** .NET, AI, ONNX, Open Vocabulary Detection, Zero-Shot Detection, OWLv2, Grounding DINO, Computer Vision, VideoCaptureCoreX, MediaPlayerCoreX
**API:** OpenVocabularyDetectorBlock, OpenVocabularyDetectorSettings, OpenVocabularyModel, OnnxDetection

# Open Vocabulary Detection — OpenVocabularyDetectorBlock

You need to detect an object that no off-the-shelf model was trained on — a specific tool, product, or uniform — but you have no labeled dataset and no time to train and deploy a custom detector. **Open-vocabulary detection** solves this: name what you're looking for in plain text and the model finds it, with no training and no fixed class list. It runs on-device via ONNX (OWLv2 or Grounding DINO), and you can change what it detects at any time by editing the text prompts.

`OpenVocabularyDetectorBlock` detects objects described by **free-text prompts** instead of a fixed class list. You give it phrases like `"a person"`, `"a red backpack"`, or `"a forklift"`, and it finds them in the video stream — no retraining, no fixed label set. It taps RGBA frames, runs an open-vocabulary ONNX model (OWLv2 or Grounding DINO), optionally draws boxes and labels into the frame, and raises `OnObjectsDetected` for frames that contain detections.

Because open-vocabulary models are heavier than a fixed-class detector, inference runs on a background, latest-wins worker: the streaming thread submits a frame copy and only redraws the most recent cached detections, so the pipeline never stalls. Each detection's `Label` is the matched prompt string and its `ClassId` is that prompt's zero-based index.

```
graph LR;
    Source-->OpenVocabularyDetectorBlock;
    OpenVocabularyDetectorBlock-->VideoRendererBlock;
    OpenVocabularyDetectorBlock-. OnObjectsDetected .->App[Your app];
```

Need a fixed set of classes at maximum speed (COCO-80, or your own trained labels)? Use [`YOLOObjectDetectorBlock`](../object-detection/) instead — it is far faster but cannot detect a class it was not trained on. Open-vocabulary detection trades throughput for the ability to detect anything you can name.

## How open-vocabulary detection works

Open-vocabulary detection is a form of **zero-shot detection**: the model detects classes it was never explicitly trained on, specified at run time as text. Each frame goes through four steps:

1. **Encode the prompts.** Every prompt string is tokenized and turned into a text embedding. This is cheap and cached until you call `SetPrompts`, so it is not repeated per frame.
2. **Encode the frame.** The frame is preprocessed to the model's convention (OWLv2 pads to a square and resizes to 960x960; Grounding DINO resizes to its fixed size) and encoded into per-region image features.
3. **Score regions against prompts.** Each candidate region is scored against each prompt embedding; regions scoring above `ConfidenceThreshold` become detections, labeled with the matched prompt (`Label`) and its index (`ClassId`).
4. **Suppress overlaps.** Class-wise non-maximum suppression (`IoUThreshold`) removes duplicate boxes, and the top `MaxDetections` results are returned.

Steps 2–4 run on a background, latest-wins worker so the video never stalls — the streaming thread draws the most recent completed result while the next inference is still running.

## Supported model families

Set `OpenVocabularyDetectorSettings.Model` to match the ONNX model layout. Each family uses a different tokenizer and preprocessing convention.

| Model | Tokenizer and preprocessing | Notes |
| --- | --- | --- |
| `OpenVocabularyModel.OWLv2` (default) | CLIP byte-level BPE tokenizer (`vocab.json` + `merges.txt`). Frame padded to a square (top-left) and resized to 960x960; per-query sigmoid logits over a fixed patch grid. | Requires both `VocabFilePath` and `MergesFilePath`. Ignores `TextThreshold`. |
| `OpenVocabularyModel.GroundingDINO` | BERT WordPiece tokenizer (`vocab.txt` only). Prompts joined into a `prompt1 . prompt2 .` caption, lowercased; frame resized to the model's fixed input size; per-query token-span scores over 900 queries. | `MergesFilePath` is not used. `TextThreshold` filters weak per-token contributions. |

The SDK does not ship detector weights in the NuGet package — supply the `.onnx` model and its tokenizer files as local paths (see [Models](#models)). The inherited `InputWidth`/`InputHeight` are **ignored**: OWLv2 always runs at 960x960 and Grounding DINO uses the fixed size baked into its ONNX model.

## Usage

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.VideoProcessing;
using VisioForge.Core.Types.X.AI;

var settings = new OpenVocabularyDetectorSettings(
    "owlv2-base-ensemble.onnx",
    "owlv2-vocab.json",
    "owlv2-merges.txt",
    new[] { "a person", "a car", "a red backpack" })
{
    Model = OpenVocabularyModel.OWLv2,
    ConfidenceThreshold = 0.25f,
    IoUThreshold = 0.5f,
    DrawDetections = true,
    Provider = OnnxExecutionProvider.Auto,
};

var detector = new OpenVocabularyDetectorBlock(settings);
detector.OnObjectsDetected += (sender, e) =>
{
    foreach (OnnxDetection obj in e.Objects)
    {
        // obj.Label is the matched prompt; obj.ClassId is its index in the prompt array.
        Console.WriteLine($"{obj.Label} {obj.Confidence:P0} at {obj.Box}");
    }
};

var videoRenderer = new VideoRendererBlock(pipeline, videoView) { IsSync = false };

pipeline.Connect(source.Output, detector.Input);
pipeline.Connect(detector.Output, videoRenderer.Input);

await pipeline.StartAsync();

Console.WriteLine($"Active provider: {detector.ActiveProvider}");
```

Each `OnObjectsDetected` fires only when the frame has detections. `ObjectsDetectedEventArgs` carries `Objects` (an `OnnxDetection[]`) and the frame `Timestamp`. Each `OnnxDetection` has the bounding `Box` in source-frame pixel coordinates, `ClassId` (the prompt index), `Label` (the matched prompt), and `Confidence`. `TrackerId` is always `-1` — this block does not track objects across frames.

### Changing prompts and thresholds at runtime

Prompts and thresholds can be updated live without rebuilding the pipeline — the change applies on the next processed frame:

```
detector.SetPrompts(new[] { "a delivery truck", "a bicycle" });
detector.SetConfidenceThreshold(0.30f);
detector.SetIoUThreshold(0.45f);
```

## Key settings

`OpenVocabularyDetectorSettings` extends `OnnxInferenceSettings`.

| Property | Default | Description |
| --- | --- | --- |
| `ModelPath` | — | Absolute path to the open-vocabulary `.onnx` file. Required. |
| `Prompts` | `null` | Free-text detection prompts. Each becomes a detectable class; `Label` = prompt, `ClassId` = its index. |
| `VocabFilePath` | `null` | Tokenizer vocab: `vocab.json` (OWLv2) or `vocab.txt` (Grounding DINO). Required. |
| `MergesFilePath` | `null` | Byte-level BPE `merges.txt`. Required for OWLv2; leave `null` for Grounding DINO. |
| `Model` | `OpenVocabularyModel.OWLv2` | Selects the tokenizer, preprocessing, and output decoder. |
| `ConfidenceThreshold` | `0.25` | Minimum confidence (0..1) for a reported detection. |
| `TextThreshold` | `0.25` | Per-token text-score threshold for Grounding DINO. Ignored by OWLv2. |
| `IoUThreshold` | `0.5` | Non-maximum-suppression threshold for class-wise NMS. |
| `MaxDetections` | `100` | Maximum detections returned per frame, highest confidence first. |
| `DrawDetections` | `true` | Draw detection boxes into the video frame. |
| `DrawLabels` | `true` | Draw the prompt label and confidence next to each box. |
| `BoxColor` / `BoxThickness` | Lime / `2` | Box overlay styling. |
| `LabelFontSize` | `0` | Label text size in px. `0` auto-scales to frame height. |
| `Provider` / `DeviceId` | `Auto` / `0` | ONNX execution provider and hardware device index. |
| `FramesToSkip` | `0` | Skip frames between inference runs to reduce load. |

`InputWidth`/`InputHeight` and `NormalizeTo01` are inherited from `OnnxInferenceSettings` but the input size is ignored (each family fixes its own). `OpenVocabularyDetectorBlock.ActiveProvider` reports the provider actually engaged after the block is built; `LastInferenceTimeMs` and `DroppedFrameCount` expose live inference cost.

## Models

Model weights are not bundled with the SDK. The demos download them on first run from GitHub Releases and cache them under `%USERPROFILE%\VisioForge\models\openvocab`.

| Model | Files |
| --- | --- |
| OWLv2 | `owlv2-base-ensemble.onnx`, `owlv2-vocab.json`, `owlv2-merges.txt` |
| Grounding DINO | `grounding-dino-tiny.onnx`, `bert-vocab.txt` (no merges file) |

A model's license is set by its origin (training code and published weights), not by the ONNX format or the SDK's own license. Confirm the license of the specific weights you deploy before shipping a closed-source product.

## Writing effective prompts

Prompt phrasing directly affects recall and precision. A few practical rules:

- **Use short noun phrases** — `"a person"`, `"a delivery truck"`, `"a cardboard box"`. Full sentences and long qualifiers narrow recall.
- **One concept per prompt.** Each prompt is a separate class; don't combine ("a person or a bag").
- **Start broad, then narrow.** `"a car"` detects more than `"a red sports car"`. Add descriptors only when you need to filter.
- **Grounding DINO lowercases prompts** and joins them into a single `.`-separated caption — keep phrases distinct and unambiguous.
- **Each prompt adds text-encoding cost** at prompt-change time (not per frame), so a huge live vocabulary is fine to index but trim it if `SetPrompts` calls feel slow.

## Performance and tuning

Open-vocabulary models are heavier than a fixed-class detector, so throughput is lower — plan for it rather than fighting it:

- **The pipeline never stalls.** Inference is asynchronous and latest-wins, so live video keeps playing; boxes reflect the most recent completed inference.
- **Lower the inference rate** with `FramesToSkip` when you don't need a result on every frame — the block still passes every frame through.
- **Use a GPU provider** (`CUDA` or `DirectML`) via `Provider`/`DeviceId` for a large latency drop over CPU. **Do not set `CoreML` for these models on Apple hardware** — see the note below.
- **Input size is fixed per family** (OWLv2 960x960; Grounding DINO its baked-in size) and cannot be lowered to trade accuracy for speed — pick the lighter model instead if you need more headroom.
- **Watch live cost** with `LastInferenceTimeMs` and `DroppedFrameCount`, and read the engaged provider from `ActiveProvider` after the block is built.

## Use with VideoCaptureCoreX and MediaPlayerCoreX

The same block instance drops into either high-level engine. Register it before the session starts:

```
var detector = new OpenVocabularyDetectorBlock(settings);
detector.OnObjectsDetected += Detector_OnObjectsDetected;

core.Video_Processing_AddBlock(detector);   // VideoCaptureCoreX — before StartAsync
// player.Video_Processing_AddBlock(detector); // MediaPlayerCoreX — before OpenAsync/PlayAsync

await core.StartAsync();

// Prompts and thresholds are still live-updatable while the session runs:
detector.SetPrompts(new[] { "a person wearing a hard hat" });
```

`SetPrompts` makes open-vocabulary detection especially useful on a live camera feed: an operator can change what to look for on the fly. See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the full processing-block API, insertion order, and lifecycle rules shared by every video AI block.

## Open-vocabulary detection vs training your own model

The choice comes down to whether you have labeled data and how much the target classes change.

| Situation | Best choice |
| --- | --- |
| No labeled data, and you need results now | **Open-vocabulary** — describe the class in text, zero training. |
| The target classes change often, or the user picks them at run time | **Open-vocabulary** — swap prompts live with `SetPrompts`, no redeploy. |
| A large labeled dataset and a need for maximum accuracy on fixed classes | **Train a model** — YOLO / RT-DETR; see [object detection](../object-detection/). |
| The highest possible frame rate on a few well-known classes | **Trained fixed-class detector** — it's faster; open-vocabulary trades speed for flexibility. |

A common pattern is to prototype with open-vocabulary detection to confirm a class is even detectable in your footage, then train a fixed-class model later only if you need the extra speed.

## Use cases

- **Ad-hoc surveillance queries** — search a camera feed for "a person carrying a bag" or "a white van" without training a custom model.
- **Retail and inventory** — detect an arbitrary product described in words, or empty shelf space, for a downstream business layer.
- **Prototyping and triage** — validate that a class is detectable in your footage before investing in a trained, fixed-class YOLO model for production speed.
- **Long-tail and rare classes** — detect objects that have no off-the-shelf trained detector by simply naming them.
- **Interactive tools** — let an end user type what to find, and update `SetPrompts` from the UI.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| No detections at all | `ConfidenceThreshold` too high, prompts too specific, or the wrong `Model` family for the ONNX file | Lower `ConfidenceThreshold`; use simpler prompts ("a car" before "a red sports car"); confirm `Model` matches the exported model. |
| Tokenizer / startup error | Missing or mismatched tokenizer files | OWLv2 needs `VocabFilePath` **and** `MergesFilePath`; Grounding DINO needs only `VocabFilePath` (`vocab.txt`). |
| Duplicate or overlapping boxes | `IoUThreshold` too high (weak suppression) | Lower `IoUThreshold` (or call `SetIoUThreshold`). |
| Grounding DINO returns noisy tokens | `TextThreshold` too low | Raise `TextThreshold` — OWLv2 ignores this setting. |
| High CPU/GPU usage on live video | Inference running on every frame | Raise `FramesToSkip`; the block still passes every frame through, it just infers less often. |
| Boxes appear only after a delay | Expected — inference is asynchronous and latest-wins | The frame is never stalled; boxes reflect the most recent completed inference. |

## Frequently Asked Questions

### How do I detect a custom object without a dataset?

Name it in a text prompt — for example `new OpenVocabularyDetectorSettings(modelPath, vocabPath, mergesPath, new[] { "a forklift", "a safety vest" })`. There are no images to collect, no labeling, and no training run. If a plain noun phrase under-detects, make it slightly more specific (`"an orange safety vest"`). See [Writing effective prompts](#writing-effective-prompts).

### Do I need to train or fine-tune anything?

No. Open-vocabulary models are pre-trained to detect arbitrary text-described classes, so you supply only the prompt text plus the ONNX model and tokenizer files — there is no training or fine-tuning step.

### Which model should I start with?

`OWLv2` (the default) gives strong open-vocabulary accuracy and takes both a vocab and a merges file. `GroundingDINO` (tiny) is a lighter alternative that uses only a `vocab.txt` and phrase-grounds a `.`-separated caption. Try OWLv2 first; switch to Grounding DINO if you need a smaller model.

### How is this different from YOLOObjectDetectorBlock?

[`YOLOObjectDetectorBlock`](../object-detection/) detects a **fixed** set of classes it was trained on, very fast. Open-vocabulary detection detects **anything you describe in text**, at a higher per-frame cost. Use YOLO for known classes at high frame rates; use open-vocabulary for flexible or rare queries.

### Can I change what it looks for while it's running?

Yes — call `SetPrompts` at any time. The new prompts apply on the next processed frame, with no pipeline rebuild. `SetConfidenceThreshold` and `SetIoUThreshold` are also live.

### Does it track objects across frames?

No — each detection is independent per frame and `TrackerId` is always `-1`. For persistent identities, tripwires, or zone counting, see [Object analytics](../object-analytics/).

### Is a GPU required?

No. `Provider` defaults to `Auto`, which runs on the CPU when no GPU provider is present. A `CUDA` or `DirectML` provider lowers per-frame latency, which matters most for these heavier models.

### Why does `Auto` not use CoreML for this block?

On Apple hardware `Auto` picks CPU for open-vocabulary detection even though CoreML is available, and that is deliberate. ONNX Runtime cannot map these graphs to CoreML in one piece: it splits OWLv2 into 126 partitions and Grounding DINO into 255, each compiled and held as a separate CoreML model. The result is not slow, it is unusable — measured on a 24 GB Mac, the session grew past 5.8 GB resident plus several GB of swap and never settled, while the same model on CPU peaks at about 4 GB and returns a frame in roughly 1.3 s.

Only the `Auto` default is redirected. Setting `Provider = OnnxExecutionProvider.CoreML` explicitly still does exactly what you ask, and it is not recommended for these two model families. Other AI blocks are unaffected — models that CoreML maps in a handful of partitions still use it.

### Is open-vocabulary detection the same as zero-shot object detection?

Yes. "Open-vocabulary" and "zero-shot" describe the same capability here: detecting object classes the model was not explicitly trained on, chosen at run time by text prompt rather than by a fixed label set. OWLv2 and Grounding DINO are two well-known open-vocabulary (zero-shot) detector families.

### How many prompts can I detect at once?

There is no hard limit on the number of prompts — each becomes its own class. `MaxDetections` (default `100`) caps how many boxes are returned per frame, not how many prompts you supply. More prompts add text-encoding cost when you set them, not on every frame.

### Can it run completely offline?

Yes. Inference is entirely local ONNX — no cloud call at run time. Only the initial model download needs a network, and you can ship the `.onnx` and tokenizer files with your app to avoid even that.

### Why are detections labeled with my prompt text?

By design. Unlike a fixed-class detector that emits numeric class ids, each open-vocabulary detection's `Label` is the exact prompt it matched and its `ClassId` is that prompt's zero-based index in the array you supplied — so you always know which query produced each box.

### Can I use my own open-vocabulary ONNX model?

Yes, as long as it matches one of the supported layouts (`OWLv2` or `GroundingDINO`) and you point `VocabFilePath`/`MergesFilePath` at the matching tokenizer files and set `Model` accordingly.

## Demos

Dedicated demos built on Media Blocks, `VideoCaptureCoreX`, and `MediaPlayerCoreX` (`Open Vocabulary Detection Demo`, `Open Vocabulary Detection MB`, `Capture Open Vocabulary Detection X`, `Capture Open Vocabulary Detection X WPF`, `Player Open Vocabulary Detection X`, `Player Open Vocabulary Detection X WPF`) are in the SDK's demo set and will be linked here once published to the public samples repository.

---END OF PAGE---


## PII Redaction SDK for .NET — Blur Faces & License Plates
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/pii-redaction/
**Description:** Redact PII in video on-device with PIIRedactionBlock — blur or pixelate faces, license plates, and on-screen text. GDPR/CCPA/BIPA-friendly, no cloud.
**Tags:** .NET, AI, ONNX, PII Redaction, Video Anonymization, Face Blur, License Plate Redaction, GDPR, Privacy, VideoCaptureCoreX, MediaPlayerCoreX
**API:** PIIRedactionBlock, PIIRedactionSettings, PIIFaceRedactionSettings, PIIPlateRedactionSettings, PIITextRedactionSettings, PIIRedactionStyle, PIIRegionsRedactedEventArgs, PIIRegion

# PII Redaction — Blur Faces, License Plates, and On-Screen Text

`PIIRedactionBlock` automatically obscures personally identifiable information in a video stream: it detects **faces** (YuNet), **vehicle license plates** (FastALPR), and **on-screen text** (PaddleOCR), then blurs, pixelates, or fills each region in-place — before the frame reaches a renderer, an encoder, or a file. Every model runs locally on ONNX Runtime, so there is no cloud API call, no per-frame billing, and no video ever leaves the device. The block only *removes* PII — it never identifies a person or outputs a plate's characters, and recognized content is never exported: faces and plates are located by detection alone, while on-screen text runs OCR internally only to confirm (and optionally filter) what to redact. Any of the three categories can be enabled independently, and the redaction style, blur strength, and enabled categories can all be changed while the pipeline is running.

```
graph LR;
    Source-->PIIRedactionBlock;
    PIIRedactionBlock-->VideoRendererBlock;
    PIIRedactionBlock-. OnRegionsRedacted .->App[Your app];
```

## Usage

The block sits in the middle of a Media Blocks pipeline: it takes video from a source, redacts it, and passes the cleaned frames on to the next block — a renderer, an encoder, or a file sink. The full example below reads a file, blurs all three PII categories, previews the result, and reports what was covered on each frame.

```
using System;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.X.AI;
using VisioForge.Core.Types.X.Sources;

// 1. Create the pipeline and a source. A file is used here; a webcam (SystemVideoSourceBlock) or an
//    IP camera (RTSPSourceBlock) plugs in exactly the same way — only the source block changes.
var pipeline = new MediaBlocksPipeline();

var sourceSettings = await UniversalSourceSettings.CreateAsync(
    "input.mp4", renderVideo: true, renderAudio: false);
var source = new UniversalSourceBlock(sourceSettings);

// 2. Configure which PII categories to redact and how they are obscured.
var settings = new PIIRedactionSettings
{
    Style = PIIRedactionStyle.GaussianBlur,   // GaussianBlur (default), Pixelate, or SolidFill
    BlurRadius = 20f,                         // blur strength for GaussianBlur
};

// Faces — YuNet detector (detection only, no identity recognition).
settings.Faces.ModelPath = "face_detection_yunet_2023mar.onnx";

// License plates — FastALPR YOLOv9-T detector (detection only, plate characters are never read).
settings.LicensePlates.ModelPath = "yolo-v9-t-640-license-plates-end2end.onnx";

// On-screen text — PaddleOCR PP-OCR (detection + recognition). Needs three files.
settings.Text.DetectionModelPath = "ch_PP-OCRv5_mobile_det.onnx";
settings.Text.RecognitionModelPath = "latin_PP-OCRv5_rec_mobile_infer.onnx";
settings.Text.CharacterDictionaryPath = "ppocrv5_latin_dict.txt";

// Turn off any category you don't need — a disabled category needs no model:
// settings.Text.Enabled = false;

var redaction = new PIIRedactionBlock(settings);

// 3. Optional: report what was covered. The event fires on a background detection thread, so marshal to the
//    UI thread before touching UI. Only the category and box are reported — never the recognized content.
redaction.OnRegionsRedacted += (sender, e) =>
{
    int faces = 0, plates = 0, text = 0;
    foreach (var region in e.Regions)
    {
        switch (region.Category)
        {
            case PIICategory.Face: faces++; break;
            case PIICategory.LicensePlate: plates++; break;
            case PIICategory.Text: text++; break;
        }
    }

    Console.WriteLine($"[{e.Timestamp:hh\\:mm\\:ss}] redacted {faces} face(s), {plates} plate(s), {text} text region(s)");
};

// 4. Wire source -> redaction -> renderer and start. VideoView1 is your VideoView control (WPF/WinForms/etc.).
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(source.Output, redaction.Input);
pipeline.Connect(redaction.Output, videoRenderer.Input);

await pipeline.StartAsync();

// 5. When the ONNX sessions are up, confirm which hardware backend engaged.
Console.WriteLine($"PII redaction running on: {redaction.ActiveProvider}");

// ... later, on shutdown:
// await pipeline.StopAsync();
// await pipeline.DisposeAsync();
```

Key points about how the block behaves:

- **Redaction always runs**, even with no `OnRegionsRedacted` subscriber — covering the pixels *is* the block's output, so the event is purely for reporting/telemetry.
- **At least one category must be enabled with a valid model path**, or `Build` fails and the pipeline does not start. Enable only the categories you need; a disabled category loads no model and costs nothing.
- **Each `PIIRegion`** in the event carries only its `Category` (`Face`, `LicensePlate`, or `Text`), the padded `BoundingBox` in source-frame pixels, and the detection `Score` (0..1) — never the recognized content.
- **Detection runs on a background worker**, not the streaming thread, so live video never stalls; every frame is redacted with the most recent regions while the detector catches up (see [Privacy and compliance](#privacy-and-compliance) for the live-latency implication).
- **To redact straight to a file** instead of previewing, replace `VideoRendererBlock` with an encoder + sink (for example an `MP4OutputBlock`); the source → redaction → sink wiring is identical.

## Redaction categories and models

| Category | Detector | Model (license) | Notes |
| --- | --- | --- | --- |
| `Faces` | YuNet | `face_detection_yunet_2023mar.onnx` (MIT) | Detection only — no face is identified or matched. |
| `LicensePlates` | FastALPR YOLOv9-T | `yolo-v9-t-640-license-plates-end2end.onnx` (MIT) | Detection only — the plate characters are never read. |
| `Text` | PaddleOCR PP-OCR | detection + recognition + dictionary (Apache-2.0) | Recognition runs only to filter the detector's false positives; by default every recognized text region is redacted. |

The SDK does not ship model weights in the NuGet package — see [Getting the models](#getting-the-models).

Text redaction needs three files (detection model, recognition model, and character dictionary) whenever the category is enabled. Recognition is required because a text *detector* alone fires on textures and edges, so detection without recognition would redact most of a real scene; recognition confirms which boxes are actually text. An optional `ClassificationModelPath` corrects 180°-rotated text.

## Redaction styles

`PIIRedactionSettings.Style` selects how each detected region is obscured:

| `PIIRedactionStyle` | Effect | Related setting |
| --- | --- | --- |
| `GaussianBlur` (default) | Region is replaced with a Gaussian-blurred copy of itself. | `BlurRadius` (sigma, default 20). |
| `Pixelate` | Region is replaced with a coarse mosaic. | `PixelateBlockSize` (cell size in px, default 16). |
| `SolidFill` | Region is painted over with a solid color. | `FillColor` (default black). |

`Style`, `BlurRadius`, `PixelateBlockSize`, and `FillColor` can all be changed while the pipeline runs.

## Key settings

`PIIRedactionSettings`:

| Property | Default | Description |
| --- | --- | --- |
| `Faces` / `LicensePlates` / `Text` | enabled | The three per-category sub-settings objects (see below). |
| `Style` | `GaussianBlur` | Redaction style applied to every region. |
| `BlurRadius` | `20` | Gaussian blur sigma for `GaussianBlur`. |
| `PixelateBlockSize` | `16` | Mosaic cell size, in pixels, for `Pixelate`. |
| `FillColor` | Black | Fill color for `SolidFill`. |
| `RegionPaddingPercent` | `0.15` | Expands each detected box per side (0.15 = 15%) to cover motion between detection cycles. |
| `RegionHoldTimeMs` | `700` | Keeps a region covered this long after the detector stops reporting it, so detector flicker never flashes PII through. |
| `FramesToSkip` | `0` | Frames to skip between detections on live video (`0` submits every frame). Detection always runs on a background worker. |
| `Provider` / `DeviceId` | `Auto` / `0` | ONNX execution provider and hardware device index. |

Each category exposes its own detector tuning.

Faces (`PIIFaceRedactionSettings`):

| Property | Default |
| --- | --- |
| `Enabled` | `true` |
| `ModelPath` | — |
| `DetectionInputSize` | `320` |
| `ConfidenceThreshold` | `0.5` |
| `NmsThreshold` | `0.3` |
| `MaxFaces` | `50` |

License plates (`PIIPlateRedactionSettings`):

| Property | Default |
| --- | --- |
| `Enabled` | `true` |
| `ModelPath` | — |
| `DetectionInputSize` | `640` |
| `ConfidenceThreshold` | `0.3` |
| `MaxDetections` | `20` |

`Text` (`PIITextRedactionSettings`): `Enabled` (`true`), `DetectionModelPath`, `RecognitionModelPath`, `CharacterDictionaryPath`, optional `ClassificationModelPath`, `TextFilterRegex` (see below), `MaxSideLength` (`1024`), `BoxThreshold` (`0.3`), `BoxScoreThreshold` (`0.5`), `UnclipRatio` (`1.6`).

The block also exposes read-only diagnostics after it is built: `ActiveProvider` (the execution provider that actually engaged), `LastInferenceTimeMs` (wall-clock of the most recent detection cycle), and `DroppedFrameCount` (frames that arrived while the detector was busy — still redacted, just not re-detected).

## Redact only specific text

By default every recognized text region is redacted. Set `Text.TextFilterRegex` to redact only the regions whose recognized text matches a pattern — for example, blur e-mail addresses and phone numbers while leaving signage and captions visible:

```
settings.Text.TextFilterRegex =
    @"(\b[\w.%+-]+@[\w.-]+\.[A-Za-z]{2,}\b)|(\+?\d[\d\s().-]{7,}\d)";
```

Recognition still runs regardless (it is what filters non-text detections); the regex only narrows which recognized regions are covered.

## Getting the models

The SDK does not bundle model weights. Supply your own `.onnx` files, or reuse the ones the demos download on first run from the samples release into `%UserProfile%/VisioForge/models`:

| File | Category | License |
| --- | --- | --- |
| `face_detection_yunet_2023mar.onnx` | Faces | MIT |
| `yolo-v9-t-640-license-plates-end2end.onnx` | License plates | MIT |
| `ch_PP-OCRv5_mobile_det.onnx` | Text (detection) | Apache-2.0 |
| `latin_PP-OCRv5_rec_mobile_infer.onnx` | Text (recognition) | Apache-2.0 |
| `ppocrv5_latin_dict.txt` | Text (dictionary) | Apache-2.0 |

These are downloaded from the `onnx-models-v1` release on the [samples repository](https://github.com/visioforge/.Net-SDK-s-samples/releases/tag/onnx-models-v1). To read the provider that ONNX Runtime actually selected, check `redaction.ActiveProvider` after the pipeline starts.

## Use with VideoCaptureCoreX and MediaPlayerCoreX

`PIIRedactionBlock` is a video processing block, so it plugs directly into the capture and playback engines — no manual `MediaBlocksPipeline` required. Add it before you start:

```
var redaction = new PIIRedactionBlock(settings);
redaction.OnRegionsRedacted += Redaction_OnRegionsRedacted;

core.Video_Processing_AddBlock(redaction);       // VideoCaptureCoreX — before StartAsync
// player.Video_Processing_AddBlock(redaction);  // MediaPlayerCoreX — before OpenAsync/PlayAsync

await core.StartAsync();
```

With VideoCaptureCoreX this anonymizes a webcam, IP camera, or capture-card feed as it is previewed, recorded, or streamed. See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the shared processing-block API, insertion order, and lifecycle rules.

## Privacy and compliance

Because every detector runs locally on ONNX Runtime, video and audio frames never leave the device, which simplifies GDPR / CCPA / BIPA reviews for camera applications. Redaction is destructive — pixels in each region are overwritten in the frame, so there is no reversible mapping to recover the original. The `OnRegionsRedacted` event carries only categories and boxes; the recognized content of a region (a plate number, a text string) is intentionally never included.

One caveat matters for live pipelines: detection runs on a background worker to keep the stream flowing, so **frames that arrive before the first detection cycle completes pass through unredacted**, and if the source resolution jumps mid-stream (for example adaptive HLS/RTSP), a newly exposed area can briefly leak until the next detection cycle. For **zero-leak** anonymization, process the file offline at reduced speed rather than live, so every frame is detected before it is written.

## Use cases

- **Dashcam / bodycam footage** — blur bystander faces and plates before publishing or sharing an incident clip.
- **CCTV and surveillance exports** — anonymize recorded video before handing it to a third party.
- **Video conferencing and screen sharing** — pixelate on-screen text (documents, badges) in a shared feed.
- **FOIA / court / insurance disclosure** — redact identities in released video to satisfy privacy rules.
- **User-generated content** — automatically obscure faces and plates in uploaded videos.
- **Street-level mapping and analytics** — anonymize faces and plates in captured drive footage.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| First frames show PII before redaction kicks in | Detection is asynchronous; frames before the first cycle pass through | Expected on live sources. For zero-leak, process files offline at reduced speed. |
| Too much of the frame is blurred (text) | Detector false positives, or every text region is being redacted | Raise `Text.BoxScoreThreshold`; set `Text.TextFilterRegex` to redact only the patterns you care about. |
| A face or plate is missed | `ConfidenceThreshold` too high, or the object is too small for `DetectionInputSize` | Lower the category's `ConfidenceThreshold`; raise `DetectionInputSize` for small/distant objects. |
| A region flickers in and out | Detection cadence too sparse or hold time too short | Lower `FramesToSkip`; raise `RegionHoldTimeMs`; raise `RegionPaddingPercent` for fast motion. |
| Runs on CPU when a GPU is present | Requested provider unavailable in the loaded ONNX Runtime build | Check `redaction.ActiveProvider`; install the matching ONNX Runtime GPU package; set `Provider`/`DeviceId`. |
| Live video stutters | Detection too slow for the frame rate on this hardware | Raise `FramesToSkip`; watch `LastInferenceTimeMs` and `DroppedFrameCount` while tuning. |

## Frequently Asked Questions

### Does PIIRedactionBlock identify people or read license plates?

No. The block never runs face recognition and never outputs a license plate's characters — faces and plates are located by detection alone. On-screen text is recognized internally only to decide what to redact (and to apply `TextFilterRegex`), and that recognized text is never emitted: the `OnRegionsRedacted` event carries only categories and boxes.

### Is this GDPR / CCPA / BIPA compliant?

Inference runs entirely on-device, so frames never leave the machine — which is the hard part for camera and microphone privacy reviews. For guaranteed zero-leak output, process files offline at reduced speed so every frame is detected before it is written; on live streams the first frames before the first detection cycle can pass through unredacted. Compliance also depends on your overall data handling — review the applicable regulations for your jurisdiction.

### Which models do I need, and where do I get them?

Faces need one YuNet model; license plates need one FastALPR model; on-screen text needs a PaddleOCR detection model, a recognition model, and a character dictionary. Weights are not shipped in the NuGet package — see [Getting the models](#getting-the-models).

### Can I redact only e-mail addresses and phone numbers, not all text?

Yes. Set `Text.TextFilterRegex` to a pattern; only regions whose recognized text matches are redacted, and all other on-screen text stays visible.

### Can I turn a category on or off while the video is running?

You can toggle a category off (and back on) live **if it was enabled when the block was built** — the detector for a category is created only when that category is enabled at build time. To add a category that was disabled at start, rebuild the block. Style, blur radius, and fill color are all live-adjustable.

### Can I run redaction on the GPU?

Yes. Set `Provider` to `CUDA`, `DirectML`, or `CoreML` (or leave it `Auto`), with `DeviceId` for the GPU index. If the requested provider is unavailable, ONNX Runtime falls back to CPU; check `ActiveProvider` to confirm what engaged.

### Is the redaction reversible?

No. Redaction overwrites the pixels in each region directly in the frame, so the original content cannot be recovered from the output.

## Demos

- **[PII Redaction Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/PII%20Redaction%20Demo)** — WPF Media Blocks pipeline demo (webcam, file, or RTSP source).
- **[Player PII Redaction X](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK%20X/WPF/Player%20PII%20Redaction%20X%20WPF)** — MediaPlayerCoreX redaction on file playback (WPF).
- **[Capture PII Redaction X](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WPF/CSharp/Capture%20PII%20Redaction%20X%20WPF)** — VideoCaptureCoreX redaction on a live camera (WPF).

---END OF PAGE---


## PTZ Auto-Tracking SDK for .NET — ONVIF Camera Control
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/ptz-auto-tracking/
**Description:** PTZ auto-tracking for .NET: make an ONVIF PTZ camera follow a detected object with proportional pan/tilt/zoom, a dead zone, and sticky tracking.
**Tags:** .NET, AI, ONVIF, PTZ, Auto-Tracking, Object Tracking, ObjectAnalyticsBlock, VideoCaptureCoreX, MediaBlocksPipeline
**API:** PTZAutoTrackingController, PTZAutoTrackingSettings, PTZTargetSelection, IPTZMoveTransport, OnvifPTZMoveTransport, PTZMoveCommandEventArgs

# PTZ Auto-Tracking — Follow a Detected Object with an ONVIF Camera

`PTZAutoTrackingController` turns object detections into continuous PTZ velocity commands, so an ONVIF PTZ camera automatically follows a tracked object. It plugs into the detections raised by [`ObjectAnalyticsBlock`](../object-analytics/) (multi-object tracking, stable tracker IDs) or the [`YOLOObjectDetectorBlock`](../object-detection/), and drives the camera over ONVIF through `OnvifPTZMoveTransport`.

The control law is a simple proportional (P) controller: the error is the target box center relative to the frame center; inside a configurable dead zone the camera holds, and outside it the camera pans/tilts (and optionally zooms) at a speed proportional to how far off-center the target is.

```
graph LR;
    Camera[ONVIF camera]-->Source[RTSP source];
    Source-->ObjectAnalyticsBlock;
    ObjectAnalyticsBlock-. OnAnalyticsUpdated .->Controller[PTZAutoTrackingController];
    Controller-. ContinuousMove/Stop .->Transport[OnvifPTZMoveTransport];
    Transport-->Camera;
```

## Requirements

- An **ONVIF PTZ camera** (the device must advertise the PTZ service — verify with `OnvifPTZMoveTransport.IsPTZSupportedAsync(onvif)`, which falls back to a media-profile `PTZConfiguration` probe when the camera's ONVIF service cache is empty). A fixed camera cannot be driven.
- An ONNX object-detection model (YOLOv8 / YOLOX / RT-DETR) for the detector.

## Usage

```
using System.Drawing;
using VisioForge.Core;
using VisioForge.Core.AI.PTZ;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.ONVIFX;
using VisioForge.Core.Types.X.AI;

// 0. Initialize the SDK once, before creating any engine object.
await VisioForgeX.InitSDKAsync();

// 1. Connect to the ONVIF camera and build the PTZ transport.
var onvif = new ONVIFClientX();
if (!await onvif.ConnectAsync("http://192.168.1.22/onvif/device_service", "admin", "password"))
{
    // Connection failed — check the address/credentials before proceeding.
    return;
}

if (!await OnvifPTZMoveTransport.IsPTZSupportedAsync(onvif))
{
    // The camera has no PTZ service — auto-tracking is not possible.
    return;
}

var transport = await OnvifPTZMoveTransport.CreateAsync(onvif); // resolves a PTZ-capable media profile
if (transport == null)
{
    // No usable media profile on the device — auto-tracking is not possible.
    return;
}

// 2. Configure the detector + analytics (ObjectAnalyticsBlock gives stable tracker IDs).
var detector = new YoloDetectorSettings("yolox_nano.onnx")
{
    Model = ObjectDetectorModel.YOLOX,
    ConfidenceThreshold = 0.4f,
};
var analyticsBlock = new ObjectAnalyticsBlock(new ObjectAnalyticsSettings(detector));

// 3. Create the controller and attach it to the analytics block.
// The frame size is the source (camera) resolution the detection boxes are expressed in.
var settings = new PTZAutoTrackingSettings
{
    TargetSelection = PTZTargetSelection.ByClassLabel,
    ClassLabelFilter = "person",
    MaxSpeed = 0.5f,
    Gain = 1.2f,
    DeadZone = 0.1f,
};

var controller = new PTZAutoTrackingController(settings, transport);
controller.OnTargetAcquired += (s, det) => Console.WriteLine($"Following {det.Label} #{det.TrackerId}");
controller.OnTargetLost += (s, e) => Console.WriteLine("Target lost.");
controller.OnMoveCommand += (s, cmd) =>
    Console.WriteLine(cmd.IsStop ? "PTZ: stop" : $"PTZ: pan={cmd.Pan} tilt={cmd.Tilt} zoom={cmd.Zoom}");

controller.AttachTo(analyticsBlock, new Size(1920, 1080));
controller.Start();

// 4. The analytics block only takes effect once it is added to your capture engine. Insert it into your
//    configured VideoCaptureCoreX (a MediaBlocksPipeline works the same way) and start streaming.
core.Video_Processing_AddBlock(analyticsBlock);
await core.StartAsync();

// On shutdown: stop the controller (halts the camera), then dispose.
await controller.StopAsync();
controller.Dispose();
```

`AttachTo` also has an overload for `YOLOObjectDetectorBlock`. Because a plain detector carries no tracker IDs, sticky tracking is only available with `ObjectAnalyticsBlock`; with a plain detector the controller reacquires a target every frame per the selection policy.

### Using it in a Media Blocks pipeline

The controller is engine-agnostic: `AttachTo` subscribes to the analytics block's detection event, which fires the same way whether the block runs inside `VideoCaptureCoreX` or a hand-built `MediaBlocksPipeline`. To wire it into a pipeline, connect the analytics block between your source and renderer and attach the controller to it exactly as above:

```
using System.Drawing;
using VisioForge.Core.AI.PTZ;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.X.AI;
using VisioForge.Core.Types.X.Sources;

var pipeline = new MediaBlocksPipeline();

var source = new RTSPSourceBlock(
    await RTSPSourceSettings.CreateAsync(new Uri("rtsp://192.168.1.22/..."), "admin", "password", audioEnabled: false));

// Detector + analytics block (same configuration as the Usage example above).
var analyticsBlock = new ObjectAnalyticsBlock(
    new ObjectAnalyticsSettings(new YoloDetectorSettings("yolox_nano.onnx")));

var renderer = new VideoRendererBlock(pipeline, VideoView1) { IsSync = false }; // VideoView1 = your WPF VideoView

// source -> analytics (detection + tracking) -> renderer
pipeline.Connect(source.VideoOutput, analyticsBlock.Input);
pipeline.Connect(analyticsBlock.Output, renderer.Input);

// The controller attaches to the same analytics block and drives the camera as a side-car.
// (transport is the OnvifPTZMoveTransport built in the Usage example above.)
var controller = new PTZAutoTrackingController(new PTZAutoTrackingSettings(), transport);
controller.AttachTo(analyticsBlock, new Size(1920, 1080));
controller.Start();

await pipeline.StartAsync();
```

## How the control law works

For each processed frame the controller:

1. **Selects a target** per `TargetSelection` (see below). Once a target with a valid tracker ID is locked, it stays sticky on that ID and ignores other objects.
2. **Computes the error**: the target box center minus the frame center, normalized to `[-1, 1]` on each axis.
3. **Applies the dead zone**: if an axis error is within `DeadZone`, that axis is not driven.
4. **Computes the speed**: `clamp(Gain * error, -MaxSpeed, MaxSpeed)` per axis. Positive pan is right, positive tilt is up.
5. **Drives zoom** (when `ZoomEnabled`): zooms in when the target box height is below `TargetBoxHeightRatio` and out when it is above.
6. **Rate limits**: at most one move command per `CommandInterval`; a single stop is emitted (no spam) when the camera enters the dead zone or the target disappears.

If the target is absent, the camera is stopped immediately. If it stays absent for longer than `LostTargetTimeout`, `OnTargetLost` fires, the camera optionally returns to `HomePresetToken`, and the next matching detection reacquires a target.

Camera commands are actuated on a dedicated background worker, so the detection thread is never blocked by network I/O.

## Target selection modes

| `PTZTargetSelection` | Behavior |
| --- | --- |
| `Largest` | Follow the object with the largest bounding-box area (default). |
| `FirstDetected` | Follow the first object in the detection array. |
| `ByTrackerId` | Follow only the object whose tracker ID equals `ManualTrackerId`. |
| `ByClassLabel` | Follow the largest object whose label matches `ClassLabelFilter` (case-insensitive). |

## Settings

| Property | Default | Description |
| --- | --- | --- |
| `TargetSelection` | `Largest` | Strategy used to pick a target when none is locked. |
| `ClassLabelFilter` | `null` | Label to follow for `ByClassLabel` (e.g. `"person"`). |
| `ManualTrackerId` | `-1` | Tracker ID to follow for `ByTrackerId`. |
| `DeadZone` | `0.1` | Centered dead-zone half-width, as a fraction of the frame half-size (0..1). |
| `MaxSpeed` | `0.5` | Maximum absolute speed on any axis (0..1). |
| `Gain` | `1.2` | Proportional gain applied to the normalized error. |
| `ZoomEnabled` | `false` | Drive zoom to keep the target height near `TargetBoxHeightRatio`. |
| `TargetBoxHeightRatio` | `0.5` | Desired target box height as a fraction of the frame height (0..1). |
| `ZoomDeadZone` | `0.05` | Zoom dead zone on the height-ratio difference (0..1). |
| `LostTargetTimeout` | `2 s` | How long the target may be absent before it is declared lost. |
| `HomePresetToken` | `null` | Optional ONVIF preset to return to when the target is lost. |
| `CommandInterval` | `200 ms` | Minimum interval between move commands (stops are not rate limited). |
| `PatrolPresetTokens` | `null` | Ordered ONVIF preset tokens to cycle as an idle patrol. Patrol is enabled only when this is non-empty. |
| `PatrolStartDelay` | `30 s` | How long to wait after the target is lost, with none reappearing, before starting the patrol. |
| `PatrolDwellTime` | `10 s` | How long to dwell at each patrol preset before advancing to the next. |

## Idle patrol

When the camera would otherwise sit idle, it can automatically cycle through a set of ONVIF presets until a new target appears. Set `PatrolPresetTokens` to the ordered preset tokens you want to visit (patrol is enabled only when this array is non-empty):

```
var settings = new PTZAutoTrackingSettings
{
    TargetSelection = PTZTargetSelection.ByClassLabel,
    ClassLabelFilter = "person",
    HomePresetToken = "1",                              // return home first when the target is lost
    PatrolPresetTokens = new[] { "1", "2", "3" },       // then patrol these presets in order
    PatrolStartDelay = TimeSpan.FromSeconds(30),        // ... after 30 s with no new target
    PatrolDwellTime = TimeSpan.FromSeconds(10),         // dwell 10 s at each preset
};

controller.OnPatrolPreset += (s, token) => Console.WriteLine($"Patrol: preset {token}");
```

Sequence of events once the target disappears:

1. The camera stops immediately, and after `LostTargetTimeout` the target is declared lost (`OnTargetLost`) and — if `HomePresetToken` is set — the camera returns home.
2. If no new target reappears for `PatrolStartDelay`, the patrol begins: the camera recalls each token in `PatrolPresetTokens` in order, dwelling `PatrolDwellTime` at each, wrapping around the list.
3. The moment a new target is acquired, the patrol is aborted immediately and normal tracking resumes. The next patrol restarts from the first preset.

Patrol timing is measured against the frame timestamps supplied to the controller, so it stays in step with the video clock. Get the preset tokens for your device with `ONVIFClientX.GetPresetsAsync`.

## Events

- `OnTargetAcquired(OnnxDetection)` — a new target was locked.
- `OnTargetLost()` — the current target was absent longer than `LostTargetTimeout`.
- `OnMoveCommand(PTZMoveCommandEventArgs)` — every command sent to the camera (`Pan`, `Tilt`, `Zoom`, `IsStop`); useful for a status bar or diagnostics.
- `OnPatrolPreset(string)` — the idle patrol moved to the given preset token.

## Custom transport

`OnvifPTZMoveTransport` is the built-in ONVIF implementation. To drive a non-ONVIF PTZ device, implement `IPTZMoveTransport` (`ContinuousMoveAsync`, `StopAsync`, `GoToPresetAsync`) and pass your implementation to the controller.

## Demo

Complete WPF samples are available in the SDK samples:

- **[PTZ Auto Tracking (Video Capture SDK X)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WPF/CSharp/PTZ%20Auto%20Tracking)** — auto-tracking with the `VideoCaptureCoreX` engine.
- **[PTZ Auto Tracking (Media Blocks SDK)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/PTZ%20Auto%20Tracking%20MB)** — the same feature built on a low-level `MediaBlocksPipeline`.

---END OF PAGE---


## Search Video by Text — Semantic Video Search for .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/semantic-video-search/
**Description:** Find any moment in recorded video by describing it in plain text. On-device semantic video search for .NET with CLIP embeddings — no tags, no cloud.
**Tags:** .NET, AI, ONNX, CLIP, Semantic Search, Video Search, Embeddings, Vector Search, MediaPlayerCoreX, Media Blocks
**API:** VideoEmbeddingBlock, VideoEmbeddingSettings, FrameEmbeddingIndex, ClipEmbeddingEngine, FrameEmbeddingSearchResult

# Semantic Video Search — VideoEmbeddingBlock

You have hours of recorded video and need to jump to one moment — *"someone entering the lobby"*, *"a red truck at the gate"* — without scrubbing through the footage or tagging it first. **Semantic video search** solves this: index the video once, then find matching moments by describing them in plain text. It runs on-device with OpenAI's CLIP model — no manual metadata, no cloud service, no per-object detector to train.

`VideoEmbeddingBlock` turns video frames into **CLIP embeddings** so you can search a video by meaning: index a file once, then find the moments that match a natural-language query like `"a person riding a bicycle"` — no fixed labels, no per-object detector. It samples frames at a configurable interval, encodes each with the CLIP vision tower, raises `OnFrameEmbedding`, and (when an index is attached) stores each embedding with its timestamp. Search embeds the query text with the same CLIP text tower and ranks frames by similarity.

This feature has two halves:

- **Indexing** — run `VideoEmbeddingBlock` over a file (or live source) to fill a `FrameEmbeddingIndex` with one embedding per sampled frame.
- **Search** — embed a text query (`ClipEmbeddingEngine.EncodeText` or `VideoEmbeddingBlock.EncodeText`) and call `FrameEmbeddingIndex.Search` to get the best-matching timestamps.

```
graph LR;
    Source-->VideoEmbeddingBlock;
    VideoEmbeddingBlock-->NullRendererBlock;
    VideoEmbeddingBlock-. OnFrameEmbedding .->Index[(FrameEmbeddingIndex)];
    Query["Text query"]-. EncodeText .->Search{{Search}};
    Index-->Search;
    Search-->Results["Ranked timestamps"];
```

Because indexing only needs the embeddings, the video is decoded at full speed to a non-synced sink (no real-time playback) — see [Fast offline indexing](#fast-offline-indexing-on-mediaplayercorex).

## How semantic video search works

Semantic search matches by **meaning**, not keywords or metadata — so "someone riding a bike" finds cyclists in footage that was never tagged. It works because CLIP has two encoders that map images and text into one shared vector space:

1. **Index the frames.** The CLIP vision tower encodes each sampled frame into an embedding (a fixed-length vector, ~512 numbers) stored with its timestamp in a `FrameEmbeddingIndex`.
2. **Embed the query.** The CLIP text tower encodes your query string into an embedding in the *same* space, so images and text are directly comparable.
3. **Rank by similarity.** Cosine similarity scores every indexed frame against the query; the highest scores are the best-matching moments.
4. **Sharpen with a contrastive margin.** Generic frames score moderately against almost any query, so the demos subtract each frame's best generic-baseline score — see [Contrastive margin](#contrastive-margin-recommended-ranking).

### Key concepts

| Term | Meaning |
| --- | --- |
| **Embedding** | A fixed-length vector that captures the meaning of a frame or a phrase. |
| **Shared embedding space** | CLIP maps images and text into the same space, so a text vector can be compared to an image vector directly. |
| **Cosine similarity** | An angle-based similarity between two vectors; higher means closer in meaning. |
| **Contrastive margin** | The query score minus the best generic-baseline score for a frame — removes a scene-independent bias in raw cosine and makes true matches stand out. |

## Build a video search feature

Turning the two halves into a working "search my footage" feature is four steps — each maps to a section below, so this is the recipe, not new code:

1. **Get the CLIP model** — the vision tower, text tower, and tokenizer files. See [Model](#model).
2. **Index the video** into a `FrameEmbeddingIndex`, decoding at full speed so a long file indexes in a fraction of its runtime. See [Indexing](#indexing) and [Fast offline indexing on MediaPlayerCoreX](#fast-offline-indexing-on-mediaplayercorex).
3. **Persist the index** to a `.vfei` file so you index once and search across sessions. See [Persisting the index](#persisting-the-index).
4. **Search by text** — embed the user's query and rank the index, ideally with the [contrastive margin](#contrastive-margin-recommended-ranking). See [Search](#search). Use each hit's `Timestamp` to seek the player or render a thumbnail.

A typical application indexes new videos in the background as they arrive, keeps one `.vfei` per video (or a shared index tagged by `SourceTag`), and runs search interactively against the loaded index.

## Indexing

Attach a `FrameEmbeddingIndex` to the settings and the block adds every sampled frame to it automatically. `SourceTag` records which file the frame came from (used later for thumbnails and result grouping).

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X;
using VisioForge.Core.Types.X.AI;

var index = new FrameEmbeddingIndex();

var settings = new VideoEmbeddingSettings(
    "clip-vitb32-vision.onnx",
    "clip-vitb32-text.onnx",
    "clip-vocab.json",
    "clip-merges.txt")
{
    Index = index,
    SourceTag = filePath,
    SampleInterval = TimeSpan.FromSeconds(1),   // one embedding per second of video
    BackpressureNoDrop = true,                  // capture every sampled frame (offline file indexing)
    Provider = OnnxExecutionProvider.Auto,
};

var embedding = new VideoEmbeddingBlock(settings);

var indexSource = new UniversalSourceBlock(
    await UniversalSourceSettings.CreateAsync(filePath, renderVideo: true, renderAudio: false));
var nullRenderer = new NullRendererBlock(MediaBlockPadMediaType.Video) { IsSync = false };

pipeline.Connect(indexSource.Output, embedding.Input);
pipeline.Connect(embedding.Output, nullRenderer.Input);

pipeline.OnStop += (s, e) => Console.WriteLine($"Indexed {index.Count} frames.");
await pipeline.StartAsync();
```

`OnFrameEmbedding` raises a `FrameEmbeddingEventArgs { Timestamp, Embedding }` per sampled frame (the `Embedding` is L2-normalized). You usually don't need the event when an `Index` is attached — it is useful for a live progress counter or to store embeddings yourself.

Live sources drop instead of backpressuring

Set `BackpressureNoDrop = true` only for offline file indexing, where blocking the decoder to capture every interval is the goal. For a **live camera**, leave it `false` — a camera cannot be backpressured without stalling capture, so a sampled frame is dropped when the encoder is busy.

## Search

Embed the query text in the same space and rank the index by cosine similarity:

```
using VisioForge.Core.AI.Clip;

using var engine = new ClipEmbeddingEngine(settings);
engine.Init();

float[] queryVector = engine.EncodeText("a person riding a bicycle");
FrameEmbeddingSearchResult[] hits = index.Search(queryVector, topK: 10);

foreach (var hit in hits)
    Console.WriteLine($"{hit.Timestamp:hh\\:mm\\:ss}  score {hit.Score:F3}  ({hit.SourceTag})");
```

Each `FrameEmbeddingSearchResult` has `Timestamp`, `SourceTag`, and `Score` (cosine similarity, roughly −1..1, higher is more similar). You can also call `VideoEmbeddingBlock.EncodeText` on a built block to embed a query with the same session — but a standalone `ClipEmbeddingEngine` lets you search after the indexing pipeline has stopped and been disposed.

### Contrastive margin (recommended ranking)

Raw cosine similarity has a scene-independent bias: generic frames score moderately against almost any query. The demos rank by a **contrastive margin** instead — the query score minus the best score from a set of generic baseline prompts — which sharply separates true matches from background frames:

```
static readonly string[] BaselinePrompts =
{
    "a photo", "a picture", "an image", "a screenshot", "a random background",
};

float[] queryVec = engine.EncodeText(query);
var queryHits = index.Search(queryVec, index.Count);

// Best baseline cosine per frame.
var baseline = new Dictionary<(string, TimeSpan), float>();
foreach (var neg in BaselinePrompts)
    foreach (var h in index.Search(engine.EncodeText(neg), index.Count))
    {
        var key = (h.SourceTag, h.Timestamp);
        if (!baseline.TryGetValue(key, out var cur) || h.Score > cur) baseline[key] = h.Score;
    }

var ranked = queryHits
    .Select(h => { baseline.TryGetValue((h.SourceTag, h.Timestamp), out var nb); return (hit: h, margin: h.Score - nb); })
    .Where(r => r.margin >= minMargin)     // minMargin is a UI threshold
    .OrderByDescending(r => r.margin)
    .Take(24);
```

### Persisting the index

`FrameEmbeddingIndex` saves and loads to a compact binary `.vfei` file, so you index once and search across sessions:

```
index.Save("frames.vfei");
// later, or in another process:
var loaded = new FrameEmbeddingIndex();
loaded.Load("frames.vfei");
index.Clear(); // empty the index and reset its dimension
```

## Key settings

`VideoEmbeddingSettings` is a standalone settings class.

| Property | Default | Description |
| --- | --- | --- |
| `ImageEncoderPath` | `null` | CLIP vision-tower ONNX (with projection head). Required for indexing. |
| `TextEncoderPath` | `null` | CLIP text-tower ONNX (with projection head). Required for `EncodeText`. |
| `VocabFilePath` / `MergesFilePath` | `null` | CLIP tokenizer files. Required for `EncodeText`. |
| `SampleInterval` | `1 second` | Minimum time between two encoded frames. |
| `Index` | `null` | The `FrameEmbeddingIndex` each sampled embedding is auto-added to. When `null`, frames are only raised via `OnFrameEmbedding`. |
| `SourceTag` | `null` | Source identifier stored with every indexed frame (file name or camera id). |
| `BackpressureNoDrop` | `false` | `true` blocks the decoder to capture every interval (offline file indexing); `false` drops when the encoder is busy (live sources). |
| `Provider` / `DeviceId` | `Auto` / `0` | ONNX execution provider and hardware device index. |

`VideoEmbeddingBlock.ActiveProvider` reports the engaged provider, `Dimension` the CLIP embedding size (typically 512), and `LastInferenceTimeMs` the per-frame encode cost.

## Index size and choosing SampleInterval

`SampleInterval` decides how many frames you embed, which drives both index size and indexing time. Each stored frame is roughly the embedding vector (~512 floats × 4 bytes ≈ 2 KB) plus its timestamp and source tag — so the math is predictable:

| Content | `SampleInterval` | Frames per hour | Approx. index size / hour |
| --- | --- | --- | --- |
| Static or slow footage | 2 s | 1,800 | ~3.5 MB |
| General footage (default) | 1 s | 3,600 | ~7 MB |
| Fast cuts / brief moments | 0.5 s | 7,200 | ~14 MB |

Pick the interval by how short the moments you need to find are: 1 second catches most scenes; use 0.5 second or finer for rapid cuts, and a coarser interval for long, static recordings to keep the index small and indexing fast. The index is in-memory during a session and persisted to a compact `.vfei` file with `Save`, so size mostly matters for very long libraries.

## Model

Indexing and search use the OpenAI **CLIP ViT-B/32** dual-tower model — a vision tower and a text tower that map images and text into the same embedding space. Both include the projection head, so their outputs share the same dimension and can be compared directly by cosine similarity. Model weights are not bundled with the SDK; the demos download them on first run and cache them under `%USERPROFILE%\VisioForge\models\clip`:

| Role | File |
| --- | --- |
| Vision tower | `clip-vitb32-vision.onnx` |
| Text tower | `clip-vitb32-text.onnx` |
| Tokenizer | `clip-vocab.json`, `clip-merges.txt` |

A model's license is set by its origin, independent of the SDK's own license — confirm the license of the weights you deploy.

## Fast offline indexing on MediaPlayerCoreX

To index a file with `MediaPlayerCoreX`, register the block and turn off video-renderer clock sync so the file decodes **at full speed instead of real time**. Combined with `BackpressureNoDrop = true`, every sampled interval is captured with no dropped frames:

```
player.Video_Renderer_IsSync = false;   // decode at full speed, not real time — set BEFORE OpenAsync
player.Video_Play = true;
player.Audio_Play = false;

var source = await UniversalSourceSettings.CreateAsync(filePath, renderVideo: true, renderAudio: false);

var settings = new VideoEmbeddingSettings(visionPath, textPath, vocabPath, mergesPath)
{
    Index = index,
    SourceTag = filePath,
    SampleInterval = TimeSpan.FromSeconds(1),
    BackpressureNoDrop = true,
};

var embedding = new VideoEmbeddingBlock(settings);
embedding.OnFrameEmbedding += (s, e) => UpdateProgress(index.Count);
player.Video_Processing_AddBlock(embedding);   // before OpenAsync / PlayAsync

player.OnStop += (s, e) => FinalizeIndexing();  // end-of-file finalizes the index

await player.OpenAsync(source);
await player.PlayAsync();
```

`Video_Renderer_IsSync` is a nullable override on `MediaPlayerCoreX`: `null` (default) syncs to the clock for normal playback, `false` decodes as fast as possible for offline analysis, `true` forces real-time. When the file reaches EOS, `OnStop` fires; the engine has already torn down and disposed the inserted block by then, so finalize the index there. Search keeps working after the pipeline stops because it runs on a standalone `ClipEmbeddingEngine`, not the disposed block.

Indexing is Media Player / Media Blocks only

Semantic video search indexes a **file** (or Media Blocks source). There is no `VideoCaptureCoreX` capture variant — index recorded footage with `MediaPlayerCoreX` or a manual Media Blocks pipeline. (A live camera can still be embedded with `BackpressureNoDrop = false`, but the feature is designed around searching stored video.)

See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the shared processing-block API and lifecycle rules.

## Semantic search vs manual tagging and keyword search

Teams usually reach for one of three ways to make video findable. Semantic search wins when the moments you need aren't known in advance and the footage isn't already labeled.

| Approach | How you find a moment | Breaks down when |
| --- | --- | --- |
| **Manual tagging / metadata** | Someone labels clips or timestamps up front; you search the labels. | Nobody tagged what you're now looking for, or the library is too large to tag by hand. |
| **Keyword search** (file names, subtitles, ASR transcripts) | Match text you already have. | The thing you want isn't spoken or written down — it's *visual* ("a person in a red jacket"). |
| **Semantic search** (this feature) | Describe the moment in plain text; CLIP ranks frames by visual meaning. | You need exact object counts or bounding boxes — pair it with [object detection](../object-detection/) or a [VLM](../vlm-captioning/). |

The three are complementary, not exclusive: index once, then combine a text query with your existing filters (date, camera, tag) to narrow the results.

## Use cases

- **Search recorded footage by description** — jump to "a person entering the lobby" across hours of video without watching it.
- **Media asset management** — build a searchable embedding index for a video library and query it with plain language.
- **Highlight and clip discovery** — find candidate moments matching a described scene for editing or review.
- **Deduplication and similarity** — compare frames or clips by embedding distance.
- **Pre-filtering for heavier AI** — locate candidate frames semantically, then run a detector or VLM only on those.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| Indexing runs at real-time speed | `Video_Renderer_IsSync` left at default (`null`) on `MediaPlayerCoreX`, or a synced renderer on Media Blocks | Set `player.Video_Renderer_IsSync = false` before `OpenAsync`, or use a `NullRendererBlock { IsSync = false }` on Media Blocks. |
| Some frames missing from the index | Encoder couldn't keep up and dropped frames | Set `BackpressureNoDrop = true` for offline file indexing. |
| Search returns weak or generic matches | Ranking by raw cosine | Use the [contrastive margin](#contrastive-margin-recommended-ranking) with baseline prompts. |
| `EncodeText` throws | Text tower or tokenizer files not provided | Set `TextEncoderPath`, `VocabFilePath`, and `MergesFilePath`. |
| `Search` returns empty | Empty index, or query/index dimension mismatch | Confirm indexing finished (`index.Count > 0`) and the same CLIP model is used for both. |
| Fewer results than expected | Sampling interval too coarse | Lower `SampleInterval` to embed more frames (at higher index and compute cost). |

## Frequently Asked Questions

### How do I find a specific scene in a long video?

Index the video once with `VideoEmbeddingBlock`, then call `FrameEmbeddingIndex.Search` with your scene described in plain text (for example `"a car pulling into the driveway"`). Each result carries a `Timestamp` you can seek to — so you jump straight to the scene instead of scrubbing. Ranking with the [contrastive margin](#contrastive-margin-recommended-ranking) makes the top hit much more reliable than raw similarity.

### Can I build a video search engine in .NET with this?

Yes — that's the intended use. Index your library into one or more `FrameEmbeddingIndex` files (`.vfei`), tag each frame with its `SourceTag`, and query the loaded index with text at run time. It's fully on-device (OpenAI CLIP via ONNX), so there is no cloud service or per-query cost. See [Build a video search feature](#build-a-video-search-feature) for the end-to-end recipe.

### How do I index faster than real time?

On `MediaPlayerCoreX`, set `Video_Renderer_IsSync = false` before `OpenAsync`; on a manual Media Blocks pipeline, send the block's output to a `NullRendererBlock { IsSync = false }`. Both decode the file as fast as the CPU/GPU allows. Keep `BackpressureNoDrop = true` so no sampled frame is dropped.

### Can I search a live camera?

The feature targets stored video. You can embed a live camera (`BackpressureNoDrop = false` so it doesn't stall), but there is no dedicated `VideoCaptureCoreX` search demo — indexing and search are built around files.

### How is the index stored?

`FrameEmbeddingIndex.Save` writes a compact binary `.vfei` file (magic `VFEI`, timestamps + source tags + float embeddings). `Load` restores it, so you can index once and search later or in another process.

### What does the contrastive margin do?

It subtracts each frame's best generic-baseline score from its query score, which removes a scene-independent bias in raw cosine similarity and makes true matches stand out. It's the ranking the demos use — see the [Search](#contrastive-margin-recommended-ranking) section.

### Do I need a GPU?

No. `Provider` defaults to `Auto` and runs on CPU when no GPU is present. A GPU provider speeds up per-frame encoding, which matters most when indexing long files at a fine `SampleInterval`.

### Can I search across multiple videos at once?

Yes. Index several files into the same `FrameEmbeddingIndex` (give each its own `SourceTag`), then one `Search` ranks frames across all of them — each `FrameEmbeddingSearchResult` reports the `SourceTag` so you know which file (and timestamp) a hit came from.

### How is this different from object detection or a VLM?

Object detection and VLMs answer "what is in this frame" (boxes, labels, captions). Semantic search answers "which frames match this description" by ranking whole frames against a text query. It finds moments; it does not draw boxes. Use it to locate candidate frames, then run a detector or [`VLMBlock`](../vlm-captioning/) on them if you need per-object detail.

### Is this keyword search over video metadata?

No. It compares the *meaning* of frames and your query in CLIP's embedding space, so it works with no tags, filenames, or transcripts — "a person in a red jacket" matches on appearance, not on text metadata that may not exist.

### Does the index work in another process or session?

Yes. `Save` writes a `.vfei` file and `Load` restores it, so you can index once and search later, in a different run, or ship a prebuilt index with your application.

### Do I have to keep the video to search it?

No — once frames are indexed, search runs entirely on the `FrameEmbeddingIndex` and the CLIP text tower. You need the original file again only to show thumbnails or to seek to a matching timestamp.

## Demos

Dedicated demos built on Media Blocks and `MediaPlayerCoreX` (`Semantic Video Search Demo`, `Semantic Video Search MB`, `Player Semantic Video Search X`, `Player Semantic Video Search X WPF`) are in the SDK's demo set and will be linked here once published to the public samples repository.

---END OF PAGE---


## Speaker Diarization SDK for .NET — SpeakerDiarizationBlock
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/speaker-diarization/
**Description:** On-device speaker diarization for .NET — find
**Tags:** .NET, AI, Speaker Diarization, Diarization SDK, Who Spoke When, Speaker Segmentation, Speaker Embedding, VideoCaptureCoreX, MediaPlayerCoreX
**API:** SpeakerDiarizationBlock, SpeakerDiarizationSettings, SpeakerSegment, SpeakerSegmentEventArgs, DiarizedTranscriptBuilder, DiarizedTranscriptSegment

# Speaker Diarization — SpeakerDiarizationBlock

`SpeakerDiarizationBlock` is an audio-only Media Block that lives in the `VisioForge.Core.MediaBlocks.AI` namespace (assembly `VisioForge.Core.AI`, NuGet package `VisioForge.DotNet.Core.AI`). It answers "who spoke when": it taps the audio stream, finds speech turns with a pyannote segmentation ONNX model, turns each turn into a voiceprint with a WeSpeaker/3D-Speaker embedding ONNX model, and — once the recording has finished — groups the voiceprints into speakers and publishes the timeline. Audio passes through the block: the tap forces a 32-bit float interleaved sample format, but the sample rate and channel count are left unchanged. The block implements `IAudioProcessingBlock`, so it can be inserted into a manual pipeline or registered directly on `VideoCaptureCoreX`/`MediaPlayerCoreX`.

The implementation follows the reference [sherpa-onnx](https://github.com/k2-fsa/sherpa-onnx) offline speaker-diarization pipeline, which uses these same two models.

```
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.Types.X.AI;
```

## Diarization is offline — the answer arrives at end-of-stream

**The block reports nothing while the audio is still playing.** This is not a limitation of the implementation, it is what the problem allows:

- The segmentation model separates the voices **inside one 10-second window** and numbers them locally. Window 5's "speaker 1" and window 6's "speaker 1" are unrelated — the model never claims otherwise.
- The only thing that can tie a voice heard at minute 1 to the same voice at minute 40 is **clustering every voiceprint of the recording together**, and that cannot be done until every voiceprint exists.

So the block analyses continuously as audio flows (that work is real, and it is why the answer appears almost immediately after the last sample), but it raises `OnSpeakerSegment` — once per turn, in start-time order — only after end-of-stream. **It suits files and finite streams.** An endless live source never reaches the moment at which an answer exists.

## Basic block setup

```
var settings = new SpeakerDiarizationSettings(segmentationModelPath, embeddingModelPath)
{
    Provider = OnnxExecutionProvider.CPU,
};

var diarization = new SpeakerDiarizationBlock(settings);

// Raised for every turn, in order, after the stream ends.
diarization.OnSpeakerSegment += (sender, e) =>
{
    var turn = e.Segment;
    Console.WriteLine($"speaker_{turn.SpeakerId:D2}: {turn.Start:c} - {turn.End:c} (conf {turn.Confidence:F2})");
};
```

The same timeline is available in one piece from `GetTimeline()`. Check `IsTimelineComplete` first — an empty timeline means "we never got to work out who spoke", not "nobody spoke":

```
if (!diarization.IsTimelineComplete)
{
    // The run never reached the clustering step: the pipeline was stopped before end-of-stream,
    // or the analysis worker faulted. The timeline is empty, and that emptiness is not an answer.
    Console.WriteLine("No diarization result — the recording was not heard to the end.");
    return;
}

Console.WriteLine($"{diarization.SpeakerCount} speaker(s).");

if (diarization.UnattributedTurns > 0)
{
    // Speech the models found but could not voiceprint: those turns carry no speaker id and
    // never reach the timeline, even though their audio WAS analysed.
    Console.WriteLine($"{diarization.UnattributedTurns} turn(s) could not be attributed to a speaker.");
}

foreach (var turn in diarization.GetTimeline())
{
    Console.WriteLine(turn); // speaker_00 [00:00:01.583 --> 00:00:03.405] (conf=0.98)
}
```

## Models — download at runtime

Two ONNX models are required, both downloaded at runtime (neither is shipped in the SDK NuGet packages). Both are exported by the [sherpa-onnx](https://github.com/k2-fsa/sherpa-onnx) project:

| Model | Role | License | Source |
| --- | --- | --- | --- |
| pyannote `segmentation-3.0` | Local speech-turn segmentation (10 s window, up to 3 local speakers, powerset activity) | MIT | Extract `model.onnx` from the [`sherpa-onnx-pyannote-segmentation-3-0.tar.bz2`](https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-segmentation-models/sherpa-onnx-pyannote-segmentation-3-0.tar.bz2) release asset. |
| WeSpeaker `voxceleb_resnet34_LM` (English, **default**) | Speaker embedding (80-bin fbank in, 256-d voiceprint out) | Apache-2.0 | [`wespeaker_en_voxceleb_resnet34_LM.onnx`](https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-recongition-models/wespeaker_en_voxceleb_resnet34_LM.onnx) release asset. |
| 3D-Speaker `eres2netv2_sv_zh-cn_16k-common` (**multilingual**) | Speaker embedding (80-bin fbank in, 192-d voiceprint out); much better speaker separation on non-English speech | Apache-2.0 | [`3dspeaker_speech_eres2netv2_sv_zh-cn_16k-common.onnx`](https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-recongition-models/3dspeaker_speech_eres2netv2_sv_zh-cn_16k-common.onnx) release asset. |

The segmentation model is **language-independent** — only the embedding model needs to match your language. The default `SegmentationModelUrl` / `EmbeddingModelUrl` on `SpeakerDiarizationSettings` point at the pyannote and WeSpeaker English release assets. They are informational — the SDK never downloads anything itself; the files actually loaded are `SegmentationModelPath` and `EmbeddingModelPath`. Any 80-bin-fbank WeSpeaker or 3D-Speaker embedding model with commercially usable weights can be substituted; the fbank feature front-end configures itself (sample scaling and feature normalization) from the model's ONNX metadata, so no manual tuning is needed when you swap it.

## Multilingual diarization

The default WeSpeaker embedding is trained on English (VoxCeleb) and under-detects speakers on other languages. For non-English or mixed-language content, use the Apache-2.0 **3D-Speaker ERes2NetV2** multilingual embedding model instead: point `EmbeddingModelPath` at its ONNX file and set `EmbeddingModel = SpeakerEmbeddingModel.ERes2NetV2Multilingual`. The segmentation model is unchanged.

```
var settings = new SpeakerDiarizationSettings(segmentationModelPath, eres2netv2ModelPath)
{
    EmbeddingModel = SpeakerEmbeddingModel.ERes2NetV2Multilingual,

    // Retune the threshold for this embedding — see below. The default (0.5) over-splits it.
    ClusterThreshold = 0.8f,
    Provider = OnnxExecutionProvider.CPU,
};

var diarization = new SpeakerDiarizationBlock(settings);
```

Retune `ClusterThreshold` when you switch embedding models

Each embedding model has its own cosine geometry, and the default `ClusterThreshold` of `0.5` is the right distance for **WeSpeaker**. The ERes2NetV2 voiceprints are spread further apart, so that same distance splits one speaker into several — on a four-speaker reference clip it yields six. A value around **`0.8`** is the starting point for ERes2NetV2. If you know the speaker count, setting `NumSpeakers` sidesteps the question entirely.

`EmbeddingModel` is a declarative hint: it selects the recommended download URL, while the file actually loaded is always `EmbeddingModelPath`. Because the front-end reads its feature configuration from the model's ONNX metadata, switching between the two models needs no other code change.

Download URLs are also exposed as constants: `SpeakerDiarizationSettings.WeSpeakerEnglishModelUrl` and `SpeakerDiarizationSettings.ERes2NetV2MultilingualModelUrl`.

## Key settings

`SpeakerDiarizationSettings(segmentationModelPath, embeddingModelPath)`. Unlike the vision AI settings, this type does **not** derive from `OnnxInferenceSettings` — those describe video-frame preprocessing, which does not apply to an audio model pair.

The defaults are the reference implementation's own and are a sound starting point for arbitrary content.

| Property | Default | Description |
| --- | --- | --- |
| `SegmentationModelPath` | — | Absolute path to the pyannote `segmentation-3.0` ONNX model. Required. |
| `EmbeddingModelPath` | — | Absolute path to the speaker-embedding ONNX model (for example WeSpeaker `voxceleb_resnet34_LM` or 3D-Speaker `eres2netv2`). Required. |
| `EmbeddingModel` | `WeSpeakerEnglish` | Which embedding model the settings are configured for (`WeSpeakerEnglish` or `ERes2NetV2Multilingual`). A declarative hint that picks the default URL; the file loaded is always `EmbeddingModelPath`, and feature extraction is auto-configured from its ONNX metadata. |
| `SegmentationModelUrl` | sherpa-onnx pyannote release | Informational download URL for the segmentation model. |
| `EmbeddingModelUrl` | sherpa-onnx WeSpeaker release | Informational download URL for the embedding model. |
| `NumSpeakers` | `-1` | The **exact** number of speakers, when you know it. A positive value pins the result to that many speakers and `ClusterThreshold` is ignored. `-1` means "work it out from the voices" — the right setting whenever the count is not certain. |
| `ClusterThreshold` | `0.5` | The cosine **DISTANCE** at which two voiceprints stop being the same person. Note the direction: this is a distance (0 = identical voices), **not** a similarity — a **smaller** value is stricter and yields **more** speakers. Ignored when `NumSpeakers` is positive. |
| `MinDurationOn` | `0.3` | The shortest turn, in seconds, that is reported. Shorter ones are dropped as noise. |
| `MinDurationOff` | `0.5` | The longest pause, in seconds, that still counts as the same turn. Two turns of one speaker closer than this are joined, so a speaker pausing for breath stays one turn. |
| `Provider` | `Auto` | Execution provider for both ONNX sessions. `Auto` uses the fastest provider in the loaded ONNX Runtime native build and falls back to CPU. |
| `DeviceId` | `0` | Hardware device id when a GPU provider is selected. |

## Speaker turns

Each `SpeakerSegment` (from `SpeakerSegmentEventArgs.Segment` and `GetTimeline()`):

| Property | Description |
| --- | --- |
| `SpeakerId` | Stable, zero-based speaker identifier for this run. |
| `Start` / `End` | `TimeSpan` on the media timeline. |
| `Duration` | `End - Start`. |
| `Confidence` | How strongly the overlapping analysis windows agreed on this speaker for this turn (0..1). `1` means every window that saw the moment named the same speaker. |

Speaker ids are stable **within a run**, not across separate pipeline runs (there is no cross-run speaker re-identification in this version).

## Diarized transcript — "who said what"

`DiarizedTranscriptBuilder` merges a speech-to-text transcript with the diarization timeline, labeling each transcript segment with the speaker who overlaps it the most (ties go to the lower speaker id). It is pure data processing — no model or media dependency — so it pairs a [`SpeechToTextBlock`](../speech-to-text/) with a `SpeakerDiarizationBlock`. Build it after end-of-stream, when the diarization timeline exists.

```
using VisioForge.Core.Types.X.AI;

// transcript: (start, end, text) tuples from SpeechToTextBlock.OnSpeechRecognized
// timeline: diarization.GetTimeline()
var labeled = DiarizedTranscriptBuilder.Build(transcript, timeline);
foreach (DiarizedTranscriptSegment seg in labeled)
{
    // "[00:00:01.000 --> 00:00:03.000] speaker_00: A pencil with black lead writes best."
    Console.WriteLine(seg);
}
```

Each `DiarizedTranscriptSegment` carries `Start`, `End`, `Text`, and the attributed `SpeakerId` (`-1` when no diarization turn overlaps the segment — for example a silent gap).

## Manual Media Blocks pipeline

Place `SpeakerDiarizationBlock` in the audio chain before the audio renderer or output:

```
var diarization = new SpeakerDiarizationBlock(settings);
diarization.OnSpeakerSegment += Diarization_OnSpeakerSegment;

pipeline.Connect(audioSource.Output, diarization.Input);
pipeline.Connect(diarization.Output, audioRenderer.Input);
```

## MediaPlayerCoreX file diarization

For playback, `Audio_Play` must be `true` for the audio chain to be built:

```
player.Audio_Play = true;

var diarization = new SpeakerDiarizationBlock(settings);
diarization.OnSpeakerSegment += Diarization_OnSpeakerSegment;

player.Audio_Processing_AddBlock(diarization); // before OpenAsync / PlayAsync
await player.OpenAsync(source);
await player.PlayAsync();
```

Let the file play to its end: stopping playback early skips the clustering step and leaves the timeline empty. Diarization reads only the audio, so to index a file as fast as the hardware allows rather than in real time, give the player an unsynced audio sink — `player.Audio_OutputBlock = new NullRendererBlock(MediaBlockPadMediaType.Audio) { IsSync = false };` — so the audio is not paced by the clock. (`Video_Renderer_IsSync = false` only unpaces a video renderer, so it has no effect on an audio-only file.)

See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the full `Audio_Processing_*` API and lifecycle rules. The engine owns the wired block after start and disposes it when the session stops — create a new block for the next session.

## How it works

Understanding these three stages explains every setting above, and why the result cannot arrive earlier.

1. **Segmentation, as the audio flows.** The audio is resampled to mono 16 kHz and cut into 10-second windows that advance 1 second at a time — so the windows overlap by 90%, and every instant of audio is seen by about ten of them. The pyannote model labels, for each of its ~59 output frames per second, which of up to three *window-local* speakers are talking.
2. **Voiceprints, as the audio flows.** For each window and each speaker active in it, the audio of that speaker is collected — **minus every frame where somebody else is talking too** — and turned into a voiceprint. Overlapped speech is excluded deliberately: a voiceprint taken from two voices at once sits between them and looks similar to both, which welds two speakers into one. Turns with less than ~0.17 s of clean speech are skipped for the same reason.
3. **Speakers and the timeline, at end-of-stream.** All the voiceprints of the recording are clustered together (agglomerative, complete linkage, cosine distance — `ClusterThreshold` / `NumSpeakers`). The window-local speaker numbers are rewritten into global ones, all the overlapping windows are laid on one frame grid, and **every frame is decided by a vote among the ~10 windows covering it**: how many people are talking is the average those windows report, and who they are is the most-voted. A window that mislabels a moment is outvoted by its neighbours. Finally the frames become turns, short pauses are bridged (`MinDurationOff`) and fragments are dropped (`MinDurationOn`).

## Threading, performance, and lifetime

Analysis runs on a **dedicated background worker**, not the streaming thread: the tap resamples the audio to mono 16 kHz and pushes it into an **unbounded queue**, and the worker consumes it in overlapping windows. Because analysis is off the streaming thread, audio is never paced to the models — a source that runs faster than they do (a file decoded at full speed, or a live source on a slow execution provider) simply makes the worker fall behind.

**A backlog is never dropped.** The queue grows instead — at 16 kHz mono that is 64 KB per buffered second — and it drains as soon as the worker catches up. If a machine is permanently slower than its source, the backlog keeps growing, and that is the honest signal: the answer is faster hardware or a GPU execution provider, never analysing a fraction of the audio. At end-of-stream the pipeline waits for the worker to drain the backlog and publish the timeline before tearing down.

`OnSpeakerSegment` is raised on the worker thread — never touch UI directly from the handler; marshal to the UI dispatcher or main thread.

Memory scales with the recording: the voiceprints are kept until the end (they are the clustering's input), and clustering builds a pairwise distance matrix over them.

## Result completeness

| Member | Description |
| --- | --- |
| `IsTimelineComplete` | `true` when the run actually produced an answer: the stream reached end-of-stream, the worker drained, and the speakers were clustered and published. **Check it before reading `GetTimeline()`** — when it is `false` the timeline is EMPTY, and that emptiness means "we never got to work out who spoke", not "nobody spoke". |
| `SpeakerCount` | How many distinct speakers were found. `0` until the timeline is published. |
| `UnattributedTurns` | Speech turns the segmentation model **found** but the embedding model could not voiceprint. Their audio *was* analysed, but they carry no speaker id and are absent from the timeline. |
| `ActiveProvider` | The execution provider the ONNX sessions actually engaged. Stays valid after the run, so it can be logged at the end. |

**A timeline is fully trustworthy when `IsTimelineComplete` is `true` AND `UnattributedTurns` is `0`.**

## Use cases

- **Meeting and interview transcription** — label a diarized transcript with per-speaker turns.
- **Call-center analytics** — separate agent and customer speech for talk-time and turn-taking metrics.
- **Media indexing** — index recorded video/audio by speaker for search and navigation.
- **Podcast and broadcast tooling** — auto-generate speaker-labeled show notes with speech-to-text.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| No turns are ever raised, and `IsTimelineComplete` is `false` | The stream never ended — the pipeline was stopped early, or the source is an endless live stream | Let the source reach end-of-stream. Diarization needs the complete recording; there is no partial answer to give. |
| No turns are raised although the file played to the end | A model path is invalid, or the audio chain isn't built | Confirm both ONNX files exist at their paths; for playback confirm `Audio_Play = true`. |
| Too many speakers detected | `ClusterThreshold` too small for this audio/model | **Raise** `ClusterThreshold` (it is a distance — a larger value merges more), or set `NumSpeakers` to the known count. |
| Speakers merged into one | `ClusterThreshold` too large | **Lower** `ClusterThreshold` (a smaller distance splits more eagerly), or set `NumSpeakers`. |
| Analysis lags a fast file source, and memory grows | The overlapping windows are compute-heavy, so the worker falls behind and the (unbounded) backlog grows — no audio is lost, but it is buffered | Use `Provider = OnnxExecutionProvider.CUDA` / `DirectML` on a GPU. A buffered second costs 64 KB. |
| Speech is missing although `IsTimelineComplete` is `true` | The embedding model failed to voiceprint some detected turns, so they got no speaker id | Check `UnattributedTurns`; look for the `SpeakerEmbeddingEngine` error in the log for the cause (typically a GPU out-of-memory or provider fallback). |

## Frequently Asked Questions

### Why do I get no speaker turns until the file ends?

Because until then there is no such thing as "speaker 2" to report. The segmentation model separates voices only inside a single 10-second window and numbers them locally; tying a voice at minute 1 to the same voice at minute 40 requires clustering every voiceprint of the recording at once. The block does all the work it can as the audio flows, and publishes the moment the last sample is in.

### Can I diarize an endless live stream?

No. A live stream has no end-of-stream, so the clustering step never runs. Diarize finite recordings — or segment a live stream into finite chunks and diarize each (speaker ids are not comparable between chunks).

### Does SpeakerDiarizationBlock require an internet connection?

No — diarization runs fully on-device through ONNX Runtime. Your application downloads the two model files once (or bundles them); nothing is called per-request over the network.

### Can I combine it with speech-to-text to get a speaker-labeled transcript?

Yes — run a [`SpeechToTextBlock`](../speech-to-text/) and a `SpeakerDiarizationBlock` on the same audio, then merge the transcript with `diarization.GetTimeline()` using `DiarizedTranscriptBuilder.Build` after end-of-stream.

### Are speaker ids the same across two separate runs?

No — ids are stable within a single run only. This version does not re-identify a speaker across runs.

### Which languages does it work with?

The segmentation model is language-independent, so it works with any language out of the box. The default WeSpeaker embedding model is trained on English (VoxCeleb) and under-detects speakers on other languages; for non-English or mixed-language audio, switch `EmbeddingModelPath` to the Apache-2.0 3D-Speaker ERes2NetV2 multilingual model and set `EmbeddingModel = SpeakerEmbeddingModel.ERes2NetV2Multilingual` (see [Multilingual diarization](#multilingual-diarization)). The front-end adapts its feature extraction to the chosen model automatically from the ONNX metadata.

---END OF PAGE---


## Speech-to-Text SDK for .NET — SpeechToTextBlock (Whisper)
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/speech-to-text/
**Description:** Speech-to-text SDK for .NET — transcribe live or file audio on-device with Whisper ASR and Silero VAD, plus SRT/VTT and live subtitle helpers.
**Tags:** .NET, AI, Whisper, Speech-to-Text, Speech-to-Text SDK, Speech Recognition, Live Subtitles, Transcription, VideoCaptureCoreX, MediaPlayerCoreX
**API:** SpeechToTextBlock, SpeechToTextSettings, SileroVadSettings, SpeechSegment, SubtitleWriter, SubtitleRenderer, SubtitleStyle

# Speech-to-Text and Live Subtitles — SpeechToTextBlock

`SpeechToTextBlock` is an audio-only Media Block from `VisioForge.DotNet.Core.AI.Whisper`. It taps the audio stream, segments speech with Silero VAD, transcribes it with Whisper (Whisper.net / GGML), and raises `OnSpeechRecognized`. Audio passes through unchanged. The block implements `IAudioProcessingBlock`, so it can be inserted into a manual pipeline or registered directly on `VideoCaptureCoreX`/`MediaPlayerCoreX`.

```
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.Types.X.AI;
```

## Basic block setup

```
var settings = new SpeechToTextSettings(whisperModelPath)
{
    Language = "auto",
    Task = SpeechToTextTask.Transcribe,
    EnableVad = true,
    EmitInterim = false,
};

settings.Vad.ModelPath = sileroVadModelPath;

var stt = new SpeechToTextBlock(settings);
stt.OnSpeechRecognized += (sender, e) =>
{
    foreach (var segment in e.Segments)
    {
        Console.WriteLine($"{segment.StartTime:c} - {segment.EndTime:c}: {segment.Text}");
    }
};
```

`SpeechToTextTask.Transcribe` keeps the source language. `SpeechToTextTask.Translate` translates supported source speech to English text.

## Key settings

`SpeechToTextSettings(whisperModelPath)`. Unlike the vision AI settings, this type does **not** derive from `OnnxInferenceSettings` — Whisper runs through Whisper.net (whisper.cpp / GGML), not ONNX Runtime, so the ONNX-specific input-size/normalization knobs don't apply.

| Property | Default | Description |
| --- | --- | --- |
| `WhisperModelPath` | — | Absolute path to the Whisper GGML model file (`ggml-*.bin`). Required. |
| `ModelSize` | `WhisperModelSize.Base` | Informational label for the model variant at `WhisperModelPath` (see below). |
| `Language` | `"auto"` | ISO 639-1 code (`"en"`, `"es"`, `"fr"`, ...), or `"auto"` to let Whisper detect it. |
| `Task` | `Transcribe` | `Transcribe` (source language) or `Translate` (to English). |
| `Provider` | `Auto` | Only `CPU` and `CUDA` are meaningful for the GGML backend (no DirectML); `Auto` picks CUDA when present, else CPU. |
| `DeviceId` | `0` | Hardware device id when a GPU provider is selected. |
| `Threads` | `0` | CPU threads Whisper uses. `0` lets Whisper.net choose from the available processor count. |
| `EnableVad` | `true` | Segment speech with Silero VAD before transcription. When `false`, audio is transcribed in fixed windows, which is prone to hallucinating text during silence. |
| `Vad` | new `SileroVadSettings` | VAD settings used when `EnableVad` is `true`. |
| `FixedWindowSeconds` | `5` | Fixed transcription window length when `EnableVad` is `false`. Clamped to 1–30 s. |
| `EmitInterim` | `false` | Reserved for a future interim-hypothesis capability; currently has no effect — only final segments are emitted. |
| `OutputSrtPath` | `null` | Optional `.srt` side-car path the block writes as final segments are recognized. |
| `OutputVttPath` | `null` | Optional `.vtt` (WebVTT) side-car path the block writes as final segments are recognized. |

## VAD settings

When `EnableVad` is `true`, `SpeechToTextSettings.Vad` controls Silero speech segmentation. Silero VAD is a tiny (~2 MB, MIT) ONNX model that classifies short audio windows as speech or non-speech, used as a real-time pre-filter so the (much heavier) Whisper model only runs on actual speech.

```
settings.Vad = new SileroVadSettings
{
    ModelPath = sileroVadModelPath,
    SpeechThreshold = 0.5f,
    MinSilenceMs = 100,
    MinSpeechMs = 250,
    SpeechPadMs = 30,
    MaxSpeechMs = 15000,
    Provider = OnnxExecutionProvider.CPU,
};
```

| Property | Default | Description |
| --- | --- | --- |
| `ModelPath` | — | Absolute path to `silero_vad.onnx`. |
| `SpeechThreshold` | `0.5` | Speech-probability threshold (0..1). Raise it in noisy environments to reduce false triggers. |
| `MinSilenceMs` | `100` | Minimum trailing silence, in ms, that ends a speech segment. |
| `MinSpeechMs` | `250` | Minimum speech-run duration, in ms, to be emitted (discards spurious blips). |
| `SpeechPadMs` | `30` | Onset padding, in ms, prepended to each detected segment. |
| `MaxSpeechMs` | `15000` | Maximum segment length, in ms, before the segmenter force-cuts an ongoing run. |
| `Provider` | `CPU` | Execution provider for the VAD session — the model is tiny (~1 ms/window on CPU), so GPU adds latency without benefit. |
| `DeviceId` | `0` | Hardware device id when a GPU provider is selected. |

The Whisper GGML weights and the Silero VAD model are downloaded at runtime; neither is shipped in the SDK NuGet packages.

### Whisper model sizes

`WhisperModelSize` is informational — it names well-known Whisper GGML weight files so an application can pick one to download. The file actually loaded is always `SpeechToTextSettings.WhisperModelPath`.

| Value | Approx. size | Notes |
| --- | --- | --- |
| `Tiny` | ~75 MB | Fastest, lowest accuracy. Good for real-time CPU transcription. |
| `Base` (default) | ~142 MB | A good real-time CPU default. |
| `Small` | ~466 MB | Noticeably more accurate; real-time with a GPU or a fast CPU. |
| `Medium` | ~1.5 GB | High accuracy; typically needs a GPU for real-time. |
| `LargeV3` | ~3 GB | Highest accuracy; GPU strongly recommended. |
| `LargeV3Turbo` | ~1.6 GB | Near-large accuracy at a fraction of the cost. |
| `TinyQuantized` | ~31 MB | `Tiny`, Q5\_1-quantized. |
| `BaseQuantized` | ~57 MB | `Base`, Q5\_1-quantized. |
| `SmallQuantized` | ~181 MB | `Small`, Q5\_1-quantized. |
| `MediumQuantized` | ~514 MB | `Medium`, Q5\_0-quantized. |
| `LargeV3TurboQuantized` | ~547 MB | `LargeV3Turbo`, Q5\_0-quantized. Recommended quantized accuracy/speed balance. |

English-only (`*.en`) variants aren't enumerated; supply their path directly. Weights are MIT-licensed.

## Recognized segments

Each `SpeechSegment` in `SpeechRecognizedEventArgs.Segments`:

| Property | Description |
| --- | --- |
| `Text` | The recognized text for the segment. |
| `StartTime` / `EndTime` | `TimeSpan`, relative to the start of the stream — ready to use for SRT/VTT or on-screen scheduling. |
| `IsFinal` | Reserved to distinguish interim vs. final hypotheses once interim results exist; segments are currently always final (`true`). |
| `Language` | Detected/used ISO 639-1 code, or `null` if unknown. |
| `Confidence` | Average token confidence (0..1), or `0` when the model doesn't report token probabilities. |

## Subtitle helpers

### SubtitleWriter — SRT/VTT files

`SubtitleWriter` writes recognized speech segments to a SubRip (`.srt`) or WebVTT (`.vtt`) side-car file, appending one cue per final segment. It is thread-safe; interim (non-final) segments are ignored.

```
using VisioForge.Core.AI.Whisper.Subtitles;

using var writer = new SubtitleWriter("captions.srt", SubtitleFormat.Srt);
stt.OnSpeechRecognized += (sender, e) =>
{
    foreach (var segment in e.Segments)
    {
        writer.Add(segment);
    }
};
```

If you only need files, it's simpler to set `OutputSrtPath` and/or `OutputVttPath` on `SpeechToTextSettings` — the block creates and drives its own `SubtitleWriter` instance(s) internally as final segments are recognized, and disposes them for you.

### SubtitleRenderer — on-screen captions

`SubtitleRenderer` drives a single text overlay on an `OverlayManagerBlock`: it shows the latest caption and auto-hides it after the segment's display duration.

```
using SkiaSharp;
using VisioForge.Core.AI.Whisper.Subtitles;

var style = new SubtitleStyle
{
    FontName = "Arial",
    FontSize = 32,
    Color = SKColors.White,
    X = 50,
    Y = 50,
    MinDisplay = TimeSpan.FromSeconds(1.5),
    MaxDisplay = TimeSpan.FromSeconds(6),
};

var subtitleRenderer = new SubtitleRenderer(overlayManagerBlock, style);
stt.OnSpeechRecognized += subtitleRenderer.OnSpeechRecognized;

// ... later, when tearing down:
subtitleRenderer.Dispose(); // removes the overlay and stops the auto-hide timer
```

Wire `SubtitleRenderer.OnSpeechRecognized` directly as the block's event handler. It clamps the on-screen time into `[MinDisplay, MaxDisplay]` based on the segment's duration and calls `OverlayManagerBlock.Video_Overlay_Update` from whatever thread invokes it — marshal the call if your UI framework requires it. `SubtitleStyle` defaults: `FontName = "Arial"`, `FontSize = 32`, `Color = White`, `X = 50`, `Y = 50`, `MinDisplay = 1.5 s`, `MaxDisplay = 6 s`.

No shipping demo yet

`SubtitleRenderer` exists in the SDK and is documented from its source, but no bundled demo currently uses it — the Live Subtitles X demos update a UI label directly from `OnSpeechRecognized` instead. Use `SubtitleWriter` or `OutputSrtPath`/`OutputVttPath` if you only need a subtitle file.

## Manual Media Blocks pipeline

Place `SpeechToTextBlock` in the audio chain before the audio renderer or output:

```
var stt = new SpeechToTextBlock(settings);
stt.OnSpeechRecognized += SpeechToText_OnSpeechRecognized;

pipeline.Connect(audioSource.Output, stt.Input);
pipeline.Connect(stt.Output, audioRenderer.Input);
```

## VideoCaptureCoreX live microphone transcription

For capture, an audio source is required. If you want analysis without speaker monitoring or recording, terminate the audio chain with a non-synced null renderer:

```
core.Audio_Source = microphoneSettings;
core.Audio_OutputBlock = new NullRendererBlock(MediaBlockPadMediaType.Audio)
{
    IsSync = false,
};

var stt = new SpeechToTextBlock(settings);
stt.OnSpeechRecognized += SpeechToText_OnSpeechRecognized;

core.Audio_Processing_AddBlock(stt); // before StartAsync
await core.StartAsync();
```

`Audio_OutputBlock` builds and terminates the audio chain without enabling speaker playback or file recording. The engine owns the assigned output block after start.

## MediaPlayerCoreX file transcription

For playback, `Audio_Play` must be `true` for the audio chain to be built. A non-synced null renderer lets the source run without real-time speaker output:

```
player.Audio_Play = true;
player.Audio_OutputBlock = new NullRendererBlock(MediaBlockPadMediaType.Audio)
{
    IsSync = false,
};

var stt = new SpeechToTextBlock(settings);
stt.OnSpeechRecognized += SpeechToText_OnSpeechRecognized;

player.Audio_Processing_AddBlock(stt); // before OpenAsync / PlayAsync
await player.OpenAsync(source);
await player.PlayAsync();
```

See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the full `Audio_Processing_*`/`Audio_OutputBlock` API and lifecycle rules.

## Threading, pacing, and lifetime

VAD and Whisper run **synchronously on the GStreamer streaming thread**: audio is segmented and transcribed in place, and the trailing segment is flushed at end-of-stream. Nothing is dropped — the whole input is transcribed losslessly, and the pipeline position tracks the transcription frontier (useful for a progress bar). Because transcription runs inline, the source is paced to Whisper: if Whisper is slower than real time, the upstream (including a live capture device) is throttled rather than losing audio. In practice Whisper Base runs well above real time, so it is not the bottleneck for a typical source.

`OnSpeechRecognized` is raised on that same streaming thread — never touch UI directly from the handler; marshal to the UI dispatcher or main thread.

After a capture or playback session starts, the engine owns wired `SpeechToTextBlock` instances and disposes them when the session stops. Create a new block for the next session.

## Use cases

- **Live captioning** — real-time subtitles for a live stream, webinar, or accessibility overlay.
- **Meeting and call transcription** — transcribe a microphone feed alongside `VideoCaptureCoreX` capture.
- **Media indexing and search** — batch-transcribe recorded video/audio files to make their content searchable.
- **Subtitle authoring** — generate `.srt`/`.vtt` side-car files from source video without a third-party transcription service.
- **Translation captions** — set `Task = SpeechToTextTask.Translate` to caption non-English speech in English.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| No segments are ever recognized | `WhisperModelPath` invalid, or the audio chain isn't built | Confirm the GGML model file exists at that path; for capture/playback, confirm the audio chain is active (see `Audio_OutputBlock` below). |
| Whisper "hallucinates" text during silence | `EnableVad` is `false` | Enable VAD (`EnableVad = true`, the default) so Whisper only runs on detected speech, not fixed windows that may be silent. |
| Transcription lags behind live audio | Whisper is slower than real time on the current hardware/model size | Choose a smaller `WhisperModelSize`/model file, or use `Provider = CUDA` on a machine with an NVIDIA GPU. |
| Segments are cut off mid-sentence | `SileroVadSettings.MaxSpeechMs` force-cuts a long continuous utterance | This is a deliberate bound (default 15 s) so one in-flight transcription can't grow unbounded; raise `MaxSpeechMs` if your scenario needs longer uninterrupted segments and can tolerate the larger bound. |
| No audio reaches the block on `VideoCaptureCoreX`/`MediaPlayerCoreX` | Audio chain not built (missing `Audio_Source`/`Audio_Play`) | See [VideoCaptureCoreX live microphone transcription](#videocapturecorex-live-microphone-transcription) and [MediaPlayerCoreX file transcription](#mediaplayercorex-file-transcription) above. |
| `.srt`/`.vtt` file is empty | Segments never finalized, or wrong path | Confirm `OutputSrtPath`/`OutputVttPath` point to a writable path and that speech was actually detected; only final segments are written. |

## Frequently Asked Questions

### Does SpeechToTextBlock require an internet connection?

No — transcription runs fully on-device through Whisper.net/GGML; the model files are downloaded once by your application (or bundled), not called per-request over the network.

### Which languages does it support?

Whisper is multilingual — set `Language` to an ISO 639-1 code, or leave it `"auto"` to let Whisper detect the spoken language automatically.

### Can I translate speech to English captions instead of transcribing the source language?

Yes — set `SpeechToTextSettings.Task = SpeechToTextTask.Translate`.

### How do I get live on-screen subtitles instead of just an event?

Wire `SubtitleRenderer.OnSpeechRecognized` as the block's event handler against an `OverlayManagerBlock` — see [SubtitleRenderer — on-screen captions](#subtitlerenderer-on-screen-captions). If you only need SRT/VTT files, set `OutputSrtPath`/`OutputVttPath` instead.

### Which Whisper model size should I use?

Start with `Base` (the default) for real-time CPU transcription. Move to `Small`/`Medium`/`LargeV3` (or their quantized variants) for higher accuracy if you have a GPU or can tolerate slower-than-real-time processing; see the [Whisper model sizes](#whisper-model-sizes) table for the full trade-off.

## Demos

- **[Live Subtitles Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Live%20Subtitles%20Demo)** — WPF Media Blocks pipeline demo.
- **[Live Subtitles MB](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/MAUI/Live%20Subtitles%20MB)** — the same Media Blocks demo for MAUI.
- **[Live Subtitles](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/Console/Live%20Subtitles)** — headless console demo (downloads models on first run).

Dedicated `VideoCaptureCoreX`/`MediaPlayerCoreX` live-subtitles demos (`Capture Live Subtitles X`, `Capture Live Subtitles X WPF`, `Player Live Subtitles X`, `Player Live Subtitles X WPF`) are in the SDK's demo set and will be linked here once published to the public samples repository.

---END OF PAGE---


## Describe and Caption Video Frames in .NET — Florence-2
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/vlm-captioning/
**Description:** Generate captions, descriptions, OCR, and grounded regions from video frames with one model. On-device vision-language AI for .NET (Florence-2).
**Tags:** .NET, AI, ONNX, VLM, Vision Language Model, Florence-2, Image Captioning, Phrase Grounding, VideoCaptureCoreX, MediaPlayerCoreX
**API:** VLMBlock, VLMSettings, VLMTask, VLMResultGeneratedEventArgs

# VLM Captioning — VLMBlock

You need human-readable output from video — a caption for accessibility, a description to index or moderate footage, or the text on a sign — but standing up and maintaining separate captioning, object-detection, and OCR pipelines is a lot of moving parts. A **vision-language model** does all of it with one model: give it a frame and a task, get back text (and, for grounding tasks, boxes). `VLMBlock` runs Microsoft Florence-2 on-device via ONNX — no cloud, no per-call cost.

`VLMBlock` runs a **vision-language model** (Microsoft Florence-2) over the video stream to produce natural-language output: a caption of the scene, a detailed description, detected objects with labels, region descriptions, OCR text, or phrases grounded to image regions. It is a pass-through video block: frames flow through untouched, optional overlays are drawn in place, and each processed frame raises `OnResultGenerated` with the model's text and any regions.

Inference runs on a background worker throttled by `ProcessingInterval` — at most one frame per interval is captioned, and other frames simply redraw the cached result, so the pipeline is never stalled. A single block instance switches tasks at runtime through its `Task` property.

```
graph LR;
    Source-->VLMBlock;
    VLMBlock-->VideoRendererBlock;
    VLMBlock-. OnResultGenerated .->App[Your app];
```

Florence-2 runs on the CPU

The block forces the `CPU` execution provider — the DirectML backend mis-executes Florence-2's autoregressive merged decoder and returns garbage. There is no `Provider`/`DeviceId` knob on `VLMSettings`. Control cost with `ProcessingInterval` (how often a frame is processed) and `MaxNewTokens` (how much text is generated).

## How Florence-2 works

A vision-language model (VLM) is a single network that takes an image plus a text instruction and generates a text answer. `VLMBlock` runs Microsoft **Florence-2** as a four-stage ONNX pipeline:

1. **Vision encoding.** The frame is resized to 768x768 and encoded into image features.
2. **Task prompting.** The chosen `VLMTask` maps to a Florence-2 task token (for example `<CAPTION>` or `<OD>`), joined with `TextInput` for phrase grounding, then tokenized and embedded.
3. **Fusion.** The text encoder fuses the task with the image features.
4. **Decoding.** The decoder generates tokens greedily (argmax, no beam search) up to `MaxNewTokens`. The output string is parsed into `Text` and, for region tasks, `<loc_N>` coordinate tokens are converted into pixel `Box` values in `Regions`.

One model covers captioning, detection, region description, OCR, and phrase grounding — you switch behavior by changing `Task`, not by loading a different model.

## Tasks

Set `VLMSettings.Task` (or `VLMBlock.Task` at runtime) to choose what the model does per processed frame.

| `VLMTask` | Output | Produces regions |
| --- | --- | --- |
| `Caption` (default) | A short one-sentence caption describing the frame. | No |
| `DetailedCaption` | A more detailed caption. | No |
| `MoreDetailedCaption` | A paragraph-length, highly detailed caption. | No |
| `ObjectDetection` | Objects with a category label and bounding box each. | Yes |
| `DenseRegionCaption` | Regions with a short description and bounding box each. | Yes |
| `Ocr` | All text in the frame as a single string. | No |
| `OcrWithRegion` | Text blocks, each with its region. | Yes |
| `PhraseGrounding` | Grounds the phrases of the caption in `TextInput` to image regions. | Yes |

`PhraseGrounding` requires `VLMSettings.TextInput` — the caption whose phrases are located (for example `"a person next to a red car"`). The region-producing tasks fill `VLMResultGeneratedEventArgs.Regions`; the caption-only tasks return text only.

### Which task should I use?

| Goal | Task |
| --- | --- |
| A quick one-line label of the scene | `Caption` |
| A rich description for indexing, accessibility, or search metadata | `DetailedCaption` / `MoreDetailedCaption` |
| Read on-screen or in-scene text | `Ocr` (string) / `OcrWithRegion` (text + boxes) |
| Boxes and labels without a trained detector | `ObjectDetection` / `DenseRegionCaption` |
| Confirm and locate a described situation | `PhraseGrounding` (set `TextInput`) |

Longer descriptions and grounding generate more tokens, so they take longer per frame than a short `Caption` — raise `MaxNewTokens` for them and keep `ProcessingInterval` comfortable.

## Usage

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.AI;

// All model files resolve from one folder by their conventional names.
var settings = new VLMSettings(modelFolder)
{
    Task = VLMTask.DetailedCaption,
    ProcessingInterval = TimeSpan.FromSeconds(1),
    MaxNewTokens = 256,
    DrawResults = true,
};

var vlm = new VLMBlock(settings);
vlm.OnResultGenerated += (sender, e) =>
{
    var text = e.Text;
    if (string.IsNullOrEmpty(text) && e.Regions.Length > 0)
        text = string.Join(", ", e.Regions.Select(r => r.Label));

    Console.WriteLine($"[{e.Timestamp:hh\\:mm\\:ss}] {e.Task}: {text} ({e.InferenceTimeMs:F0} ms)");
};

var videoRenderer = new VideoRendererBlock(pipeline, videoView) { IsSync = false };

pipeline.Connect(source.Output, vlm.Input);
pipeline.Connect(vlm.Output, videoRenderer.Input);

await pipeline.StartAsync();

Console.WriteLine($"Running on: {vlm.ActiveProvider}"); // always CPU for Florence-2
```

`VLMResultGeneratedEventArgs` carries the `Task` that produced the result, the generated `Text`, a `Regions` array (`VLMRegion { Label, Box }`, boxes in source-frame pixels; empty for caption-only tasks), the source-frame `Timestamp`, and `InferenceTimeMs`. Handlers are raised on the block's worker thread — marshal UI updates to the UI thread.

### Switching task and grounding text at runtime

```
vlm.Task = VLMTask.Ocr;                       // switch to OCR on the fly

vlm.Task = VLMTask.PhraseGrounding;
vlm.TextInput = "a person next to a red car"; // required for phrase grounding
```

## Key settings

`VLMSettings` is a standalone settings class (it does **not** derive from `OnnxInferenceSettings`).

| Property | Default | Description |
| --- | --- | --- |
| `Task` | `VLMTask.Caption` | The task performed per processed frame. Runtime-changeable. |
| `TextInput` | `null` | Auxiliary caption used only by `PhraseGrounding`. Runtime-changeable. |
| `MaxNewTokens` | `256` | Maximum tokens the decoder generates per frame. |
| `ProcessingInterval` | `1 second` | Minimum interval between two inferences. Other frames redraw the cached result. |
| `DrawResults` | `true` | Draw grounded regions and the caption bar into the frame. |
| `BoxColor` / `BoxThickness` | LimeGreen / `2` | Region-box overlay styling. |
| `LabelFontSize` | `0` | Label/caption font size in px. `0` auto-scales to frame height. |
| `VisionEncoderPath`, `EmbedTokensPath`, `EncoderModelPath`, `DecoderModelPath` | `null` | The four Florence-2 ONNX models. Set directly, or use the `VLMSettings(modelFolder)` constructor. |
| `VocabFilePath`, `MergesFilePath`, `AddedTokensFilePath` | `null` | BART tokenizer assets. `AddedTokensFilePath` is required for grounding tasks; caption tasks work without it. |

There is no `Provider`, `DeviceId`, or `FramesToSkip` — Florence-2 is CPU-only and throttling is time-based via `ProcessingInterval`. `VLMBlock.ActiveProvider` always reports `CPU`; `DroppedFrameCount` stays `0` by design (frames are sampled, never dropped).

## Model

The block runs Microsoft **Florence-2 (base)** as a four-session ONNX pipeline — vision encoder, token embedder, text encoder, and a merged autoregressive decoder — plus a BART byte-level BPE tokenizer. Decoding is greedy (argmax). Model weights are not bundled with the SDK; the demos download them on first run from GitHub Releases and cache them under `%USERPROFILE%\VisioForge\models\vlm`:

| Role | File |
| --- | --- |
| Vision encoder | `florence2-base-vision-encoder.onnx` |
| Token embedder | `florence2-base-embed-tokens.onnx` |
| Text encoder | `florence2-base-encoder.onnx` |
| Merged decoder | `florence2-base-decoder-merged.onnx` |
| Tokenizer | `florence2-vocab.json`, `florence2-merges.txt`, `florence2-added-tokens.json` |

A model's license is set by its origin, independent of the SDK's own license — confirm the license of the weights you deploy.

## Performance and tuning

Florence-2 runs on the CPU and generates text token-by-token, so it is designed for periodic frame understanding, not high-frame-rate real-time captioning. Tune it with two knobs:

- **`ProcessingInterval`** (default 1 second) sets how often a frame is captioned. Frames between inferences reuse the last result for the overlay, so live video never stalls.
- **`MaxNewTokens`** (default 256) bounds per-frame latency. Short-caption tasks finish in far fewer tokens than `MoreDetailedCaption` or grounding — lower it if you only need brief output, raise it if long output is being cut off.

`DroppedFrameCount` stays `0` by design (frames are sampled, never dropped), and `ActiveProvider` always reports `CPU`. There is no GPU or `FramesToSkip` knob — throttle with `ProcessingInterval`.

## Use with VideoCaptureCoreX and MediaPlayerCoreX

Register the block before the session starts. On `MediaPlayerCoreX`, open the file with audio rendering off if you only want captions:

```
var settings = new VLMSettings(modelFolder)
{
    Task = VLMTask.Caption,
    DrawResults = true,
};

var vlm = new VLMBlock(settings);
vlm.OnResultGenerated += Vlm_OnResultGenerated;

// VideoCaptureCoreX (live camera):
core.Video_Processing_AddBlock(vlm);            // before StartAsync
await core.StartAsync();

// MediaPlayerCoreX (file):
var source = await UniversalSourceSettings.CreateAsync(filePath, renderVideo: true, renderAudio: false);
player.Video_Processing_AddBlock(vlm);          // before OpenAsync / PlayAsync
player.Video_Play = true;
player.Audio_Play = false;
await player.OpenAsync(source);
await player.PlayAsync();
```

`Task` and `TextInput` remain live-updatable while the session runs. See [Using AI blocks with VideoCaptureCoreX and MediaPlayerCoreX](../x-engines/) for the shared processing-block API and lifecycle rules.

## One model vs separate OCR, detection, and captioning

`VLMBlock` can replace three separate pipelines — but the specialized blocks are faster at their one job. Pick by what you need:

| You need | Best fit |
| --- | --- |
| A caption or description of the scene | `VLMBlock` (`Caption` / `DetailedCaption`) — no specialized block produces this. |
| Text read from the frame | `VLMBlock` (`Ocr`), or [`OcrBlock`](../ocr/) when you need it faster (PaddleOCR). |
| Boxes and labels for objects | `VLMBlock` (`ObjectDetection`), or [`YOLOObjectDetectorBlock`](../object-detection/) for much higher speed on fixed classes. |
| Highest frame rate / real-time | A specialized block — `VLMBlock` is CPU-only and runs periodically. |
| Several of the above from one model | `VLMBlock` — switch `Task` at runtime, a single model download. |

Reach for `VLMBlock` when you want rich, flexible, natural-language output — or several of these results from one model at a relaxed cadence. Reach for the specialized blocks when you need one specific output at high frame rate. They compose: run a VLM for descriptions and a detector for real-time boxes in the same pipeline.

## Use cases

- **Automatic scene descriptions** — caption a live camera or a recorded file for accessibility, logging, or search metadata.
- **Content indexing** — run `DetailedCaption` at intervals to build a text summary track for a video archive.
- **In-frame text extraction** — read on-screen text with `Ocr` / `OcrWithRegion` without a separate OCR pipeline.
- **Visual question checks** — use `PhraseGrounding` to confirm whether a described situation ("a person wearing a helmet") is present and where.
- **Lightweight object and region labeling** — `ObjectDetection` / `DenseRegionCaption` for label-and-box output when a trained detector isn't available.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| Startup error about a missing model file | Not all seven files are present in the model folder | Ensure the four `.onnx` models and three tokenizer files are downloaded before constructing `VLMSettings(modelFolder)`. |
| `PhraseGrounding` returns nothing | `TextInput` is empty | Set `TextInput` to the caption whose phrases should be grounded. |
| Grounding tasks produce no regions | `AddedTokensFilePath` missing | Grounding tasks need `florence2-added-tokens.json`; caption tasks do not. |
| High CPU usage / low responsiveness | Frames captioned too often, or `MaxNewTokens` too high | Raise `ProcessingInterval`; lower `MaxNewTokens`. |
| No GPU acceleration | By design | Florence-2 is CPU-only here; tune throughput with `ProcessingInterval` and `MaxNewTokens`. |

## Frequently Asked Questions

### How do I generate a description of a video frame in C#?

Add a `VLMBlock` with `Task = VLMTask.DetailedCaption`, subscribe to `OnResultGenerated`, and read `e.Text` — that string is the frame's description. See [Usage](#usage). Use `ProcessingInterval` to control how often a description is produced.

### Can one model do both OCR and captioning?

Yes — Florence-2 handles captioning, description, object detection, region description, OCR, and phrase grounding. Switch between them with the `Task` property (even at runtime) instead of loading separate models. See [Tasks](#tasks).

### Can I change the task without restarting the pipeline?

Yes — set `VLMBlock.Task` (and `TextInput` for phrase grounding) at any time. The change applies on the next processed frame.

### Why doesn't setting a GPU provider speed it up?

`VLMSettings` intentionally exposes no provider setting. The DirectML backend mis-executes Florence-2's merged decoder, so the block forces CPU. Throttle with `ProcessingInterval` instead.

### How often is a caption generated?

At most once per `ProcessingInterval` (default 1 second). Frames arriving between inferences reuse the last result for the overlay, so live video never stalls waiting on the model.

### How is this different from OCR or object detection?

[`OcrBlock`](../ocr/) and [`YOLOObjectDetectorBlock`](../object-detection/) are specialized, fast, and single-purpose. `VLMBlock` is a general model that can caption, describe, detect, ground, and read text — more flexible but heavier, and CPU-only. Use the specialized blocks when you need one of their exact outputs at speed; use `VLMBlock` for rich descriptions or when you want several of these outputs from one model.

### Can I ask a free-form question about the frame?

Not as open-ended visual question answering — `VLMBlock` runs Florence-2's fixed `VLMTask` set (caption, describe, detect, region-caption, OCR, phrase grounding). The closest to a question is `PhraseGrounding`: put a described situation in `TextInput` and the model locates its phrases in the frame. For descriptions, use the caption tasks.

### What language is the output?

Florence-2 generates English text for captions, descriptions, and OCR.

### How do I turn captions into a subtitle or metadata track?

Each `OnResultGenerated` gives you the `Text` and the source-frame `Timestamp`. Collect those pairs as the file plays (or as the camera runs) and write them to your own SRT/VTT or a metadata index — the block produces the per-frame text and timing; assembling a track is your application's job.

### Does it need an internet connection?

No. Inference is fully local ONNX. Only the first-run model download needs a network, and you can ship the model files with your app instead.

## Demos

Dedicated demos built on Media Blocks, `VideoCaptureCoreX`, and `MediaPlayerCoreX` (`VLM Captioning Demo`, `VLM Captioning MB`, `Capture VLM Captioning X`, `Capture VLM Captioning X WPF`, `Player VLM Captioning X`, `Player VLM Captioning X WPF`) are in the SDK's demo set and will be linked here once published to the public samples repository.

---END OF PAGE---


## AI Blocks with VideoCaptureCoreX and MediaPlayerCoreX
**URL:** https://www.visioforge.com/help/docs/dotnet/general/ai/x-engines/
**Description:** Insert AI Media Blocks — OCR, object detection, face recognition, ANPR, background removal, speech-to-text — into VideoCaptureCoreX and MediaPlayerCoreX.
**Tags:** .NET, AI, VideoCaptureCoreX, MediaPlayerCoreX, Media Blocks
**API:** VideoCaptureCoreX, MediaPlayerCoreX, IVideoProcessingBlock, IAudioProcessingBlock, NullRendererBlock

# AI Blocks with VideoCaptureCoreX and MediaPlayerCoreX

`VideoCaptureCoreX` and `MediaPlayerCoreX` can host user-supplied Media Blocks inside their high-level pipelines. Use this path when you want the convenience of the X engines and only need to add AI processing to the video or audio chain — no manual `MediaBlocksPipeline` topology required.

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.Types.X.AI;
```

## Public API

Both engines expose the same processing-block API:

| API | Purpose |
| --- | --- |
| `Video_Processing_AddBlock(IVideoProcessingBlock block)` | Add a video processing block for the next session. |
| `Video_Processing_RemoveBlock(IVideoProcessingBlock block)` | Remove a registered video block before the session starts. |
| `Video_Processing_Clear()` | Clear registered video blocks before the session starts. |
| `Video_Processing_Blocks` | Snapshot of registered video blocks. |
| `Audio_Processing_AddBlock(IAudioProcessingBlock block)` | Add an audio processing block for the next session. |
| `Audio_Processing_RemoveBlock(IAudioProcessingBlock block)` | Remove a registered audio block before the session starts. |
| `Audio_Processing_Clear()` | Clear registered audio blocks before the session starts. |
| `Audio_Processing_Blocks` | Snapshot of registered audio blocks. |
| `Audio_OutputBlock` | Replace the default audio sink with a custom `MediaBlock`, commonly a non-synced `NullRendererBlock` for speech-to-text. |

Every video AI block (`OcrBlock`, `YOLOObjectDetectorBlock`, `ObjectAnalyticsBlock`, `FaceRecognitionBlock`, `LicensePlateRecognizerBlock`, `OpenVocabularyDetectorBlock`, `VLMBlock`, `VideoEmbeddingBlock`, `BackgroundRemovalBlock`, `OnnxInferenceBlock`) implements `IVideoProcessingBlock`. `SpeechToTextBlock` implements `IAudioProcessingBlock`.

`VideoEmbeddingBlock` (semantic video search) is designed to index a **file** — use it with `MediaPlayerCoreX` (or a manual Media Blocks pipeline), typically with `Video_Renderer_IsSync = false` for full-speed offline indexing. There is no `VideoCaptureCoreX` capture demo for it; see [Semantic video search](../semantic-video-search/).

## Lifecycle rules

Register blocks before the engine builds its pipeline: before `StartAsync` on `VideoCaptureCoreX`, before `OpenAsync`/`PlayAsync` on `MediaPlayerCoreX`. Adding, removing, or clearing processing blocks after the pipeline build has started is ignored and logged as a `Warning`:

- `VideoCaptureCoreX`: *"Cannot add a processing block while capture is running. Add it before Start()."*
- `MediaPlayerCoreX`: *"Cannot add a processing block while playback is running. Add it before Play()."*

(The log text uses the classic `Start()`/`Play()` names even though the public API you call is `StartAsync()`/`PlayAsync()` — the warning strings predate the async wrappers and are quoted here verbatim so you can grep for them.)

If you see one of these messages in the log, the block call happened after the session was already started (or starting) — move it earlier.

Once the session starts, the engine owns wired processing blocks and disposes them when the session stops. Create a fresh block instance before each new session; block events are raised on pipeline or block worker threads — keep handlers non-blocking and marshal UI changes to the UI dispatcher or main thread. If a chain is inactive, its registered blocks don't run — for example, an audio processing block requires an audio source and a built audio chain.

## Pipeline insertion order

- **`VideoCaptureCoreX`**: video AI blocks are inserted after video effects and before the sample grabber, overlay, tee, renderer, and outputs — so overlays the AI block draws reach both the preview and every recording/streaming output.
- **`MediaPlayerCoreX`**: video AI blocks are inserted after video effects and before the sample grabber, renderer, and custom video outputs.

## VideoCaptureCoreX video AI

```
var detector = new YOLOObjectDetectorBlock(new YoloDetectorSettings(modelPath)
{
    Model = ObjectDetectorModel.YOLOv8,
    DrawDetections = true,
});

detector.OnObjectsDetected += (sender, e) =>
{
    // Raised from the streaming thread.
    Console.WriteLine($"Detected {e.Objects.Length} objects.");
};

core.Video_Processing_AddBlock(detector); // before StartAsync
await core.StartAsync();
```

The same pattern applies to `OcrBlock`, `ObjectAnalyticsBlock`, `FaceRecognitionBlock`, `LicensePlateRecognizerBlock`, `OpenVocabularyDetectorBlock`, `VLMBlock`, `VideoEmbeddingBlock`, `BackgroundRemovalBlock`, and `OnnxInferenceBlock` — see each block's own page for its settings and event payload.

## VideoCaptureCoreX speech-to-text

```
core.Audio_Source = microphoneSettings;
core.Audio_OutputBlock = new NullRendererBlock(MediaBlockPadMediaType.Audio)
{
    IsSync = false,
};

var sttSettings = new SpeechToTextSettings(whisperModelPath)
{
    EnableVad = false, // or keep EnableVad = true and set sttSettings.Vad.ModelPath = sileroVadModelPath;
};
var stt = new SpeechToTextBlock(sttSettings);
stt.OnSpeechRecognized += SpeechToText_OnSpeechRecognized;

core.Audio_Processing_AddBlock(stt); // before StartAsync
await core.StartAsync();
```

`EnableVad` defaults to `true`, which requires `SileroVadSettings.ModelPath` — the pipeline build fails if VAD is enabled but no model path is set. Either disable VAD or set `sttSettings.Vad.ModelPath` before registering the block.

For capture, an audio source is required. `Audio_OutputBlock` can activate and terminate the audio chain without `Audio_Play`, `Audio_Record`, speaker monitoring, or a recording output.

## MediaPlayerCoreX video AI

```
var ocr = new OcrBlock(new OcrSettings(
    detectionModelPath,
    recognitionModelPath,
    characterDictionaryPath,
    classificationModelPath)
{
    DrawResults = true,
});

ocr.OnTextDetected += Ocr_OnTextDetected;

player.Video_Processing_AddBlock(ocr); // before OpenAsync / PlayAsync
await player.OpenAsync(source);
await player.PlayAsync();
```

## MediaPlayerCoreX speech-to-text

```
player.Audio_Play = true;
player.Audio_OutputBlock = new NullRendererBlock(MediaBlockPadMediaType.Audio)
{
    IsSync = false,
};

var sttSettings = new SpeechToTextSettings(whisperModelPath)
{
    EnableVad = false, // or keep EnableVad = true and set sttSettings.Vad.ModelPath = sileroVadModelPath;
};
var stt = new SpeechToTextBlock(sttSettings);
stt.OnSpeechRecognized += SpeechToText_OnSpeechRecognized;

player.Audio_Processing_AddBlock(stt); // before OpenAsync / PlayAsync
await player.OpenAsync(source);
await player.PlayAsync();
```

For playback, `Audio_Play` must be `true` for the audio chain to be built. Replacing the sink with a non-synced null renderer avoids speaker output and does not pace transcription to real-time playback.

## Troubleshooting

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| Block's events never fire, no warning logged | Block registered after the session was already running | Register with `Video_Processing_AddBlock`/`Audio_Processing_AddBlock` before `StartAsync` (`VideoCaptureCoreX`) or before `OpenAsync`/`PlayAsync` (`MediaPlayerCoreX`). |
| Log shows *"Cannot add a processing block while capture/playback is running..."* | Same as above — the call happened after the pipeline started building | Move the `Video_Processing_AddBlock`/`Audio_Processing_AddBlock` call earlier in your startup sequence. |
| `SpeechToTextBlock` never receives audio on `VideoCaptureCoreX` | No `Audio_Source` configured | An audio processing block requires a built audio chain — set `Audio_Source` (and, if you don't want speaker output, `Audio_OutputBlock` to a non-synced `NullRendererBlock`). |
| `SpeechToTextBlock` never receives audio on `MediaPlayerCoreX` | `Audio_Play` left at its default | Set `player.Audio_Play = true` before `OpenAsync`; the audio chain isn't built otherwise, regardless of registered audio blocks. |
| AI block's overlay doesn't appear in the recorded/streamed output, only the preview | Block registered on the wrong chain, or inserted after the point the engine builds outputs | Video AI blocks are inserted before the sample grabber/overlay/tee/renderer/outputs — see [Pipeline insertion order](#pipeline-insertion-order) — so this is usually a registration-timing issue, not a topology one. |
| Block instance reused across a second `StartAsync`/`PlayAsync` throws or behaves oddly | The engine already disposed the previous session's block instance | Create a fresh block instance (and re-subscribe to its events) for every new capture/playback session. |

## Frequently Asked Questions

### Do I need to rebuild a manual MediaBlocksPipeline to use AI blocks with VideoCaptureCoreX/MediaPlayerCoreX?

No — that's the point of this integration. `Video_Processing_AddBlock`/`Audio_Processing_AddBlock` insert the same AI block instances into the engine's existing internal pipeline; you don't construct or manage any `MediaBlocksPipeline` yourself.

### Can I add or remove AI blocks while capture/playback is running?

No — additions/removals/clears are ignored (and logged as a warning) once the pipeline build has started. Register everything you need before `StartAsync` / `OpenAsync`+`PlayAsync`, and start a new session with fresh block instances if the set of blocks needs to change.

### Do video AI blocks slow down recording or streaming outputs?

They add their own inference cost to the video chain, since they run in-line before the renderer and outputs. Use `FramesToSkip` (available on every video AI block's settings) and, where available, a GPU execution provider to keep that cost bounded.

### Can I combine multiple AI blocks — for example object detection and speech-to-text — in one session?

Yes — register one or more `IVideoProcessingBlock`s with `Video_Processing_AddBlock` and, separately, an `IAudioProcessingBlock` (like `SpeechToTextBlock`) with `Audio_Processing_AddBlock`, all before the session starts. Video and audio processing chains are independent.

## Demos

Every block covered on this page also has focused Media Blocks pipeline demos — see the **Demos** section on each block's own page ([OCR](../ocr/#demos), [Object detection](../object-detection/#demos), [Object analytics](../object-analytics/#demos), [Face recognition](../face-recognition/#demos), [License plate recognition](../license-plate-recognition/#demos), [Background removal](../background-removal/#demo), [Speech-to-text](../speech-to-text/#demos)).

The SDK's demo set additionally ships 16 demos built directly on `VideoCaptureCoreX` / `MediaPlayerCoreX` using the API on this page — Object Detection, OCR, Face Recognition, and Live Subtitles, each for both WPF and MAUI, on both the capture and playback engines (`Capture Object Detection X`, `Capture Object Detection X WPF`, `Capture OCR X`, `Capture OCR X WPF`, `Capture Face Recognition X`, `Capture Face Recognition X WPF`, `Capture Live Subtitles X`, `Capture Live Subtitles X WPF`, `Player Object Detection X`, `Player Object Detection X WPF`, `Player OCR X`, `Player OCR X WPF`, `Player Face Recognition X`, `Player Face Recognition X WPF`, `Player Live Subtitles X`, `Player Live Subtitles X WPF`). GitHub links will be added here once these demos are published to the public samples repository.

---END OF PAGE---


## Audio Sample Grabber for .NET - Capture Raw Audio Frames
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-effects/audio-sample-grabber/
**Description:** Capture and process real-time audio frames using Audio Sample Grabber with X-engines and Classic engines in .NET SDK applications.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, VideoEditCore, Windows, Editing, C#
**API:** AudioFrameBufferEventArgs, AudioSampleGrabberBlock

# Working with Audio Sample Grabber in .NET SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to Audio Sample Grabber

The Audio Sample Grabber is a powerful feature available across our .NET SDKs that enables developers to access raw audio frames directly from both live sources and media files. This capability opens up a wide range of possibilities for audio processing, analysis, and manipulation in your applications.

When working with audio processing, gaining access to individual audio frames is essential for tasks such as:

- Real-time audio visualization
- Custom audio effects processing
- Speech recognition integration
- Audio analysis and metrics
- Custom audio format conversion
- Sound detection algorithms

The `OnAudioFrameBuffer` event is the core mechanism that provides access to these raw audio frames. This event fires each time a new audio frame is available, giving you direct access to unmanaged memory containing the decoded audio data.

## How Audio Sample Grabber Works

The Audio Sample Grabber intercepts the audio pipeline during playback or capture, providing you with the raw audio data before it's rendered to the output device. This data is typically in PCM (Pulse Code Modulation) format, which is the standard format for uncompressed digital audio, but can occasionally be in IEEE floating-point format depending on the audio source.

Each time the `OnAudioFrameBuffer` event fires, it provides an `AudioFrameBufferEventArgs` object containing critical information about the audio frame:

- `Frame.Data`: An `IntPtr` pointing to the unmanaged memory block containing the raw audio data
- `Frame.DataSize`: The size of the audio data in bytes
- `Frame.Info`: A structure containing detailed information about the audio format, including:
- Channel count (mono, stereo, etc.)
- Sample rate (typically 44.1kHz, 48kHz, etc.)
- Bits per sample (16-bit, 24-bit, etc.)
- Audio format type (PCM, IEEE, etc.)
- Timestamp information
- Block alignment and other format-specific details

## Setting Up Audio Sample Grabber

The setup process varies slightly depending on whether you're using our newer X-engines or the Classic engines. Let's explore both approaches:

X-enginesClassic enginesMedia Blocks SDK

For X-engines, setting up the Audio Sample Grabber is straightforward. You simply need to create an event handler for the `OnAudioFrameBuffer` event:

```
VideoCapture1.OnAudioFrameBuffer += OnAudioFrameBuffer;
```

The X-engines architecture automatically enables audio sample grabbing when you subscribe to this event, with no additional configuration required.

When using Classic engines, you need to explicitly enable the Audio Sample Grabber functionality before creating the event handler:

```
VideoCapture1.Audio_Sample_Grabber_Enabled = true;
```

Then, as with X-engines, create your event handler:

```
VideoCapture1.OnAudioFrameBuffer += OnAudioFrameBuffer;
```

**Note**: The `Audio_Sample_Grabber_Enabled` property is not required for the VideoEditCore component, which has audio sample grabbing enabled by default.

The Media Blocks SDK also supports audio sample grabbing. Use the `AudioSampleGrabberBlock` component to capture audio frames.

```
private AudioSampleGrabberBlock _audioSampleGrabberSink;
```

Then, as with X-engines, create your event handler, and specify the audio format:

```
_audioSampleGrabberBlock = new AudioSampleGrabberBlock(VisioForge.Core.Types.X.AudioFormatX.S16LE);
_audioSampleGrabberBlock.OnAudioFrameBuffer += OnAudioFrameBuffer;
```

## Processing Audio Frames

Once you've set up the event handler, you can process the audio frames as they arrive. Here's a basic example of how to handle the `OnAudioFrameBuffer` event:

```
using VisioForge.Types;
using System.Diagnostics;

private void OnAudioFrameBuffer(object sender, AudioFrameBufferEventArgs e)
{
    // Log audio frame information
    Debug.WriteLine($"Audio frame: {e.Frame.DataSize} bytes; Format: {e.Frame.Info}");

    // Access to raw audio data through the unmanaged pointer
    IntPtr rawAudioData = e.Frame.Data;

    // Get audio format details. RAWBaseAudioInfo carries four fields:
    // Channels, SampleRate, BPS (bits-per-sample), Format (AudioFormat enum).
    int channelCount  = e.Frame.Info.Channels;
    int sampleRate    = e.Frame.Info.SampleRate;
    int bitsPerSample = e.Frame.Info.BPS;
    AudioFormat format = e.Frame.Info.Format;

    // Your custom audio processing code here
    // ...
}
```

## Working with Audio Data

### Converting Unmanaged Memory to Managed Arrays

While the `e.Frame.Data` provides a pointer to unmanaged memory, you often need to work with the data in a more convenient form. The `AudioFrame` class provides a helpful `GetDataArray()` method that returns a copy of the audio data as a byte array:

```
private void VideoCapture1_OnAudioFrameBuffer(object sender, AudioFrameBufferEventArgs e)
{
    // Get a managed copy of the audio data
    byte[] audioData = e.Frame.GetDataArray();

    // Now you can work with the data using standard C# array operations
    // ...
}
```

### Converting PCM Data to Samples

For many audio processing tasks, you'll want to convert the raw PCM bytes into actual audio sample values. Here's a helper method to convert a PCM byte array to an array of audio samples (assuming 16-bit samples):

```
private short[] ConvertBytesToSamples(byte[] audioData)
{
    short[] samples = new short[audioData.Length / 2];

    for (int i = 0; i < samples.Length; i++)
    {
        // Combine two bytes into one 16-bit sample
        samples[i] = (short)(audioData[i * 2] | (audioData[i * 2 + 1] << 8));
    }

    return samples;
}
```

### Handling Multi-Channel Audio

When working with stereo or multi-channel audio, the samples are typically interleaved. For a stereo stream, the data is arranged as: [Left0, Right0, Left1, Right1, ...]. You may want to separate these channels for processing:

```
private void ProcessStereoAudio(short[] samples, int channelCount)
{
    if (channelCount != 2) return;

    // Create arrays for each channel
    int samplesPerChannel = samples.Length / 2;
    short[] leftChannel = new short[samplesPerChannel];
    short[] rightChannel = new short[samplesPerChannel];

    // Separate the channels
    for (int i = 0; i < samplesPerChannel; i++)
    {
        leftChannel[i] = samples[i * 2];
        rightChannel[i] = samples[i * 2 + 1];
    }

    // Process each channel separately
    // ...
}
```

## Common Audio Processing Scenarios

### Audio Level Metering

A common use case for the Audio Sample Grabber is to implement audio level metering:

```
private void CalculateAudioLevel(short[] samples)
{
    double sum = 0;

    // Calculate RMS (Root Mean Square) value
    foreach (short sample in samples)
    {
        sum += sample * sample;
    }

    double rms = Math.Sqrt(sum / samples.Length);

    // Convert to decibels
    double db = 20 * Math.Log10(rms / 32768);

    // Update UI with the level (you'll need to invoke if on a different thread)
    Debug.WriteLine($"Audio level: {db} dB");
}
```

### Real-time FFT for Spectrum Analysis

For frequency spectrum analysis, you might want to perform an FFT (Fast Fourier Transform) on the audio data:

```
// Note: You'll need a library for FFT calculation
// This is a simplified example
private void PerformFFTAnalysis(short[] samples)
{
    // Typically you would use a library like Math.NET Numerics
    // Convert samples to complex numbers
    Complex[] complex = samples.Select(s => new Complex(s, 0)).ToArray();

    // Perform FFT (pseudocode)
    // Complex[] fftResult = FFT.Forward(complex);

    // Process FFT results
    // ...
}
```

## Performance Considerations

When working with the Audio Sample Grabber, keep these performance considerations in mind:

1. **Minimize Processing Time**: The `OnAudioFrameBuffer` event is called on the audio processing thread. Long-running operations can cause audio glitches.
2. **Consider Thread Safety**: If you need to update UI elements or interact with other components, use proper thread synchronization methods.
3. **Avoid Memory Allocations**: Frequent memory allocations in the event handler can lead to garbage collection pauses. Reuse arrays where possible.
4. **Buffer Copying**: The `GetDataArray()` method creates a copy of the audio data. For very high-performance scenarios, consider working directly with the unmanaged pointer.

## Conclusion

The Audio Sample Grabber provides a powerful way to access and process raw audio data in real-time from both live sources and media files. By leveraging this functionality, you can implement sophisticated audio processing features in your applications, from simple level metering to complex audio analysis and effects processing.

Whether you're building a professional audio application, implementing audio visualization, or integrating with speech recognition services, the Audio Sample Grabber gives you the raw data you need to bring your audio processing ideas to life.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Audio Effects in C# and .NET - EQ, Reverb, Filters, and More
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-effects/
**Description:** Apply real-time audio effects in C# and .NET with VisioForge SDKs. Equalizer, reverb, echo, noise reduction, pitch shift, and 30+ effects.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Playback, Streaming, Editing
**API:** VolumeAudioEffect, Equalizer10AudioEffect, VideoCaptureCoreX, MediaPlayerCoreX, CompressorExpanderAudioEffect

# Real-Time Audio Effects for .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

VisioForge Media Framework provides over 30 audio effects for real-time audio processing in C# and .NET applications. Built on GStreamer, the cross-platform effects include equalizers, reverb, echo, dynamic compression, filters, pitch shifting, AI-based noise reduction, and more — all running on Windows, macOS, Linux, iOS, and Android.

## SDKs and Platforms

### Cross-Platform Effects

- **SDKs**: Media Blocks SDK, Video Capture SDK (VideoCaptureCoreX), Media Player SDK (MediaPlayerCoreX)
- **Platforms**: Windows, macOS, Linux, iOS, Android
- **Namespace**: `VisioForge.Core.Types.X.AudioEffects`

### Classic DSP Effects

- **SDKs**: Video Capture SDK (VideoCaptureCore), Media Player SDK (MediaPlayerCore), Video Edit SDK (VideoEditCore)
- **Platforms**: Windows only
- **Namespace**: `VisioForge.Core.DSP`

### DirectSound Effects

- **SDKs**: Video Capture SDK, Media Player SDK, Video Edit SDK (Classic cores)
- **Platforms**: Windows only
- **Namespace**: `VisioForge.Core.Types.X._Windows.AudioEffects`

For detailed parameters and properties of each effect, see [Audio Effects Reference](reference/).

## Effect Categories

### Volume and Dynamics

- **VolumeAudioEffect** — Basic volume control with mute functionality
- **AmplifyAudioEffect** — Audio signal amplification with clipping control
- **CompressorExpanderAudioEffect** — Dynamic range compression and expansion
- **DynamicAmplifyAudioEffect** — Adaptive gain control with attack/release times

### Equalization

- **Equalizer10AudioEffect** — 10-band graphic equalizer with fixed frequencies
- **EqualizerParametricAudioEffect** — Parametric equalizer with configurable bands
- **TrebleEnhancerAudioEffect** — High-frequency boost
- **TrueBassAudioEffect** — Low-frequency boost

### Filters

- **HighPassAudioEffect** — High-pass filter for removing low frequencies
- **LowPassAudioEffect** — Low-pass filter for removing high frequencies
- **BandPassAudioEffect** — Band-pass filter for specific frequency ranges
- **NotchAudioEffect** — Notch filter for removing specific frequencies
- **ChebyshevLimitAudioEffect** — Chebyshev low/high-pass filters with sharp cutoffs
- **ChebyshevBandPassRejectAudioEffect** — Chebyshev band-pass/reject filters

### Spatial and Stereo

- **BalanceAudioEffect** — Stereo balance control (pan left/right)
- **WideStereoAudioEffect** — Stereo width enhancement
- **Sound3DAudioEffect** — 3D spatial audio effects
- **HRTFRenderAudioEffect** — Head-Related Transfer Function spatial audio
- **PhaseInvertAudioEffect** — Phase inversion for polarity correction

### Time-Based Effects

- **EchoAudioEffect** — Echo and delay effects
- **RSAudioEchoAudioEffect** — Enhanced echo with advanced controls
- **ReverberationAudioEffect** — Room reverberation (Freeverb algorithm)
- **FadeAudioEffect** — Fade in/out volume automation

### Modulation Effects

- **PhaserAudioEffect** — Phaser effect with LFO modulation
- **FlangerAudioEffect** — Flanging effect with delay modulation

### Pitch and Tempo

- **PitchShiftAudioEffect** — Pitch shifting without tempo change
- **ScaleTempoAudioEffect** — Tempo change without pitch shift

### Special Effects

- **KaraokeAudioEffect** — Vocal removal for karaoke
- **RemoveSilenceAudioEffect** — Automatic silence detection and removal
- **CsoundAudioEffect** — Advanced Csound-based audio processing

### Noise Reduction and Measurement

- **AudioRNNoiseAudioEffect** — AI-based noise reduction using RNN
- **AudioLoudNormAudioEffect** — EBU R128 loudness normalization
- **EbuR128LevelAudioEffect** — EBU R128 loudness measurement

### Channel Management

- **ChannelOrderAudioEffect** — Channel remapping and routing
- **DownMixAudioEffect** — Multi-channel to stereo/mono downmixing

### DirectSound Effects (Windows Only, Classic SDKs)

- **DS Chorus** — Multiple delayed and modulated copies
- **DS Distortion** — Audio distortion/overdrive
- **DS Gargle** — Gargling/tremolo modulation
- **DS Reverb (I3DL2)** — Professional reverb with environmental modeling
- **DS Waves Reverb** — Simplified reverb

## GStreamer Elements

All cross-platform audio effects are built on top of GStreamer multimedia framework. Each effect wraps one or more GStreamer elements:

| Category | GStreamer Elements |
| --- | --- |
| Volume/Dynamics | volume, audioamplify, audiodynamic |
| Equalization | equalizer-10bands, equalizer-nbands |
| Filters | audiocheblimit, audiochebband, audioiirfilter |
| Spatial | audiopanorama, stereo, hrtfrender |
| Time-Based | audioecho, rsaudioecho, freeverb |
| Modulation | Custom phaser/flanger implementations |
| Pitch/Tempo | scaletempo, pitch (SoundTouch) |
| Special | audiokaraoke, csoundfilter, removesilence |
| Noise Reduction | audiornnoise, audioloudnorm, ebur128level |
| Channels | audioconvert, custom routing |

## Common Usage Patterns

### Adding Effects (Cross-Platform SDKs)

```
// Create an audio effect
var volumeEffect = new VolumeAudioEffect(1.5); // 150% volume

// VideoCaptureCoreX / MediaPlayerCoreX
core.Audio_Effects_AddOrUpdate(volumeEffect);
```

### Combining Multiple Effects

Effects are processed in the order they are added:

```
// Create a processing chain
core.Audio_Effects_AddOrUpdate(new HighPassAudioEffect(80));           // Remove rumble
core.Audio_Effects_AddOrUpdate(new CompressorExpanderAudioEffect());   // Compress dynamics
core.Audio_Effects_AddOrUpdate(new Equalizer10AudioEffect(levels));    // EQ adjustments
core.Audio_Effects_AddOrUpdate(new ReverberationAudioEffect());        // Add reverb
```

### Real-Time Parameter Updates

Most effects support real-time parameter changes:

```
var volumeEffect = new VolumeAudioEffect(1.0);
core.Audio_Effects_AddOrUpdate(volumeEffect);

// Later, during playback:
volumeEffect.Level = 0.5; // Reduce volume to 50%
volumeEffect.Mute = true; // Mute audio
core.Audio_Effects_AddOrUpdate(volumeEffect); // Apply changes
```

### Media Blocks SDK Usage

For Media Blocks SDK pipeline-based usage with dedicated audio effect blocks, see [Audio Processing and Effect Blocks](../../mediablocks/AudioProcessing/).

## Performance Considerations

- **CPU Usage**: Complex effects like reverberation, Csound, and multiple equalizers can be CPU-intensive
- **Effect Order**: Place computationally expensive effects after simpler ones to reduce processing load
- **Real-Time Processing**: All effects are designed for real-time audio streaming

## Frequently Asked Questions

 What audio effects are available in VisioForge .NET SDKs?

VisioForge provides 30+ audio effects including volume control, 10-band and parametric equalizers, reverb, echo, compressor/expander, high/low/band-pass filters, pitch shift, noise reduction (RNN-based), karaoke vocal removal, 3D spatial audio, and more. All cross-platform effects work on Windows, macOS, Linux, iOS, and Android.

  How do I add audio effects to my C# application?

Create an effect instance and add it using `Audio_Effects_AddOrUpdate()`. For example:

```
// 10-band EQ: all bands at 0 dB (neutral)
var eq = new Equalizer10AudioEffect(new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 });
core.Audio_Effects_AddOrUpdate(eq);
```

Effects can be added, updated, and removed during playback. For Media Blocks SDK, use the `AudioEffectsBlock`.

  Can I chain multiple audio effects together?

Yes. Effects are processed in the order they are added. You can create complex processing chains combining filters, EQ, compression, reverb, and other effects. Each effect processes the audio output of the previous one.

  Do audio effects work in real-time during playback?

Yes. All VisioForge audio effects support real-time parameter changes. You can adjust volume, EQ bands, reverb levels, and other parameters while audio is playing without interrupting the stream.

  What is the difference between cross-platform and DirectSound effects?

Cross-platform effects (namespace `VisioForge.Core.Types.X.AudioEffects`) work on all platforms using GStreamer. DirectSound effects are Windows-only and available in the classic SDK cores. Cross-platform effects cover the same functionality and more.

## See Also

- [Audio Effects Reference](reference/)
- [Audio Sample Grabber](audio-sample-grabber/)
- [Audio Encoders](../audio-encoders/)
- [Audio Processing Blocks (Media Blocks SDK)](../../mediablocks/AudioProcessing/)

---END OF PAGE---


## Audio Effects API Reference for .NET - Parameters & Examples
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-effects/reference/
**Description:** API reference for 30+ audio effects in VisioForge .NET SDKs. Volume, EQ, compressor, reverb, echo, filters, pitch shift, and noise reduction with C# examples.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaPlayerCoreX, VideoCaptureCoreX, VideoEditCore, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Playback, Streaming, Editing, Effects, C#
**API:** VolumeAudioEffect, Equalizer10AudioEffect, BandPassAudioEffect, BalanceAudioEffect, WideStereoAudioEffect

# Audio Effects API Reference

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Complete parameter reference for all audio effects available in VisioForge .NET SDKs. Each cross-platform effect wraps a GStreamer element and supports real-time parameter changes from C# code during playback. Cross-platform effects work on Windows, macOS, Linux, iOS, and Android.

For an overview of effect categories and usage patterns, see [Audio Effects](../).

## Volume and Dynamics Effects

### VolumeAudioEffect

**GStreamer Element**: `volume`

**Purpose**: Control audio volume level with optional mute.

**Parameters**:

- `Level` (double): Volume multiplier
  - Range: 0.0 to unlimited
  - Default: 1.0 (100%)
  - Examples: 0.5 = 50%, 2.0 = 200%
- `Mute` (bool): Mute audio output
  - Default: false

**Usage**:

```
var effect = new VolumeAudioEffect(1.5); // 150% volume
effect.Mute = true; // Temporarily mute
```

---

### AmplifyAudioEffect

**GStreamer Element**: `audioamplify`

**Purpose**: Amplify audio with clipping control.

**Parameters**:

- `Level` (double): Amplification level
  - Range: 1.0 to 10.0
  - Default: 1.0
- `ClippingMethod` (AmplifyClippingMethod): How to handle peaks
  - Options: Normal, WrapNegative, WrapPositive, NoClip
  - Default: Normal

**Usage**:

```
var effect = new AmplifyAudioEffect(2.0);
effect.ClippingMethod = AmplifyClippingMethod.NoClip;
```

---

### CompressorExpanderAudioEffect

**GStreamer Element**: `audiodynamic`

**Purpose**: Dynamic range compression or expansion.

**Parameters**:

- `Threshold` (double): Activation threshold
  - Range: 0.0 to 1.0
  - Default: 0.0
- `Ratio` (double): Compression/expansion ratio
  - Range: 1.0+
  - Default: 1.0
  - Typical: 2:1 to 10:1 for compression
- `Mode` (AudioCompressorMode): Compressor or Expander
  - Default: Compressor
- `Characteristics` (AudioDynamicCharacteristics): HardKnee or SoftKnee
  - Default: SoftKnee

**Usage**:

```
var effect = new CompressorExpanderAudioEffect();
effect.Threshold = 0.5;
effect.Ratio = 4.0; // 4:1 compression
effect.Characteristics = AudioDynamicCharacteristics.SoftKnee;
```

---

### DynamicAmplifyAudioEffect

**Purpose**: Adaptive gain control.

**Parameters**:

- `AttackTime` (uint): Response time in ms
  - Typical: 10-100 ms
- `MaxAmplification` (uint): Maximum gain
  - 10000 = 1x (no change)
  - 20000 = 2x amplification
  - Default: 10000
- `ReleaseTime` (TimeSpan): Time before resuming amplification
  - Typical: 100-1000 ms

**Usage**:

```
var effect = new DynamicAmplifyAudioEffect(50, 20000, TimeSpan.FromMilliseconds(500));
```

---

## Equalization Effects

### Equalizer10AudioEffect

**GStreamer Element**: `equalizer-10bands`

**Purpose**: 10-band graphic equalizer with fixed frequencies.

**Frequency Bands**:

1. 29 Hz (Sub-bass)
2. 59 Hz (Bass)
3. 119 Hz (Bass)
4. 237 Hz (Low midrange)
5. 474 Hz (Midrange)
6. 947 Hz (Midrange)
7. 1889 Hz (Upper midrange)
8. 3770 Hz (Presence)
9. 7523 Hz (Brilliance)
10. 15011 Hz (Air)

**Parameters**:

- `Levels` (double[]): Gain for each band in dB
  - Range per band: -24 to +12 dB
  - Array must contain exactly 10 values

**Usage**:

```
var levels = new double[] {
    3.0,   // 29 Hz: +3 dB
    2.0,   // 59 Hz: +2 dB
    0.0,   // 119 Hz: 0 dB (no change)
    -2.0,  // 237 Hz: -2 dB
    0.0,   // 474 Hz
    0.0,   // 947 Hz
    1.0,   // 1889 Hz: +1 dB
    2.0,   // 3770 Hz: +2 dB
    3.0,   // 7523 Hz: +3 dB
    4.0    // 15011 Hz: +4 dB
};
var effect = new Equalizer10AudioEffect(levels);
```

---

### EqualizerParametricAudioEffect

**GStreamer Element**: `equalizer-nbands`

**Purpose**: Parametric equalizer with configurable bands.

**Parameters**:

- `Bands` (ParametricEqualizerBand[]): Array of bands
  - Count: 1 to 64 bands
  - Each band: Frequency, Gain, Width (bandwidth in Hz)

**Usage**:

```
var effect = new EqualizerParametricAudioEffect(3);
effect.Bands[0].Frequency = 100;  // Hz
effect.Bands[0].Gain = -6;        // dB
effect.Bands[0].Width = 1.0f;     // bandwidth
// Configure other bands...
effect.Update(); // Apply changes
```

---

### TrebleEnhancerAudioEffect

**Purpose**: Boost high frequencies.

**Parameters**:

- `Frequency` (int): Starting frequency in Hz
  - Typical: 4000-8000 Hz
  - Frequencies above this are boosted
- `Volume` (ushort): Boost amount
  - Range: 0 to 10000
  - 0 = no effect

**Usage**:

```
var effect = new TrebleEnhancerAudioEffect(6000, 5000);
```

---

### TrueBassAudioEffect

**Purpose**: Boost low frequencies.

**Parameters**:

- `Frequency` (int): Upper frequency limit in Hz
  - Typical: 100-300 Hz
  - Frequencies below this are boosted
- `Volume` (ushort): Boost amount
  - Range: 0 to 10000
  - 0 = no effect

**Usage**:

```
var effect = new TrueBassAudioEffect(150, 5000);
```

---

## Filter Effects

### HighPassAudioEffect

**Implementation**: Custom DSP (IIR high-pass filter)

**Purpose**: Remove low frequencies.

**Parameters**:

- `CutOff` (uint): Cutoff frequency in Hz
  - Frequencies below are attenuated
  - Typical: 80-200 Hz for voice, 40 Hz for music

**Common Frequencies**:

- 20-40 Hz: Sub-sonic removal
- 60-80 Hz: Rumble removal
- 100-150 Hz: Clarity improvement

**Usage**:

```
var effect = new HighPassAudioEffect(100); // Remove frequencies below 100 Hz
```

---

### LowPassAudioEffect

**Implementation**: Custom DSP (IIR low-pass filter)

**Purpose**: Remove high frequencies.

**Parameters**:

- `CutOff` (uint): Cutoff frequency in Hz
  - Frequencies above are attenuated
  - Typical: 8000-12000 Hz for hiss removal

**Common Frequencies**:

- 15000-20000 Hz: Gentle air reduction
- 8000-10000 Hz: Warmth
- 3000-5000 Hz: Telephone effect

**Usage**:

```
var effect = new LowPassAudioEffect(10000); // Remove frequencies above 10 kHz
```

---

### BandPassAudioEffect

**Implementation**: Custom DSP (state-variable filter)

**Purpose**: Allow only specific frequency range.

**Parameters**:

- `CutOffHigh` (float): Upper frequency boundary in Hz
- `CutOffLow` (float): Lower frequency boundary in Hz

**Usage**:

```
// Constructor: BandPassAudioEffect(cutOffHigh, cutOffLow)
var effect = new BandPassAudioEffect(5000, 300); // Allow 300-5000 Hz
```

---

### NotchAudioEffect

**Implementation**: Custom DSP (band-reject filter)

**Purpose**: Remove specific frequency.

**Parameters**:

- `CutOff` (uint): Center frequency to remove in Hz
  - Typical: 50/60 Hz for hum removal

**Usage**:

```
var effect = new NotchAudioEffect(60); // Remove 60 Hz hum
```

---

### ChebyshevLimitAudioEffect

**GStreamer Element**: `audiocheblimit`

**Purpose**: Sharp low/high-pass filtering with ripple control.

**Parameters**:

- `CutOffFrequency` (float): Cutoff frequency in Hz
- `Mode` (ChebyshevLimitAudioEffectMode): LowPass or HighPass
- `Poles` (int): Filter order (2-8 typical)
  - Default: 4
  - More poles = steeper rolloff
- `Ripple` (float): Passband ripple in dB
  - Default: 0.25
- `Type` (int): Chebyshev type (1 or 2)
  - Default: 1

**Usage**:

```
var effect = new ChebyshevLimitAudioEffect();
effect.CutOffFrequency = 100;
effect.Mode = ChebyshevLimitAudioEffectMode.HighPass;
effect.Poles = 6;
```

---

### ChebyshevBandPassRejectAudioEffect

**GStreamer Element**: `audiochebband`

**Purpose**: Sharp band-pass or band-reject filtering.

**Parameters**:

- `LowerFrequency` (float): Lower band boundary in Hz
- `UpperFrequency` (float): Upper band boundary in Hz
- `Mode` (ChebyshevBandPassRejectAudioEffectMode): BandPass or BandReject
- `Poles` (int): Filter order (2-8 typical)
  - Default: 4
- `Ripple` (float): Passband ripple in dB
  - Default: 0.25
- `Type` (int): Chebyshev type (1 or 2)
  - Default: 1

**Usage**:

```
var effect = new ChebyshevBandPassRejectAudioEffect();
effect.LowerFrequency = 300;
effect.UpperFrequency = 3000;
effect.Mode = ChebyshevBandPassRejectAudioEffectMode.BandPass;
```

---

## Spatial and Stereo Effects

### BalanceAudioEffect

**GStreamer Element**: `audiopanorama`

**Purpose**: Stereo balance (pan) control.

**Parameters**:

- `Level` (double): Balance position
  - Range: -1.0 to 1.0
  - -1.0 = full left
  - 0.0 = center
  - 1.0 = full right
  - Default: 0.0

**Usage**:

```
var effect = new BalanceAudioEffect(-0.5); // Pan 50% left
```

---

### WideStereoAudioEffect

**GStreamer Element**: `stereo`

**Purpose**: Enhance stereo width.

**Parameters**:

- `Level` (float): Widening intensity
  - Range: 0.0+
  - Default: 0.01
  - Typical: 0.01 to 1.0
  - Higher values = wider stereo field

**Usage**:

```
var effect = new WideStereoAudioEffect();
effect.Level = 0.5f;
```

---

### Sound3DAudioEffect

**Purpose**: 3D spatial audio simulation.

**Parameters**:

- `Value` (uint): Spatial amplification
  - Range: 1 to 20000
  - 1000 = neutral (disabled)
  - < 1000 = narrower stereo
  - > 1000 = wider stereo
  - > 10000 may distort

**Usage**:

```
var effect = new Sound3DAudioEffect(2000); // 2x spatial width
```

---

### PhaseInvertAudioEffect

**Purpose**: Invert audio phase by 180 degrees.

**Parameters**: None.

**Usage**:

```
var effect = new PhaseInvertAudioEffect();
```

---

### HRTFRenderAudioEffect

**GStreamer Element**: `hrtfrender` (rsaudiofx)

**Purpose**: HRTF-based 3D spatial audio.

**Parameters**:

- `HrirFile` (string): Path to an hrtfrender HRIR binary (not a SOFA file)
- `InterpolationSteps` (ulong): Interpolation quality
  - Default: 8
- `BlockLength` (ulong): Processing block size
  - Default: 512
- `DistanceGain` (float): Distance attenuation factor
  - Default: 1.0

**Usage**:

Download a compatible HRIR binary from [hrir\_sphere\_builder](https://github.com/mrDIMAS/hrir_sphere_builder/tree/master/hrtf_base/IRCAM).

```
var effect = new HRTFRenderAudioEffect("IRC_1002_C.bin");
effect.InterpolationSteps = 16; // Higher quality
```

---

## Time-Based Effects

### EchoAudioEffect

**GStreamer Element**: `audioecho`

**Purpose**: Echo and delay effects.

**Parameters**:

- `Delay` (TimeSpan): Echo delay time
  - Must not exceed MaxDelay
- `MaxDelay` (TimeSpan): Maximum delay buffer
  - Must be >= Delay
  - Set before starting playback
- `Intensity` (float): Echo volume
  - Range: 0.0 to 1.0
  - Default: 1.0
- `Feedback` (float): Echo repetition amount
  - Range: 0.0 to 1.0
  - Default: 0.0
  - Higher = more echoes

**Usage**:

```
var delay = TimeSpan.FromMilliseconds(500);
var effect = new EchoAudioEffect(delay);
effect.Intensity = 0.7f;
effect.Feedback = 0.4f;
```

---

### RSAudioEchoAudioEffect

**GStreamer Element**: `rsaudioecho` (rsaudiofx)

**Purpose**: Enhanced echo with advanced controls.

**Parameters**:

- `Delay` (TimeSpan): Echo delay time
- `MaxDelay` (TimeSpan): Maximum delay buffer
- `Intensity` (double): Echo intensity
  - Range: 0.0 to 1.0
- `Feedback` (double): Feedback amount
  - Range: 0.0 to 1.0

**Usage**:

```
var effect = new RSAudioEchoAudioEffect();
effect.Delay = TimeSpan.FromMilliseconds(750);
effect.Intensity = 0.6;
effect.Feedback = 0.3;
```

---

### ReverberationAudioEffect

**GStreamer Element**: `freeverb`

**Purpose**: Room reverberation simulation.

**Parameters**:

- `RoomSize` (float): Virtual room size
  - Range: 0.0 to 1.0
  - Default: 0.5
  - Larger = longer reverb tail
- `Damping` (float): High-frequency absorption
  - Range: 0.0 to 1.0
  - Default: 0.2
  - Higher = darker reverb
- `Level` (float): Wet/dry mix
  - Range: 0.0 to 1.0
  - Default: 0.5
  - 0 = dry, 1 = wet
- `Width` (float): Stereo width
  - Range: 0.0 to 1.0
  - Default: 1.0
  - 0 = mono, 1 = full stereo

**Usage**:

```
var effect = new ReverberationAudioEffect();
effect.RoomSize = 0.8f; // Large room
effect.Damping = 0.3f;
effect.Level = 0.4f;
```

---

### FadeAudioEffect

**Purpose**: Volume fade in/out automation.

**Parameters**:

- `StartVolume` (uint): Volume at start time
- `StopVolume` (uint): Volume at stop time
- `StartTime` (TimeSpan): When fade begins
- `StopTime` (TimeSpan): When fade completes

**Usage**:

```
// Fade out over 3 seconds starting at 10 seconds
var effect = new FadeAudioEffect(
    100, 0,
    TimeSpan.FromSeconds(10),
    TimeSpan.FromSeconds(13)
);
```

---

## Modulation Effects

### PhaserAudioEffect

**Purpose**: Phaser effect with LFO modulation.

**Parameters**:

- `Depth` (byte): Sweep depth
  - Range: 0 to 255
- `DryWetRatio` (byte): Mix ratio
  - Range: 0 to 255
  - 0 = dry, 255 = wet
- `Feedback` (byte): Resonance
  - Range: -100 to 100
- `Frequency` (float): LFO speed in Hz
  - Typical: 0.1 to 5 Hz
- `Stages` (byte): Number of stages
  - Range: 2 to 24 recommended
  - More = stronger effect
- `StartPhase` (float): LFO start phase in radians

**Usage**:

```
var effect = new PhaserAudioEffect(
    150,      // depth
    128,      // 50% mix
    50,       // feedback
    0.5f,     // 0.5 Hz LFO
    6,        // 6 stages
    0f        // start phase
);
```

---

### FlangerAudioEffect

**Purpose**: Flanging effect with delay modulation.

**Parameters**:

- `Delay` (TimeSpan): Base delay time
  - Typical: 1-15 ms
- `Frequency` (float): LFO speed in Hz
  - Typical: 0.1 to 5 Hz
- `PhaseInvert` (bool): Invert delayed signal phase
  - Default: false

**Usage**:

```
var effect = new FlangerAudioEffect(
    TimeSpan.FromMilliseconds(5),
    1.0f,
    false
);
```

---

## Pitch and Tempo Effects

### PitchShiftAudioEffect

**Purpose**: Change pitch without changing speed.

**Parameters**:

- `Pitch` (float): Pitch shift ratio
  - 1.0 = no change
  - 2.0 = one octave up
  - 0.5 = one octave down
  - Typical range: 0.5 to 2.0

**Musical Intervals**:

- 0.5 = -12 semitones
- 1.059 = +1 semitone
- 1.122 = +2 semitones
- 2.0 = +12 semitones

**Usage**:

```
var effect = new PitchShiftAudioEffect(1.5f); // Up by a fifth
```

---

### ScaleTempoAudioEffect

**GStreamer Element**: `scaletempo`

**Purpose**: Change tempo without changing pitch (WSOLA algorithm).

**Parameters**:

- `Rate` (double): Playback speed
  - 1.0 = normal
  - 2.0 = double speed
  - 0.5 = half speed
  - Default: 1.0
- `Stride` (TimeSpan): Processing stride
  - Default: 30 ms
- `Overlap` (double): Overlap percentage
  - Range: 0.0 to 1.0
  - Default: 0.2
- `Search` (TimeSpan): Search window
  - Default: 14 ms

**Usage**:

```
var effect = new ScaleTempoAudioEffect(1.5); // 1.5x speed
```

---

## Special Effects

### KaraokeAudioEffect

**GStreamer Element**: `audiokaraoke`

**Purpose**: Remove center-panned vocals.

**Parameters**:

- `FilterBand` (float): Center frequency in Hz
  - Default: 220 Hz
  - Typical: 80-400 Hz
- `FilterWidth` (float): Filter bandwidth in Hz
  - Default: 100 Hz
- `Level` (float): Effect intensity
  - Range: 0.0 to 1.0
  - Default: 1.0
- `MonoLevel` (float): Mono channel level
  - Range: 0.0 to 1.0
  - Default: 1.0

**Usage**:

```
var effect = new KaraokeAudioEffect();
effect.FilterBand = 250f;
effect.Level = 1.0f;
```

---

### RemoveSilenceAudioEffect

**Purpose**: Automatically remove silent sections.

**Parameters**:

- `Threshold` (double): Silence detection threshold, a linear amplitude
  - Range: 0.0 to 1.0, converted to the decibels the element uses (`20 * log10(value)`, clamped to -70..70 dB)
  - Default: 0.001 (-60 dB, the element's own default)
  - Lower = less audio is treated as silence. 1.0 is full scale and classifies everything as silence
- `Squash` (bool): what happens to the timeline after silence is dropped
  - true = pull the surviving buffers back to close the gap
  - false = keep their original timestamps
  - Default: false (keeps the original timeline, so audio stays in sync with video)

**Usage**:

```
var effect = new RemoveSilenceAudioEffect("silence-remover");
effect.Threshold = 0.001;
effect.Squash = false;
```

---

### CsoundAudioEffect

**GStreamer Element**: `csoundfilter`

**Purpose**: Csound-based audio programming.

**Platforms**: Windows, macOS, Linux (requires Csound installation).

**Parameters**:

- `CsdText` (string): Csound CSD document as text
- `Location` (string): Path to CSD file
- `Loop` (bool): Loop score continuously
  - Default: false
- `ScoreOffset` (double): Start time in seconds
  - Default: 0.0

**Usage**:

```
var csd = @"<CsoundSynthesizer>
<CsInstruments>
; Your Csound code here
</CsInstruments>
<CsScore>
; Your score here
</CsScore>
</CsoundSynthesizer>";

var effect = new CsoundAudioEffect("my-csound", csd);
effect.Loop = false;
```

---

## Noise Reduction and Measurement

### AudioRNNoiseAudioEffect

**GStreamer Element**: `audiornnoise` (rsaudiofx)

**Purpose**: AI-based noise reduction.

**Parameters**:

- `VadThreshold` (float): Voice activity detection threshold
  - Range: 0.0 to 1.0
  - Default: 0.0
  - Higher = more sensitive to voice

**Usage**:

```
var effect = new AudioRNNoiseAudioEffect();
effect.VadThreshold = 0.5f;
```

---

### AudioLoudNormAudioEffect

**GStreamer Element**: `audioloudnorm` (rsaudiofx)

**Purpose**: EBU R128 loudness normalization.

**Parameters**:

- `LoudnessTarget` (double): Target loudness in LUFS
  - Range: -70.0 to -5.0
  - Default: -24.0
- `LoudnessRangeTarget` (double): Target range in LU
  - Range: 1.0 to 20.0
  - Default: 7.0
- `MaxTruePeak` (double): Max true peak in dbTP
  - Range: -9.0 to 0.0
  - Default: -2.0
- `Offset` (double): Offset gain in LU
  - Range: -99.0 to 99.0
  - Default: 0.0

**Usage**:

```
var effect = new AudioLoudNormAudioEffect();
effect.LoudnessTarget = -16.0; // Streaming standard
effect.MaxTruePeak = -1.0;
```

---

### EbuR128LevelAudioEffect

**GStreamer Element**: `ebur128level` (rsaudiofx)

**Purpose**: EBU R128 loudness measurement.

**Parameters**:

- `Mode` (EbuR128Mode): Measurement types to calculate
  - Options: Momentary, ShortTerm, Global, LoudnessRange, SamplePeak, TruePeak, All
  - Default: All
- `PostMessages` (bool): Post measurement messages
  - Default: true
- `Interval` (TimeSpan): Measurement update interval
  - Default: 1 second

**Usage**:

```
var effect = new EbuR128LevelAudioEffect();
effect.Mode = EbuR128Mode.All;
effect.Interval = TimeSpan.FromSeconds(0.5);
```

---

## Channel Management

### ChannelOrderAudioEffect

**Purpose**: Remap audio channels.

**Parameters**:

- `Orders` (byte[,]): 2D array of [target, source] pairs
  - Format: [[target0, source0], [target1, source1], ...]
  - Channels are zero-indexed

**Usage**:

```
// Swap left and right channels
var orders = new byte[2, 2] {
    { 0, 1 },  // Output channel 0 gets input channel 1 (right)
    { 1, 0 }   // Output channel 1 gets input channel 0 (left)
};
var effect = new ChannelOrderAudioEffect(orders);
```

---

### DownMixAudioEffect

**Implementation**: Custom DSP (channel averaging)

**Purpose**: Reduce channel count (e.g., 5.1 to stereo).

**Parameters**: None (automatic downmixing).

**Usage**:

```
var effect = new DownMixAudioEffect();
```

---

## DirectSound Effects (Classic SDKs, Windows Only)

The following effects are available only in Video Capture SDK (VideoCaptureCore), Media Player SDK (MediaPlayerCore), and Video Edit SDK (VideoEditCore) on Windows. They use DirectSound/DirectX technology.

### DS Chorus

Creates a chorus effect with multiple delayed and modulated copies.

**Properties**:

- **WetDryMix** (float): Dry/wet mix (0-100)
- **Depth** (float): Modulation depth (0-100)
- **Feedback** (float): Feedback amount (0-100)
- **Frequency** (float): LFO frequency (0-10 Hz)
- **Waveform**: Sine or Triangle
- **Delay** (float): Base delay (0-20 ms)
- **Phase**: Phase relationship for stereo (-180 to 180 degrees)

**Usage**:

```
// Signature: (int streamIndex, string name, float delay, float depth,
//             float feedback, float frequency, DSChorusPhase phase,
//             DSChorusWaveForm waveformTriangle, float wetDryMix)
videoCaptureCore.Audio_Effects_DS_Chorus(0, "chorus",
    delay: 16, depth: 25, feedback: 25, frequency: 1.1f,
    phase: DSChorusPhase.Phase90, waveformTriangle: DSChorusWaveForm.Sine,
    wetDryMix: 50);
```

---

### DS Distortion

Adds distortion/overdrive to audio signal.

**Properties**:

- **Gain** (float): Pre-distortion gain (-60 to 0 dB)
- **Edge** (float): Distortion amount (0-100%)
- **PostEQCenterFrequency** (float): Post-EQ center (100-8000 Hz)
- **PostEQBandwidth** (float): Post-EQ bandwidth (100-8000 Hz)
- **PreLowpassCutoff** (float): Pre-distortion lowpass (100-8000 Hz)

**Usage**:

```
// Signature: (int streamIndex, string name, float edge, float gain,
//             float postEQBandwidth, float postEQCenterFrequency,
//             float preLowpassCutOff)
videoCaptureCore.Audio_Effects_DS_Distortion(0, "distortion",
    edge: 50, gain: -18, postEQBandwidth: 2400,
    postEQCenterFrequency: 2400, preLowpassCutOff: 8000);
```

---

### DS Gargle

Creates a gargling/tremolo modulation effect.

**Properties**:

- **RateHz** (int): Modulation rate (1-1000 Hz)
- **WaveForm**: Triangle or Square wave

**Usage**:

```
// Signature: (int streamIndex, string name, int rateHz, DSGargleWaveForm waveForm)
videoCaptureCore.Audio_Effects_DS_Gargle(0, "gargle",
    rateHz: 20, waveForm: DSGargleWaveForm.Triangle);
```

---

### DS Reverb (I3DL2)

Professional reverb with environmental modeling.

**Properties**:

- **Room** (int): Room effect level (-10000 to 0 mB)
- **RoomHF** (int): High-frequency room effect (-10000 to 0 mB)
- **RoomRolloffFactor** (float): Rolloff factor (0 to 10)
- **DecayTime** (float): Decay time (0.1 to 20 seconds)
- **DecayHFRatio** (float): HF decay ratio (0.1 to 2.0)
- **Reflections** (int): Early reflections (-10000 to 1000 mB)
- **ReflectionsDelay** (float): Reflections delay (0 to 0.3 seconds)
- **Reverb** (int): Late reverb level (-10000 to 2000 mB)
- **ReverbDelay** (float): Reverb delay (0 to 0.1 seconds)
- **Diffusion** (float): Diffusion (0 to 100%)
- **Density** (float): Density (0 to 100%)
- **HFReference** (float): Reference HF (20 to 20000 Hz)

---

### DS Waves Reverb

Simplified reverb with basic parameters.

**Properties**:

- **InGain** (float): Input gain (0 to 96 dB)
- **ReverbMix** (float): Reverb mix (0 to 96 dB)
- **ReverbTime** (float): Reverb time (0.001 to 3000 ms)
- **HighFreqRTRatio** (float): HF reverb time ratio (0.001 to 0.999)

**Usage**:

```
// Signature: (int streamIndex, string name, float highFreqRTRatio,
//             float inGain, float reverbMix, float reverbTime)
videoCaptureCore.Audio_Effects_DS_WavesReverb(0, "reverb",
    highFreqRTRatio: 0.001f, inGain: 0, reverbMix: -10, reverbTime: 1000);
```

---

## Effects Availability Matrix

| Effect | Cross-Platform SDKs | Classic SDKs | Platforms |
| --- | --- | --- | --- |
| **Volume/Level Control** |  |  |  |
| Volume | Yes | Yes | Cross-platform / Windows |
| Amplify | Yes | Yes | Cross-platform / Windows |
| **Stereo Processing** |  |  |  |
| Balance | Yes | No | Cross-platform |
| Wide Stereo | Yes | No | Cross-platform |
| Karaoke | Yes | No | Cross-platform |
| **Delay and Modulation** |  |  |  |
| Echo | Yes | Yes | Cross-platform / Windows |
| Reverberation (Freeverb) | Yes | No | Cross-platform |
| Flanger | Yes | Yes | Cross-platform / Windows |
| Phaser | Yes | Yes | Cross-platform / Windows |
| **Pitch and Tempo** |  |  |  |
| Pitch Shift | Yes | Yes | Cross-platform / Windows |
| Scale Tempo | Yes | No | Cross-platform |
| Tempo | Yes | Yes | Cross-platform / Windows |
| **Equalization** |  |  |  |
| Equalizer 10-band | Yes | No | Cross-platform |
| Equalizer Parametric | Yes | Yes | Cross-platform / Windows |
| **Filtering** |  |  |  |
| High-Pass | Yes | Yes | Cross-platform / Windows |
| Low-Pass | Yes | Yes | Cross-platform / Windows |
| Band-Pass | Yes | Yes | Cross-platform / Windows |
| Notch | Yes | Yes | Cross-platform / Windows |
| Chebyshev Band Pass/Reject | Yes | No | Cross-platform |
| Chebyshev Limit | Yes | No | Cross-platform |
| **Dynamic Processing** |  |  |  |
| Compressor/Expander | Yes | No | Cross-platform |
| Dynamic Amplify | Yes | Yes | Cross-platform / Windows |
| **Frequency Enhancement** |  |  |  |
| TrueBass | Yes | Yes | Cross-platform / Windows |
| Treble Enhancer | Yes | Yes | Cross-platform / Windows |
| **Advanced Effects** |  |  |  |
| Phase Invert | Yes | Yes | Cross-platform / Windows |
| Sound 3D | Yes | Yes | Cross-platform / Windows |
| Channel Order | Yes | Yes | Cross-platform / Windows |
| Down Mix | Yes | Yes | Cross-platform / Windows |
| Fade | Yes | Yes | Cross-platform / Windows |
| **Noise Reduction** |  |  |  |
| Remove Silence | Yes | No | Cross-platform |
| Audio RNNoise | Yes | No | Cross-platform (requires plugin) |
| Audio Loud Norm | Yes | No | Cross-platform (requires plugin) |
| **Analysis** |  |  |  |
| EBU R128 Level | Yes | No | Cross-platform (requires plugin) |
| **Spatial Audio** |  |  |  |
| HRTF Render | Yes | No | Cross-platform (requires plugin) |
| **Specialized** |  |  |  |
| RS Audio Echo | Yes | No | Cross-platform (requires plugin) |
| Csound Filter | Yes | No | Windows/macOS/Linux (requires Csound) |
| **DirectSound Effects (Windows Classic Only)** |  |  |  |
| DS Chorus | No | Yes | Windows only |
| DS Distortion | No | Yes | Windows only |
| DS Gargle | No | Yes | Windows only |
| DS Reverb (I3DL2) | No | Yes | Windows only |
| DS Waves Reverb | No | Yes | Windows only |

**Legend**:

- **Cross-platform SDKs** = Media Blocks SDK, Video Capture SDK (VideoCaptureCoreX), Media Player SDK (MediaPlayerCoreX)
- **Classic SDKs** = Video Capture SDK (VideoCaptureCore), Media Player SDK (MediaPlayerCore), Video Edit SDK (VideoEditCore) — Windows only

## Audio Elements Reference

| Effect | Audio Element | Plugin |
| --- | --- | --- |
| Volume | volume | coreelements |
| Amplify | audioamplify | audiofx |
| Balance | audiopanorama | audiofx |
| Echo | audioecho | audiofx |
| Karaoke | audiokaraoke | audiofx |
| Wide Stereo | stereo | audiofx |
| Reverberation | freeverb | freeverb |
| Equalizer 10-band | equalizer-10bands | audiofx |
| High-Pass | audiocheblimit | audiofx |
| Low-Pass | audiocheblimit | audiofx |
| Chebyshev Band | audiochebband | audiofx |
| Chebyshev Limit | audiocheblimit | audiofx |
| Compressor | audiodynamic | audiofx |
| Scale Tempo | scaletempo | audiofx |
| Pitch Shift | pitch | soundtouch |
| Audio RNNoise | audiornnoise | rsaudiofx |
| Audio Loud Norm | audioloudnorm | rsaudiofx |
| EBU R128 Level | ebur128level | rsaudiofx |
| RS Audio Echo | rsaudioecho | rsaudiofx |
| HRTF Render | hrtfrender | rsaudiofx |
| Csound Filter | csoundfilter | csound |

## Frequently Asked Questions

 What is the default value for audio effect parameters?

Each effect has documented defaults that represent neutral/bypass behavior. For example, `VolumeAudioEffect` defaults to level 1.0 (100%), `Equalizer10AudioEffect` defaults all bands to 0 dB, and `ReverberationAudioEffect` defaults to a moderate room simulation. See each effect's parameter table above for specific defaults.

  How do I reset an audio effect to its default settings?

Create a new instance of the effect with default constructor parameters and call `Audio_Effects_AddOrUpdate()` to replace the current settings. Each effect's default constructor initializes all parameters to their documented defaults.

  Can I use multiple instances of the same effect type?

Yes. Effect **names** are used as unique identifiers, not effect types. To run multiple instances of the same type simultaneously, give each instance a distinct name. Calling `Audio_Effects_AddOrUpdate()` with an effect whose name matches an existing one replaces that instance; a new name adds a new instance to the chain.

  What sample rates and channel configurations are supported?

All cross-platform audio effects support standard sample rates (8 kHz to 192 kHz) and channel configurations (mono, stereo, multi-channel). The effects automatically adapt to the audio format of the input stream. Some effects like `BalanceAudioEffect` and `WideStereoAudioEffect` require stereo input.

  How do I remove an audio effect during playback?

Use the `Audio_Effects_Remove()` method with the effect type to remove it from the processing chain during playback. The change takes effect immediately without interrupting the audio stream.

## See Also

- [Audio Effects Overview](../)
- [Audio Sample Grabber](../audio-sample-grabber/)
- [Audio Processing Blocks (Media Blocks SDK)](../../../mediablocks/AudioProcessing/)

---END OF PAGE---


## AAC Audio Encoding with M4A Container Output in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-encoders/aac/
**Description:** Use avenc_aac, voaacenc, atenc, and Media Foundation backends with runtime detection. Bitrate 32-320 kbps, 5.1 surround, and M4A/MP4 containers.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Recording, Encoding, Editing, MP4, TS, MPEG-2, AAC, C#
**API:** M4AOutput, AACObject, AVENCAACEncoderSettings, VOAACEncoderSettings, AppleAACEncoderSettings, AACOutput

# AAC encoder and M4A output

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VisioForge SDK provides several AAC encoder implementations, each with unique characteristics and use cases.

## What is M4A Output?

M4A is a file format used for storing audio data encoded with the Advanced Audio Coding (AAC) codec. VisioForge .Net SDKs provide robust support for creating high-quality M4A audio files through their dedicated M4AOutput class. This format is widely used for digital audio distribution due to its excellent compression efficiency and sound quality.

## Cross-platform M4A (AAC) output

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The cross-platform capable SDKs (VideoCaptureCoreX, VideoEditCoreX, MediaBlocksPipeline) allow you to utilize several AAC encoder implementations via `M4AOutput`. This guide focuses on three main approaches using dedicated settings objects:

1. [AVENC AAC Encoder](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.AudioEncoders.AVENCAACEncoderSettings.html) - A feature-rich, cross-platform encoder.
2. [VO-AAC Encoder](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.AudioEncoders.VOAACEncoderSettings.html) - A streamlined, cross-platform encoder.
3. Media Foundation AAC Encoder - A Windows-specific system encoder, accessible on Windows platforms via `MFAACEncoderSettings`.
4. Apple AAC Encoder - The AudioToolbox encoder built into macOS, accessible on macOS and Mac Catalyst via `AppleAACEncoderSettings`.

### AVENC AAC Encoder

The AVENC AAC Encoder offers the most comprehensive configuration options for audio encoding. It provides advanced settings for stereo coding, prediction, and noise shaping.

#### Key Features

- Multiple coder strategies
- Configurable stereo coding
- Advanced noise and prediction techniques

#### Coder Strategies

The AVENC AAC Encoder supports three coder strategies:

- `ANMR`: Advanced noise modeling and reduction method
- `TwoLoop`: Two-loop searching method for optimization
- `Fast`: Default fast search algorithm (recommended for most use cases)

#### Sample Configuration

```
var aacSettings = new AVENCAACEncoderSettings
{
    Coder = AVENCAACEncoderCoder.Fast,
    Bitrate = 192,
    IntensityStereo = true,
    ForceMS = AVENCAACTrilian.Auto,
    TNS = true
};
```

#### Supported Parameters

- **Bitrates**: 0, 32, 64, 96, 128, 160, 192, 224, 256, 320 kbps
- **Sample Rates**: 7350 to 96000 Hz
- **Channels**: 1 to 6 channels

### VO-AAC Encoder

Deprecated

`VOAACEncoderSettings` is marked `[Obsolete]` in recent SDK releases — the underlying `voaacenc` element fails caps negotiation with `mpegtsmux` on iOS and is no longer recommended. Prefer `AVENCAACEncoderSettings` for new code; `MFAACEncoderSettings` remains a good choice on Windows.

The VO-AAC Encoder is a more streamlined encoder with simpler configuration options.

#### Key Features

- Simplified configuration
- Straightforward bitrate and sample rate controls
- Limited to stereo audio

#### Sample Configuration

```
var aacSettings = new VOAACEncoderSettings
{
    Bitrate = 128
};
```

#### Supported Parameters

- **Bitrates**: 32, 64, 96, 128, 160, 192, 224, 256, 320 kbps
- **Sample Rates**: 8000 to 96000 Hz
- **Channels**: 1-2 channels

### Apple AAC Encoder (macOS and Mac Catalyst)

`AppleAACEncoderSettings` wraps `atenc`, the AAC encoder built into the operating system through AudioToolbox — the same one the rest of macOS encodes AAC with. It is available on macOS and Mac Catalyst; the iOS runtime shipped with the SDK does not carry it yet, so always gate on `IsAvailable()` rather than on the platform.

#### Key Features

- Produced by the operating system's own encoder
- Up to 8 channels, more than any other AAC backend in the SDK
- Four rate control modes, including true VBR

#### Rate Control

`RateControl` selects how the encoder spends bits, and it decides whether `Bitrate` is read at all:

- `Constant` (default): constant bitrate, driven by `Bitrate`.
- `LongTermAverage`: the instantaneous rate varies, the long-term average follows `Bitrate`.
- `VariableConstrained`: constrained VBR. **`Bitrate` is ignored.**
- `Variable`: true VBR driven by `VBRQuality` (0-127, default 65). **`Bitrate` is ignored.**

In the two variable modes the resulting file size is a function of the content and, for `Variable`, of `VBRQuality` alone — setting `Bitrate` there has no effect at all.

#### Sample Configuration

```
var aacSettings = new AppleAACEncoderSettings
{
    Bitrate = 192,
    RateControl = AppleAACRateControl.Constant
};
```

#### Supported Parameters

- **Bitrates**: 0 (Auto), 32, 64, 96, 128, 160, 192, 224, 256, 320 kbps
- **Sample Rates**: 8000 to 48000 Hz
- **Channels**: 1 to 8 channels

It is not the default

`AVENCAACEncoderSettings` remains the default AAC encoder on macOS. Measured on Apple Silicon against a lossless source, the two encoders trade places depending on the bitrate - `atenc` is behind at 96 kbps, level at 128 kbps and ahead at 192 kbps - and their CPU cost is indistinguishable, since AAC encoding runs at well over a hundred times realtime either way. Select `AppleAACEncoderSettings` explicitly when you want the platform encoder, more than six channels, or true VBR.

### Media Foundation AAC Encoder (Windows Only)

This encoder is specific to Windows platforms and offers a limited but performance-optimized encoding solution.

#### Key Features

- Windows-specific implementation
- Predefined bitrate options
- Limited sample rate support

#### Supported Parameters

- **Bitrates**: 0 (Auto), 96, 128, 160, 192, 576, 768, 960, 1152 kbps
- **Sample Rates**: 44100, 48000 Hz
- **Channels**: 1, 2, 6 channels

### Encoder Availability and Selection

Each encoder provides a static `IsAvailable()` method to check if the encoder can be used in the current environment. This is useful for runtime compatibility checks.

```
#if __MACOS__ || __MACCATALYST__
if (AppleAACEncoderSettings.IsAvailable())
{
    // Use the operating system's own AAC encoder
}
#endif

if (AVENCAACEncoderSettings.IsAvailable())
{
    // Use AVENC AAC Encoder
}
else if (VOAACEncoderSettings.IsAvailable())
{
    // Fallback to VO-AAC Encoder
}
```

### Getting Started with M4AOutput

The cross-platform implementation uses the [M4AOutput](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.M4AOutput.html) class as the foundation for M4A file creation. To begin using this feature, initialize the class with your desired output filename:

```
var output = new M4AOutput("output.m4a");
```

### Switching Between Encoders

The default encoder selection is platform-dependent:

- Windows environments: MF AAC
- Other platforms: VO-AAC

You can override this default selection by explicitly setting the `Audio` property:

```
// For VO-AAC encoder
output.Audio = new VOAACEncoderSettings();

// For AVENC AAC encoder
output.Audio = new AVENCAACEncoderSettings();

// For MF AAC encoder (Windows only)
#if NET_WINDOWS
output.Audio = new MFAACEncoderSettings();
#endif

// For the Apple AAC encoder (macOS and Mac Catalyst)
#if __MACOS__ || __MACCATALYST__
output.Audio = new AppleAACEncoderSettings();
#endif
```

### Configuring MP4 Sink Settings

Since M4A files are based on the MP4 container format, you can adjust various output parameters through the `Sink` property:

```
// Change the output filename
output.Sink.Filename = "new_output.m4a";
```

### Advanced Audio Processing

For workflows requiring specialized audio processing, the M4AOutput class supports custom audio processors:

```
// Implement your custom audio processing logic
output.CustomAudioProcessor = new MyCustomAudioProcessor();
```

### Key Methods for File Management

The M4AOutput class provides several methods for handling files and retrieving encoder information:

```
// Get current output filename
string currentFile = output.GetFilename();

// Update the output filename
output.SetFilename("updated_file.m4a");

// Retrieve available audio encoders
var audioEncoders = output.GetAudioEncoders();
```

### Using M4A Output in Different SDKs

Each VisioForge SDK has a slightly different approach to implementing M4A output:

#### With Video Capture SDK

```
var core = new VideoCaptureCoreX();
core.Outputs_Add(output, true);
```

#### With Video Edit SDK

```
var core = new VideoEditCoreX();
core.Output_Format = output;
```

#### With Media Blocks SDK

```
var aac = new VOAACEncoderSettings();
var sinkSettings = new MP4SinkSettings("output.m4a");
var m4aOutput = new M4AOutputBlock(sinkSettings, aac);
```

### Rate Control Considerations

1. **AVENC AAC Encoder**:
2. Most flexible rate control
3. Supports constant bitrate (CBR)
4. Multiple encoding strategies affect quality and performance
5. **VO-AAC Encoder**:
6. Simple constant bitrate control
7. Recommend for straightforward encoding needs
8. Limited advanced configuration
9. **Media Foundation Encoder**:
10. Limited to predefined bitrates
11. Good for quick Windows-based encoding
12. Auto bitrate option available

### Recommendations

- For advanced audio encoding with maximum control, use AVENC AAC Encoder
- For simple, cross-platform encoding, use VO-AAC Encoder
- For Windows-specific, optimized encoding, use Media Foundation Encoder

### Performance and Quality Considerations

- **Bitrate vs. Quality vs. File Size**: Higher bitrates generally result in better audio quality but also lead to larger file sizes. Experiment with different bitrates to find the optimal balance for your specific content and distribution needs.
- **Sample Rate Matching**: Always try to choose sample rates that match your source audio. This avoids unnecessary resampling, which can potentially degrade audio quality.
- **Encoder Characteristics**:
- `AVENC AAC Encoder`: Offers the most extensive configuration options, allowing for fine-grained control over quality and performance. Ideal for advanced use cases.
- `VO-AAC Encoder`: Provides a good balance of simplicity, cross-platform compatibility, and quality. A solid choice for many common scenarios.
- `Media Foundation AAC Encoder`: Leverages built-in Windows audio processing capabilities. It can be efficient on Windows but offers less configuration flexibility than AVENC.
- **Channel Configuration (Mono vs. Stereo)**:
- For voice-only content, using mono encoding (1 channel) can significantly reduce file size without a noticeable loss in quality for speech. Check if your chosen encoder settings (e.g., `AVENCAACEncoderSettings.Channels`) allow explicit channel configuration.
- For music and rich audio environments, stereo (2 channels) is generally preferred.
- **Content-Specific Bitrate Ranges**: While higher is often better, the "best" bitrate depends on the audio content:
- *Speech/Voice:* 64-96 kbps can be adequate.
- *General Music:* 128-192 kbps is a common target for good quality.
- *High-Fidelity Audio:* 256-320 kbps or higher might be used when pristine quality is critical. These are guidelines; always test with your specific audio.
- **Target Audience and Platform**: Consider who will be listening and on what devices. For example, if the audio is primarily for web streaming to mobile devices, extremely high bitrates might lead to buffering issues or unnecessary data consumption. Tailor your encoder choice and settings accordingly.

### Sample Code

- Check the [MP4 output](../../output-formats/mp4/) guide for sample code.
- Check the [AAC encoder block](../../../mediablocks/AudioEncoders/) for sample code.

## Windows-only AAC output

[VideoCaptureCore](#) [VideoEditCore](#)

[M4AOutput](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.M4AOutput.html) is the primary class for configuring M4A (AAC) output settings. It implements both `IVideoEditBaseOutput` and `IVideoCaptureBaseOutput` interfaces.

### Properties

| Property | Type | Description | Default Value |
| --- | --- | --- | --- |
| Version | AACVersion | Specifies the AAC version (MPEG-2 or MPEG-4) | MPEG4 |
| Object | AACObject | Defines the AAC object type | Low |
| Output | AACOutput | Sets the AAC output mode | RAW |
| Bitrate | int | Specifies the AAC bitrate in kbps | 128 |

### Methods

#### `GetInternalTypeVC()`

- Returns: `VideoCaptureOutputFormat.M4A`
- Purpose: Gets the internal output format for video capture

#### `GetInternalTypeVE()`

- Returns: `VideoEditOutputFormat.M4A`
- Purpose: Gets the internal output format for video editing

#### `Save()`

- Returns: JSON string representation of the M4AOutput object
- Purpose: Serializes the current configuration to JSON

#### `Load(string json)`

- Parameters: JSON string containing M4AOutput configuration
- Returns: New M4AOutput instance
- Purpose: Creates a new M4AOutput instance from JSON configuration

### Supporting Enums

#### AACVersion

Defines the version of AAC to be used:

| Value | Description |
| --- | --- |
| MPEG4 | MPEG-4 AAC (default) |
| MPEG2 | MPEG-2 AAC |

#### AACObject

Specifies the AAC encoder stream object type:

| Value | Description |
| --- | --- |
| Undefined | Not to be used |
| Main | Main profile |
| Low | Low Complexity profile (default) |
| SSR | Scalable Sample Rate profile |
| LTP | Long Term Prediction profile |

#### AACOutput

Determines the AAC encoder stream output type:

| Value | Description |
| --- | --- |
| RAW | Raw AAC stream (default) |
| ADTS | Audio Data Transport Stream format |

### Usage Example

```
// Create new M4A output configuration
var core = new VideoCaptureCore();
core.Mode = VideoCaptureMode.VideoCapture;
core.Output_Filename = "output.m4a";

var output = new M4AOutput
{
    Bitrate = 192,
    Version = AACVersion.MPEG4,
    Object = AACObject.Low,
    Output = AACOutput.ADTS
};

core.Output_Format = output; // core is an instance of VideoCaptureCore or VideoEditCore
```

### Selecting the Right Bitrate

The optimal bitrate depends on your content type and quality requirements:

- **64-96 kbps**: Suitable for voice recordings and speech content
- **128-192 kbps**: Recommended for general music and audio content
- **256-320 kbps**: Ideal for high-fidelity music where quality is paramount

### Choosing the Appropriate Profile

- Use `AACObject.Low` for most applications as it provides an excellent balance between quality and encoding efficiency
- Reserve `AACObject.Main` for specialized use cases requiring maximum quality
- Avoid `AACObject.Undefined` as it isn't a valid encoding option

### Container Format Selection

- `AACOutput.ADTS` provides better compatibility with various players and devices
- `AACOutput.RAW` is preferable when the AAC stream will be embedded within another container format

---END OF PAGE---


## FLAC Lossless Audio Encoding and Recording in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-encoders/flac/
**Description:** Lossless recording with quality levels 0-9, sample rates up to 655 kHz, 8-channel surround, and LPC optimization. VisioForge SDK C# code examples.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, FLAC, C#
**API:** FLACOutput, FLACEncoderSettings, VideoCaptureCoreX, VideoEditCoreX, CustomAudioProcessor

# FLAC encoder and output

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The FLAC (Free Lossless Audio Codec) encoder provides high-quality lossless audio compression while preserving the original audio quality.

## Cross-platform FLAC output

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

### Features

The FLAC encoder supports a wide range of audio configurations:

- Sample rates from 1 Hz to 655,350 Hz
- Up to 8 audio channels (mono to 7.1 surround)
- Lossless compression with adjustable quality settings
- Streamable output support
- Configurable block sizes and compression parameters

### Quality Settings

The encoder provides a quality parameter ranging from 0 to 9:

- 0: Fastest compression (lowest CPU usage)
- 1-7: Balanced compression settings
- 8: Highest compression (higher CPU usage)
- 9: Insane compression (extremely CPU intensive)

The default quality setting is 5, which offers a good balance between compression ratio and processing speed.

### Basic Settings

The cross-platform [FLACEncoderSettings](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.AudioEncoders.FLACEncoderSettings.html) class offers advanced configuration options:

```
// Create FLAC encoder settings with default quality
var flacSettings = new FLACEncoderSettings
{
    // Default compression level
    Quality = 5,

    // Audio block size in samples
    BlockSize = 4608,

    // Enable streaming support
    StreamableSubset = true,

    // Enable stereo processing
    MidSideStereo = true
};
```

### Advanced Compression Settings

```
// Create FLAC encoder settings with advanced configuration
var advancedSettings = new FLACEncoderSettings
{
    // Linear Prediction settings
    // Maximum LPC order for prediction
    MaxLPCOrder = 8,
    // Auto precision for coefficients
    QlpCoeffPrecision = 0,

    // Residual coding settings
    MinResidualPartitionOrder = 3,
    MaxResidualPartitionOrder = 3,

    // Search optimization settings
    // Disable expensive coefficient search
    ExhaustiveModelSearch = false,
    // Disable precision search
    QlpCoeffPrecSearch = false,
    // Disable escape code search
    EscapeCoding = false
};
```

### Sample Code

Add the FLAC output to the Video Capture SDK core instance:

```
// Create a Video Capture SDK core instance
var core = new VideoCaptureCoreX();

// Create a FLAC output instance
var flacOutput = new FLACOutput("output.flac");

// Set the quality of the FLAC encoder
flacOutput.Audio.Quality = 5;

// Add the FLAC output
core.Outputs_Add(flacOutput, true);
```

Set the output format for the Video Edit SDK core instance:

```
// Create a Video Edit SDK core instance
 var core = new VideoEditCoreX();

// Create a FLAC output instance
 var flacOutput = new FLACOutput("output.flac");

 // Set the quality
 flacOutput.Audio.Quality = 5;

 // Set the output format
 core.Output_Format = flacOutput;
```

Create a Media Blocks FLAC output instance:

```
// Create a FLAC encoder settings instance
var flacSettings = new FLACEncoderSettings();

// Create a FLAC output instance
var flacOutput = new FLACOutputBlock("output.flac", flacSettings);
```

### FLACOutput class

The `FLACOutput` class provides functionality for configuring FLAC (Free Lossless Audio Codec) output in the VisioForge SDKs.

```
// Create a new FLAC output instance
var flacOutput = new FLACOutput("output.flac");

// Configure FLAC encoder settings (Quality: 0 fastest .. 8 highest, 9 insane)
flacOutput.Audio.Quality = 5;
```

#### Filename

- Set the output filename during initialization or via the `Filename` property
- Or call `GetFilename()` / `SetFilename(string)` methods (equivalent — they back the `Filename` property)

```
// Set during initialization
var flacOutput = new FLACOutput("audio_output.flac");

// Or via the property
flacOutput.Filename = "new_output.flac";

// Or via the method accessors
flacOutput.SetFilename("final.flac");
string currentPath = flacOutput.GetFilename();  // "final.flac"
```

#### Audio Settings

The `Audio` property provides access to FLAC-specific encoding settings through the `FLACEncoderSettings` class:

```
flacOutput.Audio = new FLACEncoderSettings();
// Configure specific FLAC encoding parameters here
```

#### Custom Audio Processing

You can set a custom audio processor using the `CustomAudioProcessor` property:

```
flacOutput.CustomAudioProcessor = new CustomMediaBlock();
```

#### Implementation Notes

- The class implements multiple interfaces:
- `IVideoEditXBaseOutput`
- `IVideoCaptureXBaseOutput`
- `IOutputAudioProcessor`
- Only FLAC audio encoding is supported (no video encoding capabilities)
- Default FLAC encoder settings are automatically created during initialization

Media Blocks SDK contains a dedicated [FLAC encoder block](../../../mediablocks/AudioEncoders/).

### Performance Considerations

When configuring the FLAC encoder, consider these performance factors:

1. Higher quality settings (7-9) will significantly increase CPU usage
2. The `ExhaustiveModelSearch` option can greatly impact encoding speed
3. Larger block sizes may improve compression but increase memory usage
4. `StreamableSubset` should remain enabled unless you have specific requirements

### Compatibility

The encoder supports the following configurations:

- Audio channels: 1 to 8 channels
- Sample rates: 1 Hz to 655,350 Hz
- Bitrate: Variable (lossless compression)

### Error Handling

Always check for encoder availability before use:

```
if (!FLACEncoderSettings.IsAvailable())
{
    // Handle unavailable encoder scenario
    Console.WriteLine("FLAC encoder is not available on this system");
    return;
}
```

### Best Practices

1. Start with the default quality setting (5) and adjust based on your needs
2. Enable `MidSideStereo` for stereo content to improve compression
3. Use `SeekPoints` for longer audio files to enable quick seeking
4. Keep `StreamableSubset` enabled unless you have specific requirements
5. Avoid using `ExhaustiveModelSearch` unless compression ratio is critical

## Windows-only FLAC output

[VideoCaptureCore](#) [VideoEditCore](#)

The [FLACOutput](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.FLACOutput.html) class provides Windows-only settings for the FLAC encoder. This class implements both `IVideoEditBaseOutput` and `IVideoCaptureBaseOutput` interfaces, making it suitable for both video editing and capture scenarios.

### Properties

#### Compression Level

- **Property**: `Level`
- **Type**: `int`
- **Range**: 0-8
- **Default**: 5
- **Description**: Controls the compression level, where 0 provides fastest compression and 8 provides highest compression.

#### Block Size

- **Property**: `BlockSize`
- **Type**: `int`
- **Default**: 4608
- **Valid Values**: For subset streams, must be one of:
- 192, 256, 512, 576, 1024, 1152, 2048, 2304, 4096, 4608
- 8192, 16384 (only if sample rate > 48kHz)
- **Description**: Specifies the block size in samples. The encoder uses the same block size for the entire stream.

#### LPC Order

- **Property**: `LPCOrder`
- **Type**: `int`
- **Default**: 8
- **Constraints**:
- Must be ≤ 32
- For subset streams at ≤ 48kHz, must be ≤ 12
- **Description**: Specifies the maximum Linear Predictive Coding order. Setting to 0 disables generic linear prediction and uses only fixed predictors, which is faster but typically results in 5-10% larger files.

#### Mid-Side Coding Options

##### Mid-Side Coding

- **Property**: `MidSideCoding`
- **Type**: `bool`
- **Default**: `false`
- **Description**: Enables mid-side coding for stereo streams. This typically increases compression by a few percent by encoding both stereo pair and mid-side versions of each block and selecting the smallest resulting frame.

##### Adaptive Mid-Side Coding

- **Property**: `AdaptiveMidSideCoding`
- **Type**: `bool`
- **Default**: `false`
- **Description**: Enables adaptive mid-side coding for stereo streams. This provides faster encoding than full mid-side coding but with slightly less compression by adaptively switching between independent and mid-side coding.

#### Rice Parameters

##### Rice Minimum

- **Property**: `RiceMin`
- **Type**: `int`
- **Default**: 3
- **Description**: Sets the minimum residual partition order. Works in conjunction with RiceMax to control how the residual signal is partitioned.

##### Rice Maximum

- **Property**: `RiceMax`
- **Type**: `int`
- **Default**: 3
- **Description**: Sets the maximum residual partition order. The residual is partitioned into 2^min to 2^max pieces, each with its own Rice parameter. Optimal settings typically depend on block size, with best results when blocksize/(2^n)=128.

#### Advanced Options

##### Exhaustive Model Search

- **Property**: `ExhaustiveModelSearch`
- **Type**: `bool`
- **Default**: `false`
- **Description**: Enables exhaustive model search for optimal encoding. When enabled, the encoder generates subframes for every order and uses the smallest, potentially improving compression by ~0.5% at the cost of significantly increased encoding time.

### Methods

#### Constructor

```
public FLACOutput()
```

Initializes a new instance with default values:

- Level = 5
- RiceMin = 3
- RiceMax = 3
- LPCOrder = 8
- BlockSize = 4608

### Serialization

#### Save()

```
public string Save()
```

Serializes the settings to a JSON string.

#### Load(string json)

```
public static FLACOutput Load(string json)
```

Creates a new FLACOutput instance from a JSON string.

### Usage Example

```
var flacSettings = new FLACOutput
{
    Level = 8,                   // Maximum compression
    BlockSize = 4608,            // Default block size
    MidSideCoding = true,        // Enable mid-side coding for better compression
    ExhaustiveModelSearch = true // Enable exhaustive search for best compression
};

core.Output_Format = flacSettings; // Core is VideoCaptureCore or VideoEditCore
```

### Best Practices

#### Compression Level Selection

- Use Level 0-3 for faster encoding with moderate compression
- Use Level 4-6 for balanced compression/speed
- Use Level 7-8 for maximum compression regardless of speed

#### Block Size Considerations

- Larger block sizes generally provide better compression
- Stick to standard values (4608, 4096, etc.) for maximum compatibility
- Consider memory constraints when selecting block size

#### Mid-Side Coding

- Enable for stereo content when compression is priority
- Use adaptive mode when encoding speed is important
- Disable for mono content as it has no effect

#### Rice Parameters

- Default values (3,3) are suitable for most use cases
- Increase for potentially better compression at the cost of encoding speed
- Values beyond 6 rarely provide significant benefits

---END OF PAGE---


## Audio Encoders for .NET — AAC, FLAC, MP3, Opus Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-encoders/
**Description:** Implement AAC, FLAC, MP3, Opus, and other audio encoders in .NET with optimal settings, performance tips, and best practices.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming

# Audio Encoders for .NET Development

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to Audio Encoding in .NET Applications

When developing media applications in .NET, choosing the right audio encoder is crucial for ensuring optimal performance, compatibility, and quality. VisioForge's suite of .NET SDKs provides developers with powerful tools for audio encoding across various formats, enabling the creation of professional-grade media applications.

Audio encoders are essential components that convert raw audio data into compressed formats suitable for storage, streaming, or playback. Each encoder offers different advantages in terms of compression ratio, audio quality, processing requirements, and platform compatibility. This guide will help you navigate the various audio encoding options available in VisioForge's .NET SDKs.

## Quick Start — Pick an audio encoder

Every encoder on the cross-platform engines is a settings class that you assign to the output's `Audio` property (or pass to a `*OutputBlock` in Media Blocks). The surrounding pipeline is the same — only the settings type changes.

```
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Output;

// MP4 container: encode audio with AAC.
var mp4 = new MP4Output("output.mp4");
mp4.Audio = new VOAACEncoderSettings { Bitrate = 192 };   // 128/192/256 kbps typical

// MKV container: swap in a different codec on the same Audio slot.
var mkv = new MKVOutput("output.mkv");
mkv.Audio = new OPUSEncoderSettings { Bitrate = 128 };

// FLAC: lossless audio-only output.
var flac = new FLACOutput("music.flac");
flac.Audio.Quality = 5;                                  // 0 fastest .. 8 highest, 9 insane

// Standalone formats (one encoder = one container):
var mp3 = new MP3Output("song.mp3");       // MP3
var wav = new WAVOutput("raw.wav");        // uncompressed PCM
var ogg = new OGGVorbisOutput("music.ogg"); // OGG + Vorbis

// Attach to a VideoCaptureCoreX or VideoEditCoreX instance:
// core.Outputs_Add(mp4, true);   // VideoCaptureCoreX
// core.Output_Format = mp4;      // VideoEditCoreX
```

Pick the encoder that matches your target: **AAC** for broad compatibility (MP4, M4A, streaming), **Opus** for low-latency / low-bitrate voice or music, **MP3** for legacy distribution, **FLAC** for lossless archives, **Vorbis** for open-format WebM/OGG pipelines. Detailed per-encoder pages cover bitrate tables, sample-rate limits, and tuning parameters.

## Available Audio Encoders

VisioForge's .NET SDKs include support for the following audio encoders, each designed for specific use cases:

### [AAC Encoder](aac/)

Advanced Audio Coding (AAC) represents the industry standard for high-quality audio compression. It delivers excellent sound quality at lower bit rates compared to older formats like MP3.

**Key features:**

- Efficient compression with minimal quality loss
- Wide device and platform compatibility
- Variable bit rate support for optimized file sizes
- Ideal for streaming applications and mobile devices
- Support for multi-channel audio (up to 48 channels)

AAC is particularly well-suited for applications where audio quality is paramount, such as music streaming services, video production tools, and professional media applications.

### [FLAC Encoder](flac/)

Free Lossless Audio Codec (FLAC) provides lossless compression of audio data, preserving the original audio quality while reducing file size.

**Key features:**

- Lossless compression with no quality degradation
- Open-source format with broad support
- Typically reduces file sizes by 40-50% compared to uncompressed audio
- Fast encoding and decoding performance
- Supports metadata tags and seeking

FLAC is ideal for archiving audio, professional audio editing applications, and audiophile-grade music playback systems where maintaining perfect audio fidelity is essential.

### [MP3 Encoder](mp3/)

MPEG Audio Layer III (MP3) remains one of the most widely used audio formats due to its universal compatibility and acceptable quality-to-size ratio.

**Key features:**

- Nearly universal compatibility across devices and platforms
- Configurable bit rates from 8 to 320 Kbps
- Joint stereo mode for improved compression efficiency
- Variable bit rate (VBR) encoding for optimized quality
- Fast encoding and minimal processing requirements

MP3 is best for applications where wide compatibility is more important than achieving the absolute highest audio quality, such as podcasts, basic music applications, and legacy system integration.

### [Opus Encoder](opus/)

Opus is a highly versatile audio codec designed to handle both speech and music with excellent quality at low bit rates.

**Key features:**

- Superior performance at low bit rates (6-64 Kbps)
- Low algorithmic delay for real-time applications
- Seamless quality adjustment based on available bandwidth
- Excellent for both speech and music content
- Open standard with growing adoption

Opus excels in real-time communication applications, VoIP systems, live streaming, and scenarios where bandwidth efficiency is critical.

### [Speex Encoder](speex/)

Speex is an audio compression format specifically optimized for speech encoding, making it ideal for voice-centric applications.

**Key features:**

- Designed specifically for human voice compression
- Variable bit rates from 2 to 44 Kbps
- Voice activity detection and comfort noise generation
- Low latency for real-time applications
- Open source with minimal patent concerns

Speex is particularly effective for voice chat applications, voice recording tools, and telephony systems where speech clarity is the priority.

### [Vorbis Encoder](vorbis/)

Vorbis is an open-source, patent-free audio compression format that offers quality comparable to AAC at similar bit rates.

**Key features:**

- Free and open format without licensing restrictions
- Excellent quality-to-size ratio for music
- Variable and average bit rate encoding modes
- Strong support in open-source software ecosystems
- Multi-channel audio support

Vorbis is well-suited for applications where licensing costs are a concern, such as open-source projects, indie game development, and web applications.

### [WavPack Encoder](wavpack/)

WavPack offers a unique hybrid approach to audio compression, providing both lossless and high-quality lossy compression options.

**Key features:**

- Hybrid mode combining lossy and lossless techniques
- Correction files to restore lossy files to lossless quality
- Fast decoding with minimal CPU requirements
- Support for high-resolution audio up to 32-bit/192kHz
- Robust error correction capabilities

WavPack is excellent for applications requiring flexible quality options, archival purposes, and systems where decoding performance is more critical than encoding speed.

### [Windows Media Audio Encoder](wma/)

Windows Media Audio (WMA) provides a set of audio codecs developed by Microsoft, offering good integration with Windows platforms.

**Key features:**

- Native integration with Windows environments
- Multiple codec variants (WMA Standard, Pro, Lossless)
- Good performance on Windows devices and Xbox platforms
- Professional variant supports multi-channel surround sound
- Digital rights management capabilities

WMA is particularly useful for Windows-centric applications, enterprise solutions, and scenarios where DRM protection is required.

## Choosing the Right Audio Encoder

Selecting the appropriate audio encoder depends on several factors:

1. **Quality Requirements**: For archiving or professional applications, consider lossless options like FLAC or WavPack. For general-purpose use, AAC or Vorbis provide excellent quality at reasonable sizes.
2. **Platform Compatibility**: If your application needs to work across many devices, MP3 offers the widest compatibility, while AAC is well-supported on modern platforms.
3. **Content Type**: For speech-focused applications, Speex or Opus at lower bitrates excel. For music, AAC, Vorbis, or MP3 at higher bitrates are preferable.
4. **Bandwidth Considerations**: For streaming over limited connections, Opus provides excellent quality at very low bitrates.
5. **Licensing Requirements**: If your project requires open-source or patent-free solutions, focus on FLAC, Vorbis, or Opus.

## Implementation Considerations

When implementing audio encoders in your .NET application:

- **Threading**: Consider encoding audio on background threads to prevent UI freezing during processing.
- **Buffer Management**: Properly manage audio buffers to prevent memory leaks during encoding operations.
- **Error Handling**: Implement robust error handling for encoding failures or corrupt input data.
- **Metadata**: Most formats support metadata tags—use them to enhance the user experience.
- **Preprocessing**: Consider implementing audio normalization or other preprocessing before encoding for optimal results.

## Performance Optimization

To achieve the best performance when using audio encoders:

- Match encoding quality to your application's needs—higher quality settings require more processing power
- Implement caching strategies for frequently accessed audio
- Consider hardware acceleration when available, particularly for real-time encoding
- Batch process audio files when possible rather than encoding on demand
- Monitor memory usage, especially when processing long audio files

## Getting Started

To begin implementing audio encoders in your .NET application using VisioForge SDKs, follow these steps:

1. Install the appropriate VisioForge SDK via NuGet or direct download
2. Reference the SDK in your project
3. Initialize the encoder with your desired configuration settings
4. Process audio through the encoder using the provided API methods
5. Handle the encoded output as needed for your application

Each encoder has specific initialization parameters and optimal settings, which are detailed in their respective documentation pages.

By understanding the strengths and appropriate use cases for each audio encoder, .NET developers can make informed decisions that optimize their media applications for quality, performance, and compatibility.

---END OF PAGE---


## MP3 Audio Encoder in C# .NET — LAME Bitrate Settings
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-encoders/mp3/
**Description:** LAME encoder with CBR, ABR, and quality-based VBR modes. Joint stereo, voice optimization, bitrate 8-320 kbps. VisioForge SDK capture and editing examples.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, MP3, C#
**API:** MP3Output, MP3EncoderSettings, MP3EncoderRateControl, MP3ChannelsMode, MP3EncodingQuality

# Mastering MP3 Audio: Record, Capture & Edit in C# and .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VisioForge SDK empowers developers to seamlessly record, capture, and edit MP3 audio within C# applications. This guide explores how to leverage our robust .NET SDK for high-quality MP3 audio processing. Whether you need to capture media streams, record MP3 files, or edit audio waveforms, our C# media toolkit provides comprehensive tools using the LAME library. MP3, a widely adopted lossy audio compression format, is ideal for audio streaming and efficient storage.

You can utilize the MP3 encoder to integrate audio capture and recording functionalities into various container formats such as MP4, AVI, and MKV, enhancing your audio capture projects. Our SDK works seamlessly with Visual Studio for a smooth development experience.

SDK contains MP3 audio encoder that can be used to encode audio streams to MP3 format using the LAME library. MP3 is a lossy audio compression format that is widely used in audio streaming and storage.

You can use MP3 encode to encode audio in MP4, AVI, MKV, and other containers.

## Cross-platform MP3 Audio Capture and Recording

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The [MP3EncoderSettings](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.AudioEncoders.MP3EncoderSettings.html) class provides developers with a streamlined approach to configure MP3 encoding for C# audio capture projects. This cross-platform solution supports various rate controls and quality settings, making it ideal for record .NET MP3 applications across different operating systems.

### Supported Formats and Specifications for C# MP3 Recording

- Input Format: S16LE (Signed 16-bit Little Endian)
- Sample Rates: 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 Hz
- Channels: Mono (1) or Stereo (2)

### Rate Control Modes

The encoder supports three rate control modes:

1. **CBR (Constant Bit Rate)**
2. Fixed bitrate throughout the entire encoding process
3. Supported bitrates: 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 Kbit/s
4. Best for streaming MP3 and when consistent file size is important
5. **ABR (Average Bit Rate)**
6. Maintains an average bitrate while allowing some variation
7. More efficient than CBR while still maintaining predictable file sizes
8. Useful for streaming services that need approximate file size estimates
9. **Quality-based VBR**
10. Variable Bit Rate based on sound complexity
11. Quality setting ranges from 0 (best) to 10
12. Most efficient for storage and best quality-to-size ratio

### C# MP3 Encoding Examples

Create basic MP3 encoder settings with CBR.

```
// Create basic MP3 encoder settings using Constant Bit Rate mode
var mp3Settings = new MP3EncoderSettings
{
    // Set to Constant Bit Rate - provides consistent file size and streaming reliability
    RateControl = MP3EncoderRateControl.CBR,
    // 192 kbps offers good quality for most music content while keeping file size reasonable
    Bitrate = 192,
    // Standard quality offers a good balance between encoding speed and output quality
    EncodingEngineQuality = MP3EncodingQuality.Standard,
    // Keep stereo channels (false) - set to true if you want to convert to mono
    ForceMono = false
};
```

Quality-based VBR configuration for high-quality .NET MP3 editing.

```
// Configure MP3 encoder with Variable Bit Rate for optimal quality-to-size ratio
var vbrSettings = new MP3EncoderSettings
{
    // Quality-based VBR adjusts bitrate dynamically based on audio complexity
    RateControl = MP3EncoderRateControl.Quality,
    // Quality scale: 0 (best) to 10 (worst) - 2.0 provides excellent quality with reasonable file size
    Quality = 2.0f,
    // High quality encoding uses more CPU but produces better results
    EncodingEngineQuality = MP3EncodingQuality.High
};
```

Add the MP3 output to capture C# MP3 audio with the Video Capture SDK:

The [MP3Output](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.MP3Output.html) class implements multiple interfaces:

- IVideoEditXBaseOutput
- IVideoCaptureXBaseOutput
- IOutputAudioProcessor

```
// Create a Video Capture SDK core instance for recording
var core = new VideoCaptureCoreX();

// Initialize MP3 output with target filename
var mp3Output = new MP3Output("output.mp3");

// Configure audio encoding settings
mp3Output.Audio.RateControl = MP3EncoderRateControl.CBR;  // Use Constant Bit Rate for reliable streaming
mp3Output.Audio.Bitrate = 128;  // 128 kbps is suitable for general audio recording

// Add the MP3 output to the capture pipeline
core.Outputs_Add(mp3Output, true);
```

Set the output format for the Video Edit SDK core instance:

```
// Initialize Video Edit SDK for processing existing media
var core = new VideoEditCoreX();

// Create MP3 output with target filename
var mp3Output = new MP3Output("output.mp3");

// Configure Variable Bit Rate encoding for better quality-to-size ratio
mp3Output.Audio.RateControl = MP3EncoderRateControl.Quality;
mp3Output.Audio.Quality = 5.0f;  // Middle quality setting (0-10 scale) - good balance of quality and size

// Set as the primary output format for the editor
core.Output_Format = mp3Output;
```

### Initialization

To create a new MP3Output instance, you need to provide the output filename:

```
// Initialize MP3 output with destination filename
var mp3Output = new MP3Output("output.mp3");
```

### Audio Settings

The `Audio` property provides access to MP3 encoder settings:

```
// Create default MP3 encoder settings object
mp3Output.Audio = new MP3EncoderSettings();
// Additional configuration can be applied to mp3Output.Audio properties
```

### Custom Audio Processing

You can set a custom audio processor using the `CustomAudioProcessor` property to handle waveform manipulations:

```
// Attach a custom audio processor for advanced audio manipulation
mp3Output.CustomAudioProcessor = new MediaBlock();
// The MediaBlock can be configured for effects, filtering, or other audio processing
```

### Filename Operations

There are multiple ways to work with the output filename:

```
// Retrieve the current output filename
string currentFile = mp3Output.GetFilename();

// Change the output destination
mp3Output.SetFilename("newoutput.mp3");

// Alternative way to set the filename via property
mp3Output.Filename = "another.mp3";
```

### Audio Encoders

The MP3Output class supports MP3 encoding exclusively. You can verify the available encoders:

```
// Get information about available audio encoders
var audioEncoders = mp3Output.GetAudioEncoders();
// Returns a list of tuples containing encoder names and their setting types
// For MP3Output, this will contain a single entry for MP3
```

### MP3OutputBlock class

The [MP3OutputBlock](../../../mediablocks/AudioEncoders/) class provides a more flexible way to configure MP3 encoding.

Create a Media Blocks MP3 output instance:

```
// Create MP3 encoder settings with desired configuration
var mp3Settings = new MP3EncoderSettings();

// Initialize MP3 output block with destination file and settings
var mp3Output = new MP3OutputBlock("output.mp3", mp3Settings);
```

Check if MP3 encoding is available.

```
// Check if MP3 encoding is available on the current system
if (!MP3EncoderSettings.IsAvailable())
{
   // Handle case where MP3 encoding is not available
   // This might occur if LAME or other required libraries are missing
}
```

### Encoding Quality Levels

The encoder supports three quality presets that affect the encoding speed and CPU usage:

- `Fast`: Quickest encoding, lower CPU usage
- `Standard`: Balanced speed and quality (default)
- `High`: Best quality, higher CPU usage

### Common Scenarios

#### High-Quality Music Capture in C

```
// Configure settings for high-quality music recording
var highQualitySettings = new MP3EncoderSettings
{
    // Use quality-based Variable Bit Rate for optimal audio fidelity
    RateControl = MP3EncoderRateControl.Quality,
    // Highest quality setting (0.0f) for maximum audio fidelity
    Quality = 0.0f,
    // Use high-quality encoding algorithm (more CPU intensive but better results)
    EncodingEngineQuality = MP3EncodingQuality.High
};
```

#### Streaming Audio

```
// Configure settings optimized for audio streaming applications
var streamingSettings = new MP3EncoderSettings
{
    // Use Constant Bit Rate for predictable streaming performance
    RateControl = MP3EncoderRateControl.CBR,
    // 128 kbps provides good quality for most content while being bandwidth-friendly
    Bitrate = 128,
    // Fast encoding reduces CPU usage, important for real-time streaming
    EncodingEngineQuality = MP3EncodingQuality.Fast
};
```

## Windows-only MP3 output

[VideoCaptureCore](#) [VideoEditCore](#)

The [MP3 file output](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.MP3Output.html) class provides advanced configuration options for MP3 encoding in C# audio video capture and editing scenarios.

### Key Features

- Flexible channel mode selection
- VBR and CBR encoding support for optimal .NET MP3 recording
- Advanced encoding parameters for professional audio applications
- Quality control settings for perfect C# MP3 editing results

### Basic Configuration

#### CBR\_Bitrate

Controls the Constant Bit Rate (CBR) setting for MP3 encoding.

- For MPEG-1 (32, 44.1, 48 kHz): Valid values are 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 kbps
- For MPEG-2 (16, 22.05, 24 kHz): Valid values are 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 kbps
- Default values: 128 kbps (MPEG-1) or 64 kbps (MPEG-2)

#### SampleRate

Specifies the audio sampling frequency in Hz. Common values are:

- 44100 Hz (CD quality, default)
- 48000 Hz (professional audio)
- 32000 Hz (broadcast)
- 22050 Hz (lower quality)
- 16000 Hz (voice)

#### ChannelsMode

Determines how audio channels are encoded. Options include:

1. StandardStereo: Independent channel encoding with dynamic bit allocation
2. JointStereo: Exploits correlation between channels using mid/side encoding
3. DualStereo: Independent encoding with fixed 50/50 bit allocation (ideal for dual language)
4. Mono: Single channel output (downmixes stereo input)

### Variable Bit Rate (VBR) Settings

#### VBR\_Mode

Enables Variable Bit Rate encoding when set to true (default). VBR allows the encoder to adjust bitrate based on audio complexity.

#### VBR\_MinBitrate

Sets the minimum allowed bitrate for VBR encoding (default: 96 kbps).

#### VBR\_MaxBitrate

Sets the maximum allowed bitrate for VBR encoding (default: 192 kbps).

#### VBR\_Quality

Controls VBR encoding quality (0-9):

- Lower values (0-4): Higher quality, slower encoding
- Middle values (5-6): Balanced quality and speed
- Higher values (7-9): Lower quality, faster encoding

### Quality and Performance

#### EncodingQuality

Determines the algorithmic quality of encoding (0-9):

- 0-1: Best quality, slowest encoding
- 2: Recommended for high quality
- 5: Default, good balance of speed and quality
- 7: Fast encoding with acceptable quality
- 9: Fastest encoding, lowest quality

### Special Features

#### ForceMono

When enabled, automatically downmixes multi-channel audio to mono.

#### VoiceEncodingMode

Experimental mode optimized for voice content.

#### KeepAllFrequencies

Disables automatic frequency filtering, preserving all frequencies at the cost of efficiency.

#### DisableShortBlocks

Forces use of long blocks only, which may improve quality at very low bitrates but can cause pre-echo artifacts.

### MP3 Frame Flags

#### Copyright

Sets the copyright bit in MP3 frames.

#### Original

Marks the stream as original content.

#### CRCProtected

Enables CRC error detection at the cost of 16 bits per frame.

#### EnableXingVBRTag

Adds VBR information headers for better player compatibility.

#### StrictISOCompliance

Enforces strict ISO MP3 standard compliance.

### Example MP3 Recording and Editing Configurations

Basic settings for C# MP3 capture applications.

```
// Configure basic MP3 output with standard settings
var mp3Output = new MP3Output
{
    // 192 kbps provides good quality for most music content
    CBR_Bitrate = 192,
    // CD-quality sample rate
    SampleRate = 44100,
    // Joint stereo mode provides better compression for most stereo content
    ChannelsMode = MP3ChannelsMode.JointStereo,
};

// Set as the output format for capture or editing
core.Output_Format = mp3Output; // Core is VideoCaptureCore or VideoEditCore
```

VBR configuration.

```
// Configure MP3 output with Variable Bit Rate for better quality/size balance
var mp3Output = new MP3Output
{
    // Enable Variable Bit Rate encoding
    VBR_Mode = true,
    // Set minimum bitrate floor to ensure acceptable quality
    VBR_MinBitrate = 96,
    // Limit maximum bitrate to control file size
    VBR_MaxBitrate = 192,
    // Quality level 6 provides a good balance between quality and file size
    VBR_Quality = 6,
};

// Set as the output format for capture or editing
core.Output_Format = mp3Output; // Core is VideoCaptureCore or VideoEditCore
```

#### Basic Stereo MP3 Encoding

```
// Configure standard stereo MP3 encoding with fixed bitrate
var mp3Output = new MP3Output
{
    // 192 kbps provides good quality for most music while keeping file size reasonable
    CBR_Bitrate = 192,
    // Standard stereo mode encodes left and right channels independently
    ChannelsMode = MP3ChannelsMode.StandardStereo,
    // CD-quality sample rate
    SampleRate = 44100,
    // Disable Variable Bit Rate to ensure consistent file size and playback
    VBR_Mode = false
};
```

#### Voice-Optimized Encoding

```
// Configure MP3 settings optimized for voice recordings
var voiceMP3 = new MP3Output
{
    // Enable voice-optimized encoding algorithms
    VoiceEncodingMode = true,
    // Use mono for voice to reduce file size (most voice doesn't benefit from stereo)
    ChannelsMode = MP3ChannelsMode.Mono,
    // Lower sample rate is sufficient for voice content
    SampleRate = 22050,
    // Enable Variable Bit Rate for better quality/size ratio
    VBR_Mode = true,
    // Better quality setting for voice clarity while keeping file size reasonable
    VBR_Quality = 4
};
```

#### High-Quality Music Encoding

```
// Configure high-quality MP3 settings for music archiving
var highQualityMP3 = new MP3Output
{
    // Enable Variable Bit Rate for optimal quality-to-size ratio
    VBR_Mode = true,
    // Set minimum bitrate to ensure good quality even in simple passages
    VBR_MinBitrate = 128,
    // Allow high bitrate for complex passages to preserve audio detail
    VBR_MaxBitrate = 320,
    // Use high quality setting (2) for excellent audio fidelity
    VBR_Quality = 2,
    // Set encoder algorithm to high quality mode
    EncodingQuality = 2,
    // Joint stereo provides better compression for most music content
    ChannelsMode = MP3ChannelsMode.JointStereo,
    // Professional audio sample rate captures full audible spectrum
    SampleRate = 48000,
    // Add VBR header for better player compatibility and seeking
    EnableXingVBRTag = true
};
```

### Advanced Settings

- **CRC Protection**: Adds error detection capability at the cost of 16 bits per frame
- **Short Blocks**: Can be disabled to potentially increase quality at very low bitrates
- **Frequency Range**: Option to keep all frequencies (disables automatic lowpass filtering)
- **Voice Mode**: Experimental mode optimized for voice content

### Best Practices

1. **Choosing Rate Control for Different Applications**
2. Use CBR for streaming and real-time C# MP3 capturing
3. Use Quality-based VBR for archival and highest quality .NET MP3 recording
4. Use ABR when you need a balance between consistent size and quality
5. **Quality Settings for Different Use Cases**
6. For archival: Use VBR with quality 0-2
7. For general C# audio video capture: VBR with quality 3-5 or CBR 192-256kbps
8. For voice recording in .NET: Consider using voice encoding mode with lower bitrates
9. **Channel Mode Selection**
10. Use Joint Stereo for most music content
11. Use Standard Stereo for critical listening and complex stereo mixes
12. Use Mono for voice recordings or when bandwidth is critical
13. **Performance Optimization**
14. Use Fast encoding quality for real-time applications
15. Use Standard quality for general purpose encoding
16. Use High quality only for archival purposes where encoding time is not critical

### Notes on Default Values

The class constructor sets these default values:

- CBR\_Bitrate = 192 kbps
- VBR\_MinBitrate = 96 kbps
- VBR\_MaxBitrate = 192 kbps
- VBR\_Quality = 6
- EncodingQuality = 6
- SampleRate = 44100 Hz
- ChannelsMode = MP3ChannelsMode.StandardStereo
- VBR\_Mode = true

---END OF PAGE---


## Opus Audio Encoder in C# .NET — Bitrate, VBR, DTX Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-encoders/opus/
**Description:** VBR, CBR, and CVBR rate control modes. Bitrate 6-510 kbps, 5 ms latency, complexity tuning, and DTX for speech. OGG/WebM output with C# examples.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, WebM, OGG, Opus, C#
**API:** OPUSEncoderSettings, VideoCaptureCoreX, VideoEditCoreX, OPUSOutput, OGGOpusOutputBlock

# Mastering OPUS Audio Encoding in .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to OPUS Audio Encoding

OPUS stands as one of the most versatile and efficient audio codecs available for modern software development. VisioForge .NET SDKs include a royalty-free OPUS encoder that transforms audio into the highly adaptable Opus format. This encoded audio can be encapsulated in various containers including Ogg, Matroska, WebM, or RTP streams, making it ideal for both streaming applications and stored media.

Developed by the Internet Engineering Task Force (IETF), OPUS combines the best elements of the SILK and CELT codecs to deliver exceptional performance across a wide range of audio requirements. The codec excels in both speech and music encoding at bitrates from as low as 6 kbps to as high as 510 kbps, offering developers remarkable flexibility in balancing quality against bandwidth constraints.

## Why Choose OPUS for Your .NET Applications

OPUS has become the preferred choice for many audio applications for several compelling reasons:

- **Low Latency**: With encoding delays as low as 5ms, OPUS is perfect for real-time communication applications
- **Adaptive Bitrate**: Seamlessly switches between speech and music optimization
- **Wide Bitrate Range**: Functions effectively from 6 kbps to 510 kbps
- **Superior Compression**: Offers better quality than MP3, AAC, and other codecs at equivalent bitrates
- **Open Standard**: Royalty-free and open-source, reducing licensing concerns
- **Cross-Platform Support**: Works across all major platforms and browsers

These advantages make OPUS particularly valuable for developers building applications that require efficient audio streaming, VoIP solutions, or any scenario where audio quality and bandwidth efficiency are crucial considerations.

## Implementing OPUS in Cross-Platform .NET Applications

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

When working with VisioForge's cross-platform X-engines, developers can leverage the [OPUSEncoderSettings](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.AudioEncoders.OPUSEncoderSettings.html) class to configure OPUS encoding parameters precisely for their application needs.

### Essential OPUS Encoder Configuration Properties

To achieve optimal results with the OPUS encoder, understanding and configuring these key properties is essential:

- **Bitrate**: Sets the target bitrate in Kbps, determining the balance between quality and file size
- **Rate Control Mode**: Selects between Variable Bitrate (VBR), Constant Bitrate (CBR), or Constrained Variable Bitrate (CVBR)
- **Complexity**: Controls encoding complexity on a scale from 0-10, where higher values produce better quality at the expense of increased CPU usage
- **Frame Duration**: Configures the frame size (2.5, 5, 10, 20, 40, or 60ms), with shorter frames providing lower latency at the cost of encoding efficiency
- **Application Type**: Optimizes for either voice or music content, allowing the encoder to apply specialized techniques
- **Forward Error Correction**: Enables packet loss resilience for streaming applications
- **DTX (Discontinuous Transmission)**: Reduces bandwidth during silence periods

Each of these parameters can significantly impact audio quality, processing requirements, and bandwidth consumption, making them critical considerations for developers optimizing for specific application scenarios.

## Understanding Bitrate Control Modes in Depth

One of the most important decisions when implementing OPUS encoding is selecting the appropriate bitrate control strategy. OPUS offers three primary modes, each with distinct advantages for different use cases.

### Variable Bitrate (VBR)

VBR represents the most efficient approach for quality optimization, allowing the encoder to dynamically adjust bitrate based on audio complexity. This results in higher bitrates for complex passages and lower bitrates for simpler content.

```
// Create an instance of the OPUSEncoderSettings class.
var opus = new OPUSEncoderSettings();

// Set rate control mode to VBR
opus.RateControl = OPUSRateControl.VBR;

// Set audio bitrate for the codec (in Kbps)
opus.Bitrate = 128;
```

**Best for**: On-demand audio streaming, podcast distribution, music applications, and any scenario where consistent bandwidth isn't a primary concern.

**Key advantage**: Provides the highest quality-to-size ratio by allocating more bits to complex audio sections.

### Constant Bitrate (CBR)

CBR mode attempts to maintain a consistent bitrate throughout the encoding process. While OPUS is inherently a variable bitrate codec, its CBR implementation keeps fluctuations minimal, typically within 5% of the target.

```
// Create an instance of the OPUSEncoderSettings class.
var opus = new OPUSEncoderSettings();

// Set rate control mode to CBR
opus.RateControl = OPUSRateControl.CBR;

// Set audio bitrate for the codec (in Kbps)
opus.Bitrate = 128;
```

**Best for**: Live streaming applications, VoIP systems, videoconferencing, and scenarios where network bandwidth predictability is critical.

**Key advantage**: Maintains consistent bandwidth utilization, making it easier to plan network capacity and ensure reliable transmission.

### Constrained Variable Bitrate (CVBR)

CVBR offers a middle-ground approach, allowing bitrate variations based on content complexity while imposing constraints to prevent extreme fluctuations. This provides many of VBR's quality benefits while keeping bandwidth requirements more predictable.

```
// Create an instance of the OPUSEncoderSettings class.
var opus = new OPUSEncoderSettings();

// Set rate control mode to Constrained VBR
opus.RateControl = OPUSRateControl.ConstrainedVBR;

// Set audio bitrate for the codec (in Kbps)
opus.Bitrate = 128;
```

**Best for**: Adaptive streaming applications, mixed-content broadcasting, and scenarios where quality is important but bandwidth constraints still exist.

**Key advantage**: Balances quality optimization with reasonable bandwidth predictability.

## Bitrate Selection Guidelines

Setting an appropriate bitrate involves balancing quality requirements against bandwidth limitations. For OPUS encoding, consider these channel-specific recommendations:

**For Mono Audio:**

- 6-12 kbps: Acceptable for low-bitrate speech
- 16-24 kbps: Good quality speech
- 32-64 kbps: High-quality speech and acceptable music
- 64-128 kbps: High-quality music

**For Stereo Audio:**

- 16-32 kbps: Low-quality stereo
- 48-64 kbps: Good quality stereo speech
- 64-128 kbps: Standard quality stereo music
- 128-256 kbps: High-quality stereo music

While OPUS can technically support bitrates up to 510 kbps, most applications achieve excellent results well below 192 kbps due to the codec's exceptional efficiency.

## Practical Implementation Examples

### Implementing OPUS in Video Capture Applications

The following example demonstrates how to add OPUS output to a Video Capture SDK core instance:

```
// Create a Video Capture SDK core instance
var core = new VideoCaptureCoreX();

// Create a OPUS output instance
var opusOutput = new OPUSOutput("output.opus");

// Set the bitrate and rate control mode
opusOutput.Audio.RateControl = OPUSRateControl.CBR;
opusOutput.Audio.Bitrate = 128;

// Add the OPUS output
core.Outputs_Add(opusOutput, true);
```

### Configuring OPUS for Video Editing Workflows

When working with the Video Edit SDK, you can configure OPUS as your output format:

```
// Create a Video Edit SDK core instance
var core = new VideoEditCoreX();

// Create a OPUS output instance
var opusOutput = new OPUSOutput("output.opus");

// Set the bitrate for high-quality music encoding
opusOutput.Audio.RateControl = OPUSRateControl.VBR;
opusOutput.Audio.Bitrate = 192;

// Set the output format
core.Output_Format = opusOutput;
```

### Creating OPUS Outputs with Media Blocks SDK

The Media Blocks SDK offers flexible options for creating OPUS outputs in different container formats:

```
// Create a OPUS encoder settings instance with specific configuration
var opusSettings = new OPUSEncoderSettings
{
    Bitrate = 128,
    RateControl = OPUSRateControl.VBR,
    Complexity = 8
};

// Create an Ogg OPUS output instance (opus + ogg container)
var oggOpusOutput = new OGGOpusOutputBlock("output.ogg", opusSettings);
```

## Performance Optimization Tips

To achieve the best results with OPUS encoding in your .NET applications:

1. **Match Complexity to Your Hardware**: For real-time applications on limited hardware, use lower complexity values (3-6). For offline encoding or on powerful systems, higher values (7-10) will yield better quality.
2. **Select Appropriate Frame Duration**: Shorter frames (2.5-10ms) minimize latency for real-time communication, while longer frames (20-60ms) improve compression efficiency for music and stored content.
3. **Consider Input Sample Rate**: OPUS performs optimally with 48kHz input. If your source is at a different sample rate, consider resampling to 48kHz before encoding.
4. **Optimize for Content Type**: Use the Application property to tell the encoder whether you're primarily encoding speech or music for content-specific optimizations.
5. **Enable DTX for Speech**: For voice communications with frequent silence, enabling DTX can significantly reduce bandwidth requirements without noticeable quality impact.

## Conclusion

The OPUS codec offers .NET developers an exceptional tool for creating high-quality, bandwidth-efficient audio applications. With VisioForge's SDKs, implementing OPUS encoding becomes straightforward while still providing the flexibility to fine-tune every aspect of the encoding process.

By understanding the bitrate control modes, selecting appropriate parameters, and following the implementation examples provided, you can leverage OPUS to deliver superior audio experiences in your .NET applications regardless of whether you're building real-time communication tools, media players, or content creation software.

---END OF PAGE---


## Speex Speech Audio Encoder Integration for .NET SDK
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-encoders/speex/
**Description:** Implement Speex speech compression in .NET with optimized voice encoding settings, quality controls, and cross-platform audio capture.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, Speex, C#
**API:** SpeexEncoderSettings, VideoCaptureCoreX, VideoEditCoreX, MediaBlocksPipeline, SpeexOutput

# Speex Audio Encoder for .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to Speex

Speex is a patent-free audio codec specifically designed for speech encoding in .NET applications. Whether you need to capture, edit, or record audio in C#, Speex provides excellent compression while maintaining voice quality across various bitrates. VisioForge integrates this powerful encoder into its .NET SDKs, offering developers flexible configuration options for speech-based applications. The codec is particularly well-suited for C# developers looking to implement high-quality audio capture and recording features in their applications.

## Core Functionality

The Speex encoder in VisioForge SDKs supports:

- Multiple frequency bands for different quality levels
- Variable and fixed bitrate encoding
- Voice activity detection and silence compression
- Adjustable complexity and quality settings
- Cross-platform compatibility across Windows, macOS, and Linux
- Seamless integration with dotnet applications

## Cross-platform Implementation

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

### Encoder Modes

Speex offers four operation modes optimized for different frequency ranges:

| Mode | Value | Optimal Sample Rate |
| --- | --- | --- |
| Auto | 0 | Automatic selection based on input |
| Ultra Wide Band | 1 | 32 kHz |
| Wide Band | 2 | 16 kHz |
| Narrow Band | 3 | 8 kHz |

The encoder automatically adjusts internal parameters based on the selected mode. For most speech applications, Wide Band (mode 2) offers an excellent balance between quality and bandwidth usage.

## Technical Specifications

### Supported Sample Rates

Speex works with three standard sampling frequencies:

- 8,000 Hz - Best for telephone-quality audio (Narrow Band)
- 16,000 Hz - Recommended for most voice applications (Wide Band)
- 32,000 Hz - Highest quality speech encoding (Ultra Wide Band)

### Channel Configuration

The encoder handles both:

- Mono (1 channel) - Ideal for speech recordings
- Stereo (2 channels) - For multi-speaker or immersive audio

## Rate Control Methods

### Quality-Based Encoding

For consistent perceptual quality, use the `Quality` parameter:

```
var settings = new SpeexEncoderSettings {
    Quality = 8.0f, // Range from 0 (lowest) to 10 (highest)
    VBR = false     // Fixed quality mode
};
```

Higher quality values produce better audio at the expense of increased file size. Most speech applications work well with quality values between 5-8.

### Variable Bit Rate (VBR)

VBR dynamically adjusts the bitrate based on speech complexity:

```
var settings = new SpeexEncoderSettings {
    VBR = true,
    Quality = 8.0f  // Target quality level
};
```

This approach typically saves bandwidth while maintaining consistent perceived quality, making it ideal for streaming applications.

### Average Bit Rate (ABR)

ABR maintains a target bitrate over time while allowing quality fluctuations:

```
var settings = new SpeexEncoderSettings {
    ABR = 15.0f,   // Target bitrate in kbps
    VBR = true     // Required for ABR mode
};
```

This option works well when you need predictable file sizes or bandwidth usage.

### Fixed Bitrate Encoding

For consistent data rates throughout the encoding process:

```
var settings = new SpeexEncoderSettings {
    Bitrate = 24.6f,  // Fixed rate in kbps
    VBR = false
};
```

Supported bitrates range from 2.15 kbps to 24.6 kbps:

- 2.15 kbps - Ultra-compressed speech (limited quality)
- 3.95 kbps - Low bandwidth voice
- 5.95 kbps - Basic speech clarity
- 8.00 kbps - Standard voice quality
- 11.0 kbps - Good speech reproduction
- 15.0 kbps - Near-transparent speech
- 18.2 kbps - High-quality voice
- 24.6 kbps - Maximum quality speech

## Voice Optimization Features

### Voice Activity Detection (VAD)

VAD identifies the presence of speech in audio signals:

```
var settings = new SpeexEncoderSettings {
    VAD = true,    // Enable voice detection
    DTX = true     // Recommended with VAD
};
```

This feature improves bandwidth efficiency by focusing encoding resources on actual speech segments.

### Discontinuous Transmission (DTX)

DTX reduces data transmission during silence periods:

```
var settings = new SpeexEncoderSettings {
    DTX = true     // Enable silence compression
};
```

For VoIP and real-time communications, enabling DTX can significantly reduce bandwidth requirements.

### Encoding Complexity

Control CPU usage versus encoding quality:

```
var settings = new SpeexEncoderSettings {
    Complexity = 3  // Range: 1 (fastest) to 10 (highest quality)
};
```

Lower values prioritize speed and reduce CPU load, while higher values improve audio quality at the cost of performance.

## Implementation Examples

### Checking Encoder Availability

Always verify encoder availability before implementing Speex in your C# application:

```
if (!SpeexEncoderSettings.IsAvailable())
{
    throw new InvalidOperationException("Speex encoder not available on this system.");
}
```

### Basic Configuration for Audio Capture

Here's how to set up basic Speex encoding for audio capture in dotnet:

```
var encoderSettings = new SpeexEncoderSettings
{
    Mode = SpeexEncoderMode.WideBand,
    SampleRate = 16000,
    Channels = 1,
    Quality = 7.0f
};
```

### Optimized for Voice Recording

For voice recording applications in .NET, use these optimized settings:

```
var voipSettings = new SpeexEncoderSettings
{
    Mode = SpeexEncoderMode.WideBand,
    SampleRate = 16000,
    Channels = 1,
    VBR = true,
    VAD = true,
    DTX = true,
    Quality = 6.0f,
    Complexity = 4
};
```

### Highest Quality Audio Capture

For maximum quality audio capture in dotnet:

```
var highQualitySettings = new SpeexEncoderSettings
{
    Mode = SpeexEncoderMode.UltraWideBand,
    SampleRate = 32000,
    Channels = 2,
    Bitrate = 24.6f,
    Complexity = 8
};
```

## SDK Integration

### Video Capture SDK Integration

Learn how to capture audio using Speex in your C# application:

```
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;

// Create a Video Capture SDK core instance
var core = new VideoCaptureCoreX();

// Set the audio input device, filter by API
var api = AudioCaptureDeviceAPI.DirectSound;
var audioInputDevice = (await DeviceEnumerator.Shared.AudioSourcesAsync()).FirstOrDefault(x => x.API == api);
if (audioInputDevice == null)
{
    MessageBox.Show("No audio input device found.");
    return;
}

var audioInput = new AudioCaptureDeviceSourceSettings(api, audioInputDevice, audioInputDevice.GetDefaultFormat());

core.Audio_Source = audioInput;

// Configure Speex settings
var speexSettings = new SpeexEncoderSettings
{
    Mode = SpeexEncoderMode.WideBand,
    SampleRate = 16000,
    Channels = 1,
    VBR = true,
    Quality = 7.0f
};

var speexOutput = new SpeexOutput("output.spx", speexSettings);

// Add the Speex output
core.Outputs_Add(speexOutput, true);

// Set the audio record mode
core.Audio_Record = true;
core.Audio_Play = false;

// Start the capture
await core.StartAsync();

// Stop after 10 seconds
await Task.Delay(10000);

// Stop the capture
await core.StopAsync();
```

### Video Edit SDK Integration

Edit and process audio files using Speex in dotnet:

```
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;

// Create a Video Edit SDK core instance
var core = new VideoEditCoreX();

// Add the audio source file
var audioFile = new AudioFileSource(@"c:\samples\!audio.mp3");
core.Input_AddAudioFile(audioFile, null);

// Configure Speex settings
var speexSettings = new SpeexEncoderSettings
{
    Mode = SpeexEncoderMode.WideBand,
    SampleRate = 16000,
    Channels = 1,
    VBR = true,
    Quality = 7.0f
};

var speexOutput = new SpeexOutput(@"output.spx", speexSettings);

// Add the Speex output
core.Output_Format = speexOutput;

// Catch OnStop event
core.OnStop += (s, e) =>
{
    // Handle the stop event here
    MessageBox.Show("Editing complete.");
};

core.OnProgress += (s, e) =>
{
    // Handle progress updates here
    Debug.WriteLine($"Progress: {e.Progress}%");
};

core.OnError += (s, e) =>
{
    // Handle errors here
    Debug.WriteLine($"Error: {e.Message}");
};

// Start the editing
core.Start();
```

### Media Blocks SDK Integration

Process audio streams using Speex in your .NET application:

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AudioEncoders;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;

using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;

// Create a new pipeline
var pipeline = new MediaBlocksPipeline();

// Add universal source to read audio file
var sourceSettings = await UniversalSourceSettings.CreateAsync(@"c:\samples\!audio.mp3", renderVideo: false, renderAudio: true);
var source = new UniversalSourceBlock(sourceSettings);

// Add Speex output
var speexSettings = new SpeexEncoderSettings
{
    Mode = SpeexEncoderMode.NarrowBand,
    SampleRate = 8000,
    DTX = true,
    VAD = true
};

var speexOutput = new OGGSpeexOutputBlock("output.spx", speexSettings);

// Connect
pipeline.Connect(source.AudioOutput, speexOutput.Input);

// Add OnStop event handler
pipeline.OnStop += (sender, e) =>
{
    // Do something when the pipeline stops
    MessageBox.Show("Conversion complete");
};

// Start
await pipeline.StartAsync();
```

## Performance Optimization

When implementing Speex encoding, consider these optimization strategies:

1. **Match sample rate to content** - Use Narrow Band (8 kHz) for telephone audio, Wide Band (16 kHz) for most voice applications, and Ultra Wide Band (32 kHz) only when maximum quality is required
2. **Enable VBR with VAD/DTX** for speech content - This combination provides optimal bandwidth efficiency for typical voice recordings
3. **Adjust complexity based on platform** - Mobile applications may benefit from lower complexity values (2-4), while desktop applications can use higher values (5-8)
4. **Use ABR for streaming** - Average Bit Rate provides predictable bandwidth usage while maintaining quality flexibility
5. **Test different quality settings** - Often a quality setting of 5-7 provides excellent results without excessive file size

## Use Cases

Speex encoding excels in these developer scenarios:

- VoIP applications and internet telephony
- Voice chat features in games and collaboration tools
- Podcast creation and distribution
- Speech recognition preprocessing
- Voice note applications
- Audio archiving of speech content

## Installation and Setup

To get started with Speex in your dotnet application, check the main installation guide [here](../../../install/).

## Common Use Cases

### Audio Capture and Recording

For streaming applications, use these optimized settings:

```
var streamingSettings = new SpeexEncoderSettings
{
    Mode = SpeexEncoderMode.WideBand,
    SampleRate = 16000,
    Channels = 1,
    VBR = true,
    VAD = true,
    DTX = true,
    Quality = 6.0f,
    Complexity = 3
};
```

### Voice Over IP Applications

For VoIP applications, prioritize low latency and bandwidth efficiency:

```
var voipSettings = new SpeexEncoderSettings
{
    Mode = SpeexEncoderMode.NarrowBand,
    SampleRate = 8000,
    Channels = 1,
    VBR = true,
    VAD = true,
    DTX = true,
    Quality = 5.0f,
    Complexity = 2
};
```

## Licensing and Community

Speex is released under the BSD license, making it free for both commercial and non-commercial use. The codec is actively maintained by the open-source community, with regular updates and improvements.

## Frequently Asked Questions

### What is the best bitrate for voice recording?

For most voice applications, a bitrate between 8-15 kbps provides excellent quality while maintaining reasonable file sizes. Use VBR mode for optimal results.

### How does Speex compare to other codecs?

Speex offers superior speech quality compared to many other codecs at similar bitrates, especially for voice content. It's particularly effective for low-bitrate applications.

### Can I use Speex for music encoding?

While Speex can encode music, it's specifically optimized for speech. For music content, consider using other codecs like AAC or MP3.

## Conclusion

The VisioForge implementation of Speex provides .NET developers with a powerful tool for capturing, editing, and recording audio in C# applications. Whether you're building a new voice capture application or enhancing an existing one, Speex delivers exceptional results with minimal resource usage. The codec's flexibility and performance make it an excellent choice for any .NET developer working with audio processing.

---END OF PAGE---


## Vorbis Audio Encoding Guide for .NET SDK Development
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-encoders/vorbis/
**Description:** Implement Vorbis audio encoding in .NET with quality optimization, cross-platform support, and efficient compression for streaming.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, WebM, OGG, Vorbis, C#
**API:** OGGVorbisOutput, VorbisEncoderSettings, WebMOutput, VideoCaptureCore, VideoEditCore

# Vorbis Audio Encoding for .NET Developers

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to Vorbis in VisioForge SDK

The VisioForge SDK suite offers powerful Vorbis audio encoding capabilities that enable developers to implement high-quality audio compression in their .NET applications. Vorbis, an open-source audio codec, delivers exceptional audio fidelity with efficient compression ratios, making it ideal for streaming applications, multimedia content, and web audio.

This guide will help you navigate the various Vorbis implementation options available in the VisioForge SDK ecosystem, providing practical code examples and optimization strategies for different use cases.

## Vorbis Encoder Options

The SDK exposes three distinct APIs for Vorbis encoding. Two are Windows-classic (`VideoCaptureCore` / `VideoEditCore`) and one is cross-platform (`VideoCaptureCoreX` / `VideoEditCoreX` / `MediaBlocksPipeline`).

### Implementation Options

#### 1. WebM Container with Vorbis Audio (Windows classic)

The [`WebMOutput`](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.WebMOutput.html) class in namespace `VisioForge.Core.Types.X.Output` encapsulates Vorbis audio within the WebM container format. Runs on Windows only (DirectShow).

#### 2. OGG Vorbis Dedicated Output (Windows classic)

The [`OGGVorbisOutput`](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.OGGVorbisOutput.html) class in namespace `VisioForge.Core.Types.X.Output` provides detailed control over VBR/bitrate modes for OGG-containerised Vorbis. Windows only.

#### 3. Flexible VorbisEncoderSettings (cross-platform)

The [`VorbisEncoderSettings`](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.AudioEncoders.VorbisEncoderSettings.html) class in namespace `VisioForge.Core.Types.X.AudioEncoders` drives Vorbis encoding on the X engines (`VideoCaptureCoreX`, `VideoEditCoreX`) and Media Blocks (`VorbisEncoderBlock`). This is the recommended path for cross-platform projects.

### Rate Control Strategies

Choosing the appropriate rate control mode is crucial for balancing audio quality against file size requirements. Vorbis encoding in VisioForge supports two primary approaches:

#### Quality-Based Variable Bit Rate (VBR)

Quality-based VBR is the recommended approach for most applications, as it dynamically adjusts bitrate to maintain consistent perceptual quality throughout the audio stream.

WebMOutputOGGVorbisOutputVorbisEncoderSettings

WebMOutput implements a simplified quality-based approach with an easy-to-understand scale:

```
// Create and configure WebM output with high-quality Vorbis audio
var webmOutput = new WebMOutput();

// Quality range: 20 (lowest) to 100 (highest)
// Values 70-80 provide excellent quality for most content
webmOutput.Audio_Quality = 80;

// Higher values produce better audio quality with larger files
// Lower values prioritize file size over audio fidelity
```

Key considerations:

- Quality setting directly impacts perceived audio quality and file size
- Values around 70-80 work well for most professional content
- Lower settings (40-60) may be suitable for voice-only recordings

OGGVorbisOutput offers more explicit quality mode selection:

```
// Initialize OGG Vorbis output for quality-focused encoding
var oggOutput = new OGGVorbisOutput();

// Set the encoding mode to quality-based VBR
oggOutput.Mode = VorbisMode.Quality;

// Configure quality level (range: 20-100)
// 80: High quality for music and complex audio
// 60: Good quality for general purpose use
// 40: Acceptable quality for voice recordings
oggOutput.Quality = 80;
```

This implementation gives you direct control over the quality-to-size tradeoff, making it ideal for applications with varying content types.

VorbisEncoderSettings uses the native Vorbis quality scale:

```
// Create Vorbis encoder with quality-based rate control
var vorbisEncoder = new VorbisEncoderSettings();

// Set rate control mode to quality-based VBR
vorbisEncoder.RateControl = VorbisEncoderRateControl.Quality;

// Configure quality level using Vorbis scale (-1 to 10)
// -1: Very low quality (~45 kbps)
// 3: Good quality (~112 kbps)
// 5: Very good quality (~160 kbps)
// 8: Excellent quality (~224 kbps)
// 10: Highest quality (~320 kbps)
vorbisEncoder.Quality = 5;
```

The VorbisEncoderSettings implementation provides the most precise quality control, using the established Vorbis quality scale that audio engineers are familiar with.

#### Bitrate-Constrained Encoding

For scenarios with specific bandwidth limitations or target file sizes, bitrate-constrained encoding offers more predictable output sizes.

WebMOutputOGGVorbisOutputVorbisEncoderSettings

WebMOutput does not support explicit bitrate control for Vorbis audio. Developers should use the quality parameter instead and test to determine the resulting bitrates.

OGGVorbisOutput provides comprehensive bitrate management tools:

```
// Set up OGG output with specific bitrate constraints
var oggOutput = new OGGVorbisOutput();

// Enable bitrate-controlled encoding mode
oggOutput.Mode = VorbisMode.Bitrate;

// Configure bitrate parameters (all values in Kbps)
oggOutput.MinBitRate = 96;     // Minimum bitrate floor
oggOutput.AvgBitRate = 160;    // Target average bitrate
oggOutput.MaxBitRate = 240;    // Maximum bitrate ceiling

// These settings create a controlled VBR encode that
// averages 160 Kbps but can fluctuate between limits
```

This approach is ideal for streaming applications where bandwidth prediction is important.

VorbisEncoderSettings offers the most detailed bitrate control options:

```
// Initialize Vorbis encoder with bitrate constraints
var vorbisEncoder = new VorbisEncoderSettings();

// Set rate control mode to bitrate-based
vorbisEncoder.RateControl = VorbisEncoderRateControl.Bitrate;

// Configure bitrate parameters (all values in Kbps; valid range 16-240)
vorbisEncoder.Bitrate = 192;      // Target average bitrate
vorbisEncoder.MinBitrate = 128;   // Minimum allowed bitrate
vorbisEncoder.MaxBitrate = 240;   // Maximum allowed bitrate

// These settings are ideal for applications requiring
// predictable file sizes or streaming bandwidth
```

The flexible bitrate controls allow for precise audio encoding tailored to specific delivery requirements.

Check the [VorbisEncoderBlock](../../../mediablocks/AudioEncoders/) and [OGGSinkBlock](../../../mediablocks/Sinks/) for more information.

### Best Practices for Developers

To achieve optimal results with Vorbis encoding in your .NET applications, consider these developer-focused recommendations:

#### Choosing the Right Encoding Mode

1. **Default choice: Quality-based VBR**
2. Produces consistent perceived quality across varying content
3. Automatically optimizes bitrate based on audio complexity
4. Simplifies configuration with a single quality parameter
5. **When to use Bitrate-constrained mode:**
6. Streaming applications with bandwidth limitations
7. Storage-constrained environments with fixed size allocations
8. Content delivery networks with predictable bandwidth requirements

#### Recommended Settings for Common Use Cases

| Content Type | Recommended Settings |
| --- | --- |
| Music (high quality) | WebM: Audio\_Quality = 80 OGG: Quality = 80 VorbisEncoder: Quality = 6 |
| Voice recordings | WebM: Audio\_Quality = 60 OGG: Quality = 60 VorbisEncoder: Quality = 3 |
| Mixed content | WebM: Audio\_Quality = 70 OGG: Quality = 70 VorbisEncoder: Quality = 4 |
| Streaming audio | OGG: Mode = Bitrate, AvgBitRate = 128 VorbisEncoder: RateControl = Bitrate, Bitrate = 128 |

## Windows-only output

[VideoCaptureCore](#) [VideoEditCore](#)

The `OGGVorbisOutput` class provides configuration and functionality for encoding audio using the Vorbis codec.

### Class Details

```
public sealed class OGGVorbisOutput : IVideoEditBaseOutput, IVideoCaptureBaseOutput
```

The class implements two interfaces:

- `IVideoEditBaseOutput`: Enables use in video editing scenarios
- `IVideoCaptureBaseOutput`: Enables use in video capture scenarios

### Bitrate Controls

When operating in Bitrate mode, these properties control the output bitrate constraints:

#### AvgBitRate

- Type: `int`
- Default Value: 128 (Kbps)
- Description: Specifies the target average bitrate for the encoded audio stream. This value represents the general quality level and file size trade-off.

#### MaxBitRate

- Type: `int`
- Default Value: 192 (Kbps)
- Description: Defines the maximum allowed bitrate during encoding. Useful for ensuring the encoded audio doesn't exceed bandwidth constraints.

#### MinBitRate

- Type: `int`
- Default Value: 64 (Kbps)
- Description: Sets the minimum allowed bitrate during encoding. Helps maintain a baseline quality level even during simple audio passages.

### Quality Controls

#### Quality

- Type: `int`
- Default Value: 80
- Valid Range: 10-100
- Description: When operating in Quality mode, this value determines the encoding quality. Higher values result in better audio quality but larger file sizes.

#### Mode

- Type: `VorbisMode` (enum)
- Default Value: `VorbisMode.Bitrate`
- Options:
- `VorbisMode.Quality`: Encoding focuses on maintaining a consistent quality level
- `VorbisMode.Bitrate`: Encoding focuses on maintaining specified bitrate constraints

### Constructor

```
public OGGVorbisOutput()
```

Initializes a new instance with default values:

- MinBitRate: 64 kbps
- AvgBitRate: 128 kbps
- MaxBitRate: 192 kbps
- Quality: 80
- Mode: VorbisMode.Bitrate

### Serialization Methods

#### Save()

```
public string Save()
```

Serializes the current configuration to a JSON string, allowing settings to be saved and restored later.

#### Load(string json)

```
public static OGGVorbisOutput Load(string json)
```

Creates a new instance with settings deserialized from the provided JSON string.

### Usage Examples

#### Basic Usage with Default Settings

```
var oggOutput = new OGGVorbisOutput();
// Ready to use with default settings (Bitrate mode, 128kbps average)
```

#### Quality-Based Encoding

```
var oggOutput = new OGGVorbisOutput
{
    Mode = VorbisMode.Quality,
    Quality = 90  // High quality setting
};
```

#### Constrained Bitrate Encoding

```
var oggOutput = new OGGVorbisOutput
{
    Mode = VorbisMode.Bitrate,
    MinBitRate = 96,    // Minimum 96kbps
    AvgBitRate = 160,   // Target 160kbps
    MaxBitRate = 240    // Maximum 240kbps
};
```

#### Saving and Loading Configuration

```
// Save configuration
var oggOutput = new OGGVorbisOutput();
string savedConfig = oggOutput.Save();
```

```
// Load configuration
var loadedOutput = OGGVorbisOutput.Load(savedConfig);
```

#### Apply settings to core instances

```
var core = new VideoCaptureCore();
core.Output_Filename = "output.ogg";
core.Output_Format = oggOutput;
```

```
var core = new VideoEditCore();
core.Output_Filename = "output.ogg";
core.Output_Format = oggOutput;
```

## Performance Considerations

When implementing Vorbis encoding in production environments:

- Encoding quality directly impacts CPU usage; higher quality settings require more processing power
- The VorbisEncoderSettings implementation offers the best balance of flexibility and performance
- Pre-configured profiles can help standardize output quality across different content types
- Consider multi-threaded encoding for batch processing applications

## Conclusion

Vorbis encoding provides an excellent open-source solution for high-quality audio compression in .NET applications. By understanding the different implementation options and configuration strategies available in the VisioForge SDK, developers can effectively balance audio quality, file size, and performance requirements for their specific use cases.

Whether you're building a streaming application, a media processing tool, or integrating audio capabilities into a larger software ecosystem, the Vorbis encoders in VisioForge's .NET SDKs offer the flexibility and performance needed for professional audio processing.

---END OF PAGE---


## WAV PCM Audio Encoder Settings and Code Examples for .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-encoders/wav/
**Description:** Implement WAV audio processing in .NET with sample rates, channel configuration, PCM format selection, and cross-platform support.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, WAV, C#
**API:** WAVEncoderSettings, VideoCaptureCoreX, VideoEditCoreX, MediaBlocksPipeline, WAVOutput

# Implementing WAV Audio in .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## What is WAV Format?

WAV (Waveform Audio File Format) functions as an uncompressed audio container format rather than a codec. It stores raw PCM (Pulse-Code Modulation) audio data in its native form. When working with VisioForge SDKs, the WAV output functionality allows developers to create high-quality audio files with configurable PCM settings. Since WAV preserves audio without compression, it maintains original sound quality at the cost of larger file sizes compared to compressed formats like MP3 or AAC.

## How WAV Files Work

The WAV format stores audio samples in their raw form. When your application outputs to WAV format, it performs three key operations:

1. Organizing raw PCM audio data into the WAV container structure
2. Defining interpretation parameters (sample rate, bit depth, and channel count)
3. Generating appropriate WAV headers and metadata

This uncompressed nature means file sizes are predictable and directly calculated from the audio parameters:

```
File size (bytes) = Sample Rate × Bit Depth × Channels × Duration / 8
```

For example, a one-minute stereo WAV file sampled at 44.1kHz with 16-bit samples consumes approximately 10.1 MB:

```
44100 × 16 × 2 × 60 / 8 = 10,584,000 bytes
```

## Cross-Platform WAV Implementation

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

### Key Features

- Flexible audio format configuration (default: S16LE)
- Adjustable sample rates ranging from 8kHz to 192kHz
- Support for both mono and stereo channel configurations
- Consistent audio quality across different platforms

### Configuration Parameters

#### Audio Format Options

The WAV encoder supports multiple audio formats through the `AudioFormatX` enum, with S16LE (16-bit Little-Endian) serving as the default format for maximum compatibility.

#### Sample Rate Selection

- Available range: 8,000 Hz to 192,000 Hz
- Default setting: 48,000 Hz
- Increment values: 8,000 Hz steps

#### Channel Configuration

- Available options: 1 (mono) or 2 (stereo)
- Default setting: 2 (stereo)

### Implementation Examples

#### Basic Implementation

```
// Initialize WAV encoder with default settings
var wavEncoder = new WAVEncoderSettings();
```

```
// Initialize with custom configuration
var customWavEncoder = new WAVEncoderSettings(
    format: AudioFormatX.S16LE,
    sampleRate: 44100,
    channels: 2
);
```

#### Integration with Video Capture SDK

```
// Initialize Video Capture SDK core
var core = new VideoCaptureCoreX();

// Create WAV output with file path
var wavOutput = new WAVOutput("output.wav");

// Add output to the capture pipeline
core.Outputs_Add(wavOutput, true);
```

#### Integration with Video Edit SDK

```
// Initialize Video Edit SDK core
var core = new VideoEditCoreX();

// Create WAV output instance
var wavOutput = new WAVOutput("output.wav");

// Configure core to use WAV output
core.Output_Format = wavOutput;
```

#### Media Blocks Pipeline Configuration

```
// Initialize WAV encoder settings
var wavSettings = new WAVEncoderSettings();

// Create encoder block
var wavOutput = new WAVEncoderBlock(wavSettings);

// Add File Sink block for output
var fileSink = new FileSinkBlock("output.wav");

// Connect encoder to file sink in pipeline
pipeline.Connect(wavOutput.Output, fileSink.Input); // pipeline is MediaBlocksPipeline
```

#### Verifying Encoder Availability

```
if (WAVEncoderSettings.IsAvailable())
{
    // Encoder is available, proceed with encoding
    var encoder = new WAVEncoderSettings();
    // Configure and use encoder
}
else
{
    // Handle unavailability
    Console.WriteLine("WAV encoder is not available on this system");
}
```

#### Advanced Configuration

```
var wavEncoder = new WAVEncoderSettings
{
    Format = AudioFormatX.S16LE,
    SampleRate = 96000,
    Channels = 1  // Configure for mono audio
};
```

#### Creating an Encoder Block

```
var settings = new WAVEncoderSettings();
MediaBlock encoderBlock = settings.CreateBlock();
// Integrate the encoder block into your media pipeline
```

#### Retrieving Supported Parameters

```
// Get list of supported audio formats
IEnumerable<string> formats = WAVEncoderSettings.GetFormatList();

// Get available sample rates
var settings = new WAVEncoderSettings();
int[] sampleRates = settings.GetSupportedSampleRates();
// Returns array ranging from 8000 to 192000 in 8000 Hz increments

// Get supported channel configurations
int[] channels = settings.GetSupportedChannelCounts();
// Returns [1, 2] for mono and stereo options
```

## Windows-Specific WAV Implementation

[VideoCaptureCore](#) [VideoEditCore](#)

### Enumerating Available Audio Codecs

```
// core is an instance of VideoCaptureCore or VideoEditCore
foreach (var codec in core.Audio_Codecs)
{
    cbAudioCodecs.Items.Add(codec);
}
```

### Configuring Audio Settings

```
// Initialize ACM output for WAV
var acmOutput = new ACMOutput();

// Configure audio parameters
acmOutput.Channels = 2;
acmOutput.BPS = 16;
acmOutput.SampleRate = 44100;
acmOutput.Name = "PCM"; // codec name

// Set as output format
core.Output_Format = acmOutput;
```

### Specifying Output File

```
// Set output file path
core.Output_Filename = "output.wav";
```

### Starting Processing

```
// Begin capture or conversion operation
await core.StartAsync();
```

## Best Practices for WAV Implementation

### Sample Rate Selection Guidelines

The sample rate significantly impacts audio quality and file size:

- 8kHz: Suitable for basic voice recordings and telephony applications
- 16kHz: Improved voice quality for speech recognition systems
- 44.1kHz: Standard for CD-quality audio and music production
- 48kHz: Professional audio standard used in video production
- 96kHz+: High-resolution audio for professional sound engineering

For most applications, 44.1kHz or 48kHz provides excellent quality without excessive file sizes.

### Channel Configuration Strategy

Your channel selection should align with content requirements:

- **Mono (1 channel)**: Ideal for voice recordings, podcasts, or when storage space is limited
- **Stereo (2 channels)**: Essential for music, spatial audio, or any content where directional sound matters

### Format Selection Considerations

When selecting audio formats:

- S16LE (16-bit Little-Endian) offers the best compatibility across platforms
- Higher bit depths (24-bit, 32-bit) provide greater dynamic range for professional audio work
- Consider your target system's requirements and hardware capabilities

## Technical Limitations and Considerations

### File Size Implications

WAV files grow linearly with recording duration, which can present challenges:

- A 10-minute stereo recording at 44.1kHz/16-bit requires approximately 100MB
- For mobile or web applications, consider implementing size limits or compression options
- When streaming is required, compressed formats may be more appropriate

### Performance Factors

WAV processing has specific performance characteristics:

- Lower CPU usage during encoding compared to compressed formats
- Higher disk I/O requirements due to larger data volumes
- Memory buffer considerations for long recordings

## Conclusion

The WAV format provides developers with a reliable, high-quality audio output option within VisioForge .NET SDKs. Its uncompressed nature ensures pristine audio quality, making it ideal for applications where audio fidelity is paramount. By leveraging the configuration options and implementation approaches outlined above, developers can effectively integrate WAV audio functionality into their .NET applications while maintaining optimal performance and quality.

For most professional audio applications, WAV remains the format of choice during production and editing stages, even if compressed formats are used for final distribution. The flexibility and cross-platform compatibility of the VisioForge SDK's WAV implementation make it a valuable tool in any developer's audio processing toolkit.

---END OF PAGE---


## WavPack Audio Encoder Settings and Configuration in .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-encoders/wavpack/
**Description:** Implement WavPack lossless and hybrid lossy audio compression in .NET with quality settings, correction modes, and stereo encoding.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, WavPack, C#
**API:** WavPackEncoderSettings, VideoCaptureCoreX, VideoEditCoreX, MediaBlocksPipeline, WavPackOutput

# WavPack Audio Encoder for .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

## Introduction to WavPack

WavPack is a powerful audio codec that offers both lossless and hybrid lossy compression capabilities, making it highly versatile for different application requirements. The VisioForge.Core library provides a robust implementation of this codec for .NET developers seeking high-quality audio compression solutions.

With support for various quality levels, correction modes, and stereo encoding options, the WavPack encoder can handle multiple channel configurations while delivering excellent compression across a wide range of bitrates and sample rates.

## Getting Started with WavPack

### Basic Configuration

To begin using the WavPack encoder, you'll need to create an instance of the `WavPackEncoderSettings` class with your desired parameters:

```
var encoder = new WavPackEncoderSettings
{
    Mode = WavPackEncoderMode.Normal,
    JointStereoMode = WavPackEncoderJSMode.Auto,
    CorrectionMode = WavPackEncoderCorrectionMode.Off,
    MD5 = false
};
```

This simple configuration uses balanced compression settings and automatic stereo encoding mode selection, suitable for most general use cases.

### Compression Modes Explained

WavPack offers four distinct compression modes that balance processing speed against compression efficiency:

```
public enum WavPackEncoderMode
{
    Fast = 1,      // Prioritizes encoding speed
    Normal = 2,    // Balanced compression (default)
    High = 3,      // Higher compression ratio
    VeryHigh = 4   // Maximum compression
}
```

For applications where file size is critical, you can implement higher compression settings:

```
var encoder = new WavPackEncoderSettings
{
    Mode = WavPackEncoderMode.High,
    ExtraProcessing = 1 // Enables advanced filters for better compression
};
```

## Quality Control Options

### Bitrate-Based Encoding

The most straightforward method for controlling output quality is to specify a target bitrate:

```
var encoder = new WavPackEncoderSettings
{
    Bitrate = 192000 // 192 kbps
};
```

Key specifications for bitrate control:

- Valid range: 24,000 to 9,600,000 bits/second
- Setting values below 24,000 disables lossy encoding
- Enables the lossy encoding mode automatically

### Bits Per Sample Control

For more precise quality control, especially when maintaining consistent quality across different sample rates is important:

```
var encoder = new WavPackEncoderSettings
{
    BitsPerSample = 16.0 // Equivalent to 16-bit quality
};
```

Important notes:

- Values below 2.0 disable lossy encoding
- This approach maintains more consistent quality regardless of sample rate variations

## Advanced Encoding Features

### Stereo Encoding Options

WavPack provides three methods for encoding stereo content, each with different characteristics:

```
var encoder = new WavPackEncoderSettings
{
    JointStereoMode = WavPackEncoderJSMode.Auto
};
```

Available stereo encoding modes:

- `Auto`: Intelligently selects the optimal encoding method based on content
- `LeftRight`: Uses traditional left/right channel separation
- `MidSide`: Implements mid/side encoding which often yields better compression for stereo material

### Hybrid Correction Mode

One of WavPack's unique features is its hybrid mode, which generates a correction file alongside the main compressed file:

```
var encoder = new WavPackEncoderSettings
{
    CorrectionMode = WavPackEncoderCorrectionMode.Optimized,
    Bitrate = 192000 // Required when using correction modes
};
```

The available correction options:

- `Off`: Standard operation with no correction file
- `On`: Generates a standard correction file
- `Optimized`: Creates an optimization-focused correction file

Note that correction modes only function when lossy encoding is active, making them ideal for applications where initial file size is important but future lossless restoration might be needed.

## Technical Specifications

The WavPack encoder supports:

- Sample rates from 6,000 Hz to 192,000 Hz
- 1 to 8 audio channels
- Optional MD5 hash storage of raw samples for verification
- Additional processing options for quality enhancement

Before implementation, you can verify encoder availability in your environment:

```
if (WavPackEncoderSettings.IsAvailable())
{
    // Configure and use the encoder
    var encoder = new WavPackEncoderSettings
    {
        Mode = WavPackEncoderMode.Normal,
        Bitrate = 192000,
        MD5 = true
    };
}
```

## Implementation Examples

### Video Capture SDK Integration

```
// Initialize the Video Capture SDK core
var core = new VideoCaptureCoreX();

// Create a WavPack output instance
var wavPackOutput = new WavPackOutput("output.wv");

// Add the WavPack output to the capture pipeline
core.Outputs_Add(wavPackOutput, true);
```

### Video Edit SDK Integration

```
// Initialize the Video Edit SDK core
var core = new VideoEditCoreX();

// Create a WavPack output instance
var wavPackOutput = new WavPackOutput("output.wv");

// Set the output format
core.Output_Format = wavPackOutput;
```

### Media Blocks SDK Integration

```
// Configure WavPack encoder settings
var wavPackSettings = new WavPackEncoderSettings();

// Create the encoder block
var wavPackOutput = new WavPackEncoderBlock(wavPackSettings);

// Create a file output destination
var fileSink = new FileSinkBlock("output.wv");

// Connect the encoder to the file sink in the pipeline
pipeline.Connect(wavPackOutput.Output, fileSink.Input); // pipeline is MediaBlocksPipeline
```

## Optimization Strategies

### Performance vs. Quality

For optimal encoder performance and quality balance:

DefaultArchivalStreaming

- Use `Normal` mode for everyday encoding tasks
- Enable `ExtraProcessing` only when encoding time isn't critical
- Maintain `JointStereoMode` as `Auto` for most content types

- Implement `High` or `VeryHigh` mode for archival purposes
- Enable MD5 hash generation for content verification
- Consider lossless encoding for critical audio preservation

- Use `Fast` mode for real-time encoding scenarios
- Select an appropriate bitrate based on bandwidth constraints
- Disable additional processing features to minimize latency

## Best Practices

When implementing WavPack in your applications:

1. **Balance quality and performance** by selecting the appropriate compression mode based on your use case
2. **Leverage hybrid mode** when distributing lossy files that may need lossless restoration later
3. **Consider format compatibility** with your target platforms and playback environments
4. **Test thoroughly** across different audio content types to ensure optimal settings

## Conclusion

The WavPack encoder provides a versatile solution for audio compression in .NET applications. Whether you need archival-grade lossless compression or efficient lossy compression with future upgrade potential, the implementation in VisioForge's SDKs offers the flexibility and performance required by professional audio applications.

By understanding the various configuration options and implementation strategies outlined in this guide, you can effectively integrate WavPack encoding into your software development projects and deliver high-quality audio processing capabilities to your users.

---END OF PAGE---


## Windows Media Audio (WMA) Encoder Integration Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/general/audio-encoders/wma/
**Description:** Implement WMA audio encoding in .NET with cross-platform and Windows-specific approaches, bitrate controls, and codec configuration.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, MP3, WMA, C#
**API:** WMAOutput, WMAEncoderSettings, VideoCaptureCore, VideoEditCore, VideoCaptureCoreX

# Windows Media Audio encoder

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Windows Media Audio (WMA) is a popular audio codec developed by Microsoft for efficient audio compression. This documentation covers the WMA encoder implementations available in the VisioForge .Net SDKs.

## Overview

The VisioForge SDK provides two distinct approaches for WMA encoding: the platform-specific [WMAOutput](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.WMAOutput.html) for Windows environments and the cross-platform [WMAEncoderSettings](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.AudioEncoders.WMAEncoderSettings.html). Let's explore both implementations in detail to understand their capabilities and use cases.

## Cross-platform WMA output

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The `WMAEncoderSettings` provides a cross-platform solution for WMA encoding. This implementation is built on SDK and offers consistent behavior across different operating systems.

### Key Features

The encoder supports the following audio configurations:

- Sample rates: 44.1 kHz and 48 kHz
- Bitrates: 128, 192, 256, and 320 Kbps
- Channel configurations: Mono (1) and Stereo (2)

### Rate Control

The WMA encoder implements constant bitrate (CBR) encoding, allowing you to specify a fixed bitrate from the supported values. This ensures consistent audio quality and predictable file sizes throughout the encoded content.

### Usage Example

Add the WMA output to the Video Capture SDK core instance:

```
// Create a Video Capture SDK core instance
var core = new VideoCaptureCoreX();

// Create a WMA output
var wmaOutput = new WMAOutput("output.wma");
wmaOutput.Audio.SampleRate = 48000;
wmaOutput.Audio.Channels = 2;
wmaOutput.Audio.Bitrate = 320;

// Add the WMA output
core.Outputs_Add(wmaOutput, true);
```

Set the output format for the Video Edit SDK core instance:

```
// Create a Video Edit SDK core instance
var core = new VideoEditCoreX();

// Create a WMA output
var wmaOutput = new WMAOutput("output.wma");
wmaOutput.Audio.SampleRate = 48000;
wmaOutput.Audio.Channels = 2;
wmaOutput.Audio.Bitrate = 320;

// Add the WMA output
core.Output_Format = wmaOutput;
```

Create a Media Blocks WMA output instance:

```
// Create a WMA encoder settings instance
var wmaSettings = new WMAEncoderSettings();

// Create a WMA output instance
var wmaOutput = new WMAEncoderBlock(wmaSettings);

// Create a ASF output instance
var asfOutput = new ASFSinkBlock(new ASFSinkSettings("output.wma"));

// Connect the WMA encoder to the ASF output
pipeline.Connect(wmaOutput.Output, asfOutput.Input); // pipeline is MediaBlocksPipeline
```

Check if WMA encoding is available before you build the pipeline:

```
if (!WMAEncoderSettings.IsAvailable())
{
   // Handle error — the WMA encoder plugin is missing on this platform.
}
```

## Windows-only WMA output

[VideoCaptureCore](#) [VideoEditCore](#)

The `WMAOutput` class provides a comprehensive Windows-specific implementation with advanced features and configuration options. This implementation leverages the Windows Media Format SDK for optimal performance on Windows systems.

### Key Features

The Windows-specific implementation offers:

- Multiple profile support (internal, external, and custom)
- Language and localization settings
- Quality-based encoding
- Advanced bitrate control with peak bitrate settings
- Buffer size configuration

### Configuration Modes

The classic Windows implementation selects its encoder source via the `WMVMode` enum on `WMAOutput.Mode`:

- `WMVMode.InternalProfile` — pick a predefined Windows Media profile by name (simplest).
- `WMVMode.ExternalProfile` — load a `.prx` profile file from disk.
- `WMVMode.ExternalProfileFromText` — pass profile XML inline as a string.
- `WMVMode.CustomSettings` — drive all encoder parameters manually (quality, peak bitrate, buffer, etc.) through the `Custom_Audio_*` properties.
- `WMVMode.V8SystemProfile` — use a Windows Media Video 8 system profile for compatibility with older Windows Media systems (lower compression efficiency than WMV9; only when targeting legacy systems).

Rate control (CBR / VBR / quality-based VBR) is expressed through those `Custom_Audio_*` properties or baked into the chosen profile — it is not a separate enum.

### Usage Example

Here's how to set up the Windows-specific WMA encoder:

Use an internal profile for simple configuration

```
var wmaOutput = new WMAOutput
{
    // Use an internal profile for simple configuration
    Mode = WMVMode.InternalProfile,
    Internal_Profile_Name = "Windows Media Audio 9 High (192K)"
};

core.Output_Format = wmaOutput; // Core is VideoCaptureCore or VideoEditCore
```

Or configure custom settings

```
var wmaOutput = new WMAOutput
{
    Mode = WMVMode.CustomSettings,
    Custom_Audio_StreamPresent = true,
    Custom_Audio_Quality = 98,        // High quality setting
    Custom_Audio_PeakBitrate = 320,   // Maximum bitrate in Kbps
    Custom_Audio_PeakBufferSize = 3   // Buffer size for streaming
};

core.Output_Format = wmaOutput; // Core is VideoCaptureCore or VideoEditCore
```

### Profile Management

The Windows implementation supports three profile modes:

1. Internal Profiles:
2. Pre-configured profiles for common use cases
3. Access through `Internal_Profile_Name`
4. External Profiles:
5. Load profiles from external files
6. Configure using `External_Profile_FileName` or `External_Profile_Text`
7. Custom Profiles:
8. Fine-grained control over encoding parameters
9. Configure through Custom\_\* properties

## Best Practices

When implementing WMA encoding in your application:

1. For Windows applications requiring advanced features:
2. Use WMAOutput for access to Windows-specific optimizations
3. Consider saving configurations to JSON for reuse
4. Implement proper error handling for profile loading
5. For cross-platform applications:
6. Stick to WMAEncoderSettings for consistent behavior
7. Verify supported rates before setting configuration
8. Use the highest supported sample rate and bitrate for best quality

This documentation provides a foundation for implementing WMA encoding in your applications. The choice between cross-platform and Windows-specific implementations should be based on your application's requirements for platform support, encoding features, and quality control.

---END OF PAGE---


## Using Third-Party DirectShow Video Filters in .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/3rd-party-video-effects/
**Description:** Implement third-party DirectShow video filters in .NET with code examples, best practices, and troubleshooting for Video SDK platforms.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, DirectShow, Windows, C#

# Use Third-Party Video Filters in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction

Third-party video processing filters provide powerful capabilities for manipulating video streams in .NET applications. These filters can be seamlessly integrated into various SDK platforms including Video Capture SDK .Net, Media Player SDK .Net, and Video Edit SDK .Net to enhance your applications with advanced video processing features.

This guide explores how to implement, configure, and optimize third-party DirectShow filters within your .NET projects, providing you with the knowledge needed to create sophisticated video processing applications.

## Understanding DirectShow Filters

DirectShow filters are COM-based components that process media data within the DirectShow framework. They can perform various operations including:

- Video effects and transitions
- Color correction and grading
- Frame rate conversion
- Resolution changes
- Noise reduction
- Special effects processing

Before using third-party filters, it's important to understand how they operate within the DirectShow pipeline and how they interact with our SDK components.

## Prerequisites

To successfully implement third-party video processing filters in your .NET applications, you'll need:

1. The appropriate SDK (.NET Video Capture, Media Player, or Video Edit)
2. Third-party DirectShow filters of your choice
3. Administrative access for filter registration
4. Basic understanding of DirectShow architecture

## Filter Registration Process

DirectShow filters must be properly registered on the system before they can be used in your applications. This is typically done using the Windows registration utility:

```
regsvr32.exe path\to\your\filter.dll
```

Alternative COM registration methods can also be used, particularly in scenarios where:

- You need to register filters during application installation
- You're working in environments with limited user permissions
- You require silent registration as part of a deployment process

### Registration Troubleshooting

If filter registration fails, verify:

1. You have administrator privileges
2. The filter DLL is compatible with your system architecture (x86/x64)
3. All dependencies of the filter are available on the system
4. The filter is properly implemented as a COM object

## Implementation Guide

### Enumerating Available DirectShow Filters

Before adding filters to your processing chain, you may want to discover what filters are available on the system:

```
// DirectShow_Filters() returns ObservableCollection<string> — each entry is the filter name
foreach (var filterName in VideoCapture1.DirectShow_Filters())
{
    Console.WriteLine($"Filter Name: {filterName}");
    Console.WriteLine("----------------------------");
}
```

This code snippet allows you to inspect all registered DirectShow filters, helping you identify the correct filters to use in your application.

### Managing the Filter Chain

Before adding new filters, you may want to clear any existing filters from the processing chain:

```
// Remove all currently applied filters
VideoCapture1.Video_Filters_Clear();
```

This ensures you're starting with a clean processing pipeline and prevents unexpected interactions between filters.

### Adding Filters to Your Application

To add a third-party filter to your video processing pipeline:

```
// Ctor: CustomProcessingFilter(string name, Guid? clsid = null, bool beforeEffects = false)
// Use the filter name as registered in DirectShow; the SDK resolves the CLSID automatically.
var myFilter = new CustomProcessingFilter("My Effect Filter");

// Add the filter to the processing chain
VideoCapture1.Video_Filters_Add(myFilter);
```

`CustomProcessingFilter` only exposes `Name`, `CLSID`, and `BeforeEffects` — filter-specific parameters are configured on the underlying COM filter (see the Filter Parameters section below).

You can add multiple filters in sequence to create complex processing chains. The order of filters matters, as each filter processes the output of the previous one.

## Advanced Filter Configuration

### Filter Parameters

Most third-party filters expose configurable parameters via their own COM interfaces (e.g. `IPropertyBag`, `ISpecifyPropertyPages`, or a vendor-specific `ISomethingFilter`). These interfaces are reached through the underlying `IBaseFilter` instance once the graph is built — not through `CustomProcessingFilter`, which only carries the registration identity (`Name` / `CLSID`). Consult the filter vendor's documentation for the concrete interface and property names.

### Filter Ordering

The sequence of filters in your processing chain significantly impacts the final result:

```
// Example of a multi-filter processing chain
VideoCapture1.Video_Filters_Add(new CustomProcessingFilter("Noise Reduction"));
VideoCapture1.Video_Filters_Add(new CustomProcessingFilter("Color Enhancement"));
VideoCapture1.Video_Filters_Add(new CustomProcessingFilter("Sharpening"));
```

Experiment with different filter arrangements to achieve the desired effect. For example, applying noise reduction before sharpening usually produces better results than the reverse order.

## Performance Considerations

Third-party filters can impact application performance. Consider these optimization strategies:

1. Only enable filters when necessary
2. Use lower complexity filters for real-time processing
3. Consider the resolution and frame rate when applying multiple filters
4. Test performance with your target hardware configurations
5. Use profile-guided optimization when available

## Common Issues and Solutions

### Thread Safety

When working with filters in multi-threaded applications, ensure proper synchronization:

```
private readonly object _filterLock = new object();

public void RebuildFilterChain(IEnumerable<CustomProcessingFilter> filters)
{
    lock (_filterLock)
    {
        // VideoCaptureCore only exposes Add/Clear — rebuild the chain instead of removing a single filter.
        VideoCapture1.Video_Filters_Clear();
        foreach (var filter in filters)
        {
            VideoCapture1.Video_Filters_Add(filter);
        }
    }
}
```

## Required Components

To successfully deploy applications that use third-party video processing filters, ensure you include:

- SDK redistributables for your chosen platform
- Any dependencies required by the third-party filters
- Proper installation and registration scripts for the filters

## Conclusion

Third-party video processing filters offer powerful capabilities for enhancing your .NET video applications. By following the guidelines in this document, you can successfully integrate these filters into your projects, creating sophisticated video processing solutions.

Remember to test thoroughly with your target environment configurations to ensure optimal performance and compatibility.

---

For more code samples and implementation details, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## ASF and WMV File Indexing for .NET SDK Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/asf-wmv-files-indexing/
**Description:** Learn why ASF, WMV, and WMA files need indexing for reliable seeking, and how to add indexes before opening them in VisioForge .NET apps.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, DirectShow, Windows, WinForms, Streaming, WMV, WMA, C#

# ASF and WMV File Indexing in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

When working with Windows Media files in your .NET applications, you may encounter seeking problems with ASF, WMV, or WMA files that were produced without a proper index. This page explains the underlying issue and points to the right tool for building the index before VisioForge consumes the file.

## Understanding the indexing problem

ASF (Advanced Systems Format) is Microsoft's container format designed for streaming media; WMV (Windows Media Video) and WMA (Windows Media Audio) are built on it. Files lacking an index exhibit:

- Choppy or unpredictable seeking behaviour
- Inability to jump to specific timestamps
- Inconsistent playback when navigating through the file
- High overhead during random access

An ASF index is a lookup table that maps timestamps (or frame numbers) to byte offsets in the file. When present, players can jump directly to any point in the stream; when absent, they must fall back to sequential parsing.

## Building an ASF index

VisioForge consumes ASF/WMV/WMA files once they are indexed, but it does not ship a public indexer on the managed surface. Build the index with one of the following external tools before handing the file to the SDK:

- **Windows Media Format SDK** (`IWMWriterFileSink` / `IWMIndexer` COM interfaces, available via `Microsoft.Windows.WindowsMedia.Format`). This is the canonical Microsoft path for offline indexing; the `IWMIndexer::StartIndexing` method writes a `WM/Index` object into the file.
- **Windows Media File Editor** (`WMFileEditor.exe`, part of the Windows Media Encoder 9 tools) for ad-hoc indexing during development.
- **`ffmpeg -i input.wmv -c copy -map 0 -f asf output.wmv`** — muxing through ffmpeg will rewrite the ASF container with a fresh index in most cases, without re-encoding.

Once the file carries a valid index, all VisioForge engines (`MediaPlayerCore`, `MediaPlayerCoreX`, `VideoEditCore`, `VideoEditCoreX`) will seek accurately and report consistent durations through the usual `Duration`/`Position_Get*` APIs.

## Best practices for ASF/WMV workflows

1. **Detect missing indexes up front.** If `Duration` is reported as zero or seeking returns the wrong frame, suspect a missing or corrupt ASF index.
2. **Index once per file.** Indexing rewrites the file on disk; do it as part of ingest, not at playback time.
3. **Cache indexed copies.** When a user loads an unindexed file, persist the indexed version to disk and point future sessions at it instead of re-indexing.
4. **Run indexing off the UI thread.** Large files can take several seconds to index; pipe the operation through `Task.Run` to keep your UI responsive.
5. **Prefer MP4 for new recordings.** If you control the capture pipeline, VisioForge's `MP4Output` produces seekable files without a separate indexing step.

## System requirements

Indexing is a Windows-only workflow because the ASF container itself is Windows Media technology:

- Windows Media Format SDK runtime (bundled with Windows 7 and later)
- Write access to the target file
- Enough free disk to rewrite the container (indexing appends metadata and, in some cases, re-serialises the stream)

## See also

- [WMV encoding reference](../../output-formats/wmv/) — configure VisioForge's WMV output to produce indexed files on capture.
- [Windows Media Format SDK — IWMIndexer](https://learn.microsoft.com/en-us/previous-versions/windows/desktop/api/wmsdkidl/nn-wmsdkidl-iwmindexer)
- [MP4 output](../../output-formats/mp4/) — a seek-friendly alternative for new projects.

---

For more code samples and advanced media processing techniques, check out our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Custom DirectShow Filter Interfaces Guide for .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/custom-filter-interface/
**Description:** Implement custom DirectShow filter interfaces in .NET with IBaseFilter access and manipulation for multimedia applications.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, DirectShow, VideoCaptureCore, Windows, Capture, C#, NuGet
**API:** IBaseFilter, FilterEventArgs, VideoCaptureCore

# Use Custom DirectShow Filter Interfaces

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

*Note: The API shown in this guide is the same across all our SDK products, including Video Capture SDK .Net, Video Edit SDK .Net, and Media Player SDK .Net.*

DirectShow is a powerful multimedia framework that allows developers to perform complex operations on media streams. One of its key strengths is the ability to work with custom filter interfaces, giving you precise control over media processing. This guide will walk you through implementing and utilizing custom DirectShow filter interfaces in your .NET applications.

## Understanding DirectShow Filters

DirectShow uses a filter-based architecture where each filter performs a specific operation on the media stream. These filters are connected in a graph, creating a pipeline for media processing.

### Key DirectShow Components

- **Filter**: A component that processes media data
- **Pin**: Connection points between filters
- **Filter Graph**: The complete pipeline of connected filters
- **IBaseFilter**: The fundamental interface that all DirectShow filters implement

## Getting Started with Custom Filter Interfaces

To work with DirectShow filters in .NET, you'll need to:

1. Add the proper references to your project
2. Access the filter through appropriate events
3. Cast the filter to the interface you need
4. Implement your custom logic

### Required Project References

To access DirectShow functionality, include the appropriate package in your project:

```
<PackageReference Include="VisioForge.DotNet.Core" Version="X.X.X" />
```

You can also add the `VisioForge.Core` assembly reference directly to your project.

## Implementing Custom Filter Interface Access

Our SDK provides several events that give you access to filters as they're added to the filter graph. Here's how to use them effectively:

### Accessing Filters in Video Capture SDK

The Video Capture SDK offers the `OnFilterAdded` event that fires whenever a filter is added to the graph. This event provides access to each filter through its event arguments.

```
// Subscribe to the OnFilterAdded event
videoCaptureCore.OnFilterAdded += VideoCaptureCore_OnFilterAdded;

// Event handler implementation
private void VideoCaptureCore_OnFilterAdded(object sender, FilterEventArgs eventArgs)
{
    // Access the DirectShow filter interface
    IBaseFilter baseFilter = eventArgs.Filter as IBaseFilter;

    // Now you can work with the filter through the IBaseFilter interface
    if (baseFilter != null)
    {
        // Custom filter manipulation code goes here
    }
}
```

## Working with IBaseFilter Interface

The `IBaseFilter` interface is the foundation of DirectShow filters. Here's what you can do with it:

### Retrieving Filter Information

```
private void GetFilterInfo(IBaseFilter filter)
{
    FilterInfo filterInfo = new FilterInfo();
    int hr = filter.QueryFilterInfo(out filterInfo);

    if (hr >= 0)
    {
        Console.WriteLine($"Filter Name: {filterInfo.achName}");

        // Don't forget to release the reference to the filter graph
        if (filterInfo.pGraph != null)
        {
            Marshal.ReleaseComObject(filterInfo.pGraph);
        }
    }
}
```

### Enumerating Filter Pins

```
private void EnumerateFilterPins(IBaseFilter filter)
{
    IEnumPins enumPins;
    int hr = filter.EnumPins(out enumPins);

    if (hr >= 0 && enumPins != null)
    {
        IPin[] pins = new IPin[1];
        int fetched;

        while (enumPins.Next(1, pins, out fetched) == 0 && fetched > 0)
        {
            PinInfo pinInfo = new PinInfo();
            pins[0].QueryPinInfo(out pinInfo);

            Console.WriteLine($"Pin Name: {pinInfo.name}, Direction: {pinInfo.dir}");

            // Release pin and info
            if (pinInfo.filter != null)
                Marshal.ReleaseComObject(pinInfo.filter);

            Marshal.ReleaseComObject(pins[0]);
        }

        Marshal.ReleaseComObject(enumPins);
    }
}
```

## Identifying the Right Filter

When working with the `OnFilterAdded` event, remember that it can be called multiple times as various filters are added to the graph. To work with a specific filter, you'll need to identify it correctly:

```
private void VideoCaptureCore_OnFilterAdded(object sender, FilterEventArgs eventArgs)
{
    IBaseFilter baseFilter = eventArgs.Filter as IBaseFilter;

    if (baseFilter != null)
    {
        FilterInfo filterInfo = new FilterInfo();
        baseFilter.QueryFilterInfo(out filterInfo);

        // Check if this is the filter we're looking for
        if (filterInfo.achName == "Video Capture Device")
        {
            // This is our target filter, perform specific operations
            ConfigureVideoCaptureFilter(baseFilter);
        }

        // Release the filter graph reference
        if (filterInfo.pGraph != null)
        {
            Marshal.ReleaseComObject(filterInfo.pGraph);
        }
    }
}
```

## Advanced Filter Configuration

Once you have access to the filter interface, you can perform advanced configurations:

### Setting Filter Properties

```
private void SetFilterProperty(IBaseFilter filter, Guid propertySet, int propertyId, object propertyValue)
{
    IKsPropertySet propertySetInterface = filter as IKsPropertySet;

    if (propertySetInterface != null)
    {
        // Convert property value to byte array
        byte[] propertyData = ConvertToByteArray(propertyValue);

        // Set the property
        int hr = propertySetInterface.Set(
            propertySet,
            propertyId,
            IntPtr.Zero,
            0,
            propertyData,
            propertyData.Length
        );

        Marshal.ReleaseComObject(propertySetInterface);
    }
}
```

### Retrieving Filter Properties

```
private object GetFilterProperty(IBaseFilter filter, Guid propertySet, int propertyId, Type propertyType)
{
    IKsPropertySet propertySetInterface = filter as IKsPropertySet;
    object result = null;

    if (propertySetInterface != null)
    {
        int dataSize = Marshal.SizeOf(propertyType);
        byte[] propertyData = new byte[dataSize];
        int returnedDataSize;

        // Get the property
        int hr = propertySetInterface.Get(
            propertySet,
            propertyId,
            IntPtr.Zero,
            0,
            propertyData,
            propertyData.Length,
            out returnedDataSize
        );

        if (hr >= 0)
        {
            result = ConvertFromByteArray(propertyData, propertyType);
        }

        Marshal.ReleaseComObject(propertySetInterface);
    }

    return result;
}
```

## Common Use Cases for Custom Filter Interfaces

### Video Processing Filters

When working with video, you might need to access specific properties of camera devices:

```
private void ConfigureVideoCaptureFilter(IBaseFilter captureFilter)
{
    // Access and set camera properties
    IAMCameraControl cameraControl = captureFilter as IAMCameraControl;

    if (cameraControl != null)
    {
        // Set exposure
        cameraControl.Set(CameraControlProperty.Exposure, 0, CameraControlFlags.Manual);

        // Set focus
        cameraControl.Set(CameraControlProperty.Focus, 0, CameraControlFlags.Manual);

        Marshal.ReleaseComObject(cameraControl);
    }
}
```

### Audio Processing Filters

For audio processing, you might want to adjust volume or audio quality settings:

```
private void ConfigureAudioFilter(IBaseFilter audioFilter)
{
    // Access volume interface
    IBasicAudio basicAudio = audioFilter as IBasicAudio;

    if (basicAudio != null)
    {
        // Set volume (0 to -10000, where 0 is max and -10000 is min)
        basicAudio.put_Volume(-2000); // 80% volume

        Marshal.ReleaseComObject(basicAudio);
    }
}
```

## Handling Resources Properly

When working with DirectShow interfaces, it's crucial to properly release COM objects to prevent memory leaks:

```
private void ReleaseComObject(object comObject)
{
    if (comObject != null)
    {
        Marshal.ReleaseComObject(comObject);
    }
}
```

## Complete Example

Here's a more complete example that demonstrates finding and configuring a video capture filter:

```
using System;
using System.Runtime.InteropServices;
using VisioForge.Libs.DirectShowLib;  // Public namespace — IBaseFilter, FilterInfo, IPin, etc.

public class CustomFilterExample
{
    private VideoCaptureCore captureCore;

    public void Initialize()
    {
        captureCore = new VideoCaptureCore();
        captureCore.OnFilterAdded += CaptureCore_OnFilterAdded;

        // Configure source
        // ...

        // Start capture
        captureCore.Start();
    }

    private void CaptureCore_OnFilterAdded(object sender, FilterEventArgs eventArgs)
    {
        IBaseFilter baseFilter = eventArgs.Filter as IBaseFilter;

        if (baseFilter != null)
        {
            // Get filter information
            FilterInfo filterInfo = new FilterInfo();
            baseFilter.QueryFilterInfo(out filterInfo);

            Console.WriteLine($"Filter added: {filterInfo.achName}");

            // Check if this is the video capture filter
            if (filterInfo.achName.Contains("Video Capture"))
            {
                ConfigureVideoCaptureFilter(baseFilter);
            }

            // Release filter graph reference
            if (filterInfo.pGraph != null)
            {
                Marshal.ReleaseComObject(filterInfo.pGraph);
            }
        }
    }

    private void ConfigureVideoCaptureFilter(IBaseFilter captureFilter)
    {
        // Your filter configuration code here
    }

    public void Cleanup()
    {
        if (captureCore != null)
        {
            captureCore.Stop();
            captureCore.OnFilterAdded -= CaptureCore_OnFilterAdded;
            captureCore.Dispose();
            captureCore = null;
        }
    }
}
```

## Required System Components

To use DirectShow functionality in your application, ensure your end-users have the following components installed:

- DirectX Runtime (included with Windows)
- SDK redistributable components

## Conclusion

Working with custom DirectShow filter interfaces gives you powerful capabilities for media processing in your .NET applications. By following the patterns described in this guide, you can access and manipulate the underlying DirectShow components to achieve precise control over your multimedia applications.

For additional assistance with implementing these techniques, please contact our support team. Visit our GitHub repository for more code samples and implementation examples.

---END OF PAGE---


## Creating Custom Real-Time Video Effects in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/custom-video-effects/
**Description:** Implement custom video effects in C# with OnVideoFrameBitmap and OnVideoFrameBuffer events for real-time video processing and overlays.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows, C#
**API:** VideoFrameBitmapEventArgs, VideoFrameBufferEventArgs

# Creating Custom Real-time Video Effects in C# Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction to Video Frame Processing

When developing video applications, you often need to apply custom effects or overlays to video streams in real-time. The .NET SDK provides two powerful events for this purpose: `OnVideoFrameBitmap` and `OnVideoFrameBuffer`. These events give you direct access to each video frame, allowing you to modify pixels before they're rendered or encoded.

## Implementation Methods

There are two primary approaches to implementing custom video effects:

1. **Using OnVideoFrameBitmap**: Process frames as Bitmap objects with GDI+ - easier to use but with moderate performance
2. **Using OnVideoFrameBuffer**: Manipulate raw RGB24 image buffer directly - offers better performance but requires more low-level code

## Code Examples for Custom Video Effects

### Text Overlay Implementation

Adding text overlays to video is useful for watermarking, displaying information, or creating captions. This example demonstrates how to add simple text to your video frames:

```
private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    Graphics grf = Graphics.FromImage(e.Frame);

    grf.DrawString("Hello!", new Font(FontFamily.GenericSansSerif, 20), new SolidBrush(Color.White), 20, 20);
    grf.Dispose();

    e.UpdateData = true;
}
```

### Grayscale Effect Implementation

Converting video to grayscale is a fundamental image processing technique. This example shows how to access and modify individual pixel values:

```
private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    Bitmap bmp = e.Frame;
    Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
    System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat);

    IntPtr ptr = bmpData.Scan0;
    int bytes = Math.Abs(bmpData.Stride) * bmp.Height;
    byte[] rgbValues = new byte[bytes];

    System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes);

    // Apply standard luminance formula (0.3R + 0.59G + 0.11B) for accurate grayscale conversion
    for (int i = 0; i < rgbValues.Length; i += 3)
    {
        int gray = (int)(rgbValues[i] * 0.3 + rgbValues[i + 1] * 0.59 + rgbValues[i + 2] * 0.11);
        rgbValues[i] = (byte)gray;
        rgbValues[i + 1] = (byte)gray;
        rgbValues[i + 2] = (byte)gray;
    }

    System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, bytes);
    bmp.UnlockBits(bmpData);

    e.UpdateData = true;
}
```

### Brightness Adjustment Implementation

This example demonstrates how to adjust the brightness of video frames - a common requirement in video processing applications:

```
private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    float brightness = 1.2f; // Values > 1 increase brightness, < 1 decrease it

    Bitmap bmp = e.Frame;
    Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
    System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat);

    IntPtr ptr = bmpData.Scan0;
    int bytes = Math.Abs(bmpData.Stride) * bmp.Height;
    byte[] rgbValues = new byte[bytes];

    System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes);

    // Apply brightness adjustment to each color channel
    for (int i = 0; i < rgbValues.Length; i++)
    {
        int newValue = (int)(rgbValues[i] * brightness);
        rgbValues[i] = (byte)Math.Min(255, Math.Max(0, newValue));
    }

    System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, bytes);
    bmp.UnlockBits(bmpData);

    e.UpdateData = true;
}
```

### Timestamp Overlay Implementation

Adding timestamps to video frames is essential for surveillance and logging applications. This example shows how to create a professional-looking timestamp with a semi-transparent background:

```
private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    Graphics grf = Graphics.FromImage(e.Frame);

    // Create a semi-transparent background for better readability
    Rectangle textBackground = new Rectangle(10, e.Frame.Height - 50, 250, 40);
    grf.FillRectangle(new SolidBrush(Color.FromArgb(128, 0, 0, 0)), textBackground);

    // Display current date and time
    string dateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
    grf.DrawString(dateTime, new Font(FontFamily.GenericSansSerif, 16),
                  new SolidBrush(Color.White), 15, e.Frame.Height - 45);

    grf.Dispose();

    e.UpdateData = true;
}
```

## Performance Optimization Tips

### Working with Raw Buffer Data

For high-performance applications, processing raw buffer data offers significant speed advantages:

```
// OnVideoFrameBuffer event example (pseudo-code)
private void VideoCapture1_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    // e.Frame.Data is an IntPtr to the native buffer (length = e.Frame.DataSize).
    // Dimensions and stride live in e.Frame.Info; actual pixel layout is in
    // e.Frame.Info.Colorspace (RGB24/RGB32/YUY2/NV12/...). Don't assume RGB24.
    int width   = e.Frame.Info.Width;
    int height  = e.Frame.Info.Height;
    int stride  = e.Frame.Info.Stride;
    var colorspace = e.Frame.Info.Colorspace;

    // Process e.Frame.Data in place for maximum performance, then set
    // e.UpdateData = true so the modified buffer flows downstream.
}
```

### Best Practices for Frame Processing

- **Memory Management**: Always dispose Graphics objects and unlock bitmapped data
- **Performance Considerations**: For real-time processing, keep operations lightweight
- **Buffer Processing**: We strongly recommend processing RAW data in the OnVideoFrameBuffer event for optimal performance
- **External Libraries**: Consider using Intel IPP or other optimized image-processing libraries for complex operations

---

## Additional Resources

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to access more code samples and complete project examples.

---END OF PAGE---


## Implementing Dynamic Text Overlays on Video Frames
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/draw-multitext-onvideoframebuffer/
**Description:** Create multiple text overlays on video frames with OnVideoFrameBuffer event for customizable text properties and dynamic updates in .NET.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows, C#
**API:** VideoFrameBufferEventArgs

# Implementing Dynamic Text Overlays on Video Frames in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction

Adding text overlays to video content has become essential for various applications, from adding watermarks and timestamps to creating informative annotations and captions. While many SDKs offer built-in text overlay capabilities, these functions might not always provide the level of customization or flexibility required for advanced projects.

This guide demonstrates how to implement custom text overlays using the `OnVideoFrameBuffer` event. This approach gives you full control over the text appearance, position, and behavior, allowing for more sophisticated overlay implementations than what's possible with standard API methods.

## Why Use Custom Text Overlays?

Standard text overlay APIs often have limitations in areas such as:

- Number of concurrent text elements
- Font customization options
- Dynamic text updates
- Animation capabilities
- Precise positioning control
- Alpha channel management

By leveraging the `OnVideoFrameBuffer` event and working directly with bitmap data, you can overcome these limitations and implement exactly what your application needs.

## Understanding the Approach

The technique demonstrated in this article involves:

1. Creating a transparent bitmap with the same dimensions as the video frame
2. Drawing text elements onto this bitmap using GDI+ (System.Drawing)
3. Converting the bitmap to a memory buffer
4. Overlaying this buffer onto the video frame data
5. Optionally updating text elements dynamically

This provides a powerful method for text overlay creation while maintaining good performance.

## Basic Implementation

The following code sample shows a straightforward implementation for drawing multiple text overlays on video frames:

```
        // Image
        private Bitmap logoImage = null;

        // Image RGB32 buffer
        private IntPtr logoImageBuffer = IntPtr.Zero;
        private int logoImageBufferSize = 0;

        private string text1 = "Hello World";
        private string text2 = "Hey-hey";
        private string text3 = "Ocean of pancakes";

        private void SDK_OnVideoFrameBuffer(Object sender, VideoFrameBufferEventArgs e)
        {
            // draw text to image
            if (logoImage == null)
            {
                logoImage = new Bitmap(e.Frame.Info.Width, e.Frame.Info.Height, PixelFormat.Format32bppArgb);

                using (var grf = Graphics.FromImage(logoImage))
                {
                    // antialiasing mode
                    grf.TextRenderingHint = TextRenderingHint.AntiAlias;

                    // drawing mode
                    grf.InterpolationMode = InterpolationMode.HighQualityBicubic;

                    // smoothing mode
                    grf.SmoothingMode = SmoothingMode.HighQuality;

                    // text 1
                    var brush1 = new SolidBrush(Color.Blue);
                    var font1 = new Font("Arial", 30, FontStyle.Regular);
                    grf.DrawString(text1, font1, brush1, 100, 100);

                    // text 2
                    var brush2 = new SolidBrush(Color.Red);
                    var font2 = new Font("Times New Roman", 35, FontStyle.Strikeout);
                    grf.DrawString(text2, font2, brush2, e.Frame.Info.Width / 2, e.Frame.Info.Height / 2);

                    // text 3
                    var brush3 = new SolidBrush(Color.Green);
                    var font3 = new Font("Verdana", 40, FontStyle.Italic);
                    grf.DrawString(text3, font3, brush3, 200, 200);
                }
            }

            // create image buffer if not allocated or have zero size
            if (logoImageBuffer == IntPtr.Zero || logoImageBufferSize == 0)
            {
                if (logoImageBuffer == IntPtr.Zero)
                {
                        logoImageBufferSize = ImageHelper.GetStrideRGB32(logoImage.Width) * logoImage.Height;
                        logoImageBuffer = Marshal.AllocCoTaskMem(logoImageBufferSize);
                }
                else
                {
                        logoImageBufferSize = ImageHelper.GetStrideRGB32(logoImage.Width) * logoImage.Height;

                        Marshal.FreeCoTaskMem(logoImageBuffer);
                        logoImageBuffer = Marshal.AllocCoTaskMem(logoImageBufferSize);
                }

                BitmapHelper.BitmapToIntPtr(logoImage, logoImageBuffer, logoImage.Width, logoImage.Height,
                        PixelFormat.Format32bppArgb);
            }

            // Draw image
            FastImageProcessing.Draw_RGB32OnRGB24(logoImageBuffer, logoImage.Width, logoImage.Height, e.Frame.Data, e.Frame.Info.Width, e.Frame.Info.Height, 0, 0);

            e.UpdateData = true;
        }
```

### Key Components Explained

1. **Bitmap Creation**: We create a 32-bit bitmap (with alpha channel) matching the video frame dimensions
2. **Graphics Settings**: We configure anti-aliasing, interpolation, and smoothing for high-quality text rendering
3. **Text Configuration**: Each text element gets its own font, color, and position
4. **Memory Management**: We allocate unmanaged memory for the bitmap buffer
5. **Bitmap to Buffer Conversion**: We convert the bitmap to a memory buffer using `BitmapHelper.BitmapToIntPtr`
6. **Buffer Overlay**: We draw the RGBA buffer onto the video frame using `FastImageProcessing.Draw_RGB32OnRGB24`
7. **Frame Update Flag**: We set `e.UpdateData = true` to inform the SDK that the frame data has been modified

## Advanced Implementation with Dynamic Updates

For more interactive applications, you might need to update text overlays dynamically. The following implementation supports on-the-fly updates of text content, fonts, and colors:

```
        // Image
        Bitmap logoImage = null;

        // Image RGB32 buffer
        IntPtr logoImageBuffer = IntPtr.Zero;
        int logoImageBufferSize = 0;

        // text settings
        string text1 = "Hello World";
        Font font1 = new Font("Arial", 30, FontStyle.Regular);
        SolidBrush brush1 = new SolidBrush(Color.Blue);

        string text2 = "Hey-hey";
        Font font2 = new Font("Times New Roman", 35, FontStyle.Strikeout);
        SolidBrush brush2 = new SolidBrush(Color.Red);

        string text3 = "Ocean of pancakes";
        Font font3 = new Font("Verdana", 40, FontStyle.Italic);
        SolidBrush brush3 = new SolidBrush(Color.Green);

        // update flag
        bool textUpdate = false;
        object textLock = new object();

        // Update text overlay, index is [1..3]
        void UpdateText(int index, string text, Font font, SolidBrush brush)
        {
            lock (textLock)
            {
                textUpdate = true;
            }

            switch (index)
            {
                case 1:
                    text1 = text;
                    font1 = font;
                    brush1 = brush;
                    break;
                case 2:
                    text2 = text;
                    font2 = font;
                    brush2 = brush;
                    break;
                case 3:
                    text3 = text;
                    font3 = font;
                    brush3 = brush;
                    break;
                default:
                    return;
            }
        }

        private void SDK_OnVideoFrameBuffer(Object sender, VideoFrameBufferEventArgs e)
        {
            lock (textLock)
            {
                if (textUpdate)
                {
                    logoImage.Dispose();
                    logoImage = null;
                }

                // draw text to image
                if (logoImage == null)
                {
                    logoImage = new Bitmap(e.Frame.Info.Width, e.Frame.Info.Height, PixelFormat.Format32bppArgb);

                    using (var grf = Graphics.FromImage(logoImage))
                    {
                        // antialiasing mode
                        grf.TextRenderingHint = TextRenderingHint.AntiAlias;

                        // drawing mode
                        grf.InterpolationMode = InterpolationMode.HighQualityBicubic;

                        // smoothing mode
                        grf.SmoothingMode = SmoothingMode.HighQuality;

                        // text 1
                        grf.DrawString(text1, font1, brush1, 100, 100);

                        // text 2
                        grf.DrawString(text2, font2, brush2, e.Frame.Info.Width / 2, e.Frame.Info.Height / 2);

                        // text 3
                        grf.DrawString(text3, font3, brush3, 200, 200);
                    }
                }

                // create image buffer if not allocated or have zero size
                if (logoImageBuffer == IntPtr.Zero || logoImageBufferSize == 0)
                {
                    if (logoImageBuffer == IntPtr.Zero)
                    {
                        logoImageBufferSize = ImageHelper.GetStrideRGB32(e.Frame.Info.Width) * e.Frame.Info.Height;
                        logoImageBuffer = Marshal.AllocCoTaskMem(logoImageBufferSize);
                    }
                    else
                    {
                        logoImageBufferSize = ImageHelper.GetStrideRGB32(e.Frame.Info.Width) * e.Frame.Info.Height;

                        Marshal.FreeCoTaskMem(logoImageBuffer);
                        logoImageBuffer = Marshal.AllocCoTaskMem(logoImageBufferSize);
                    }

                    BitmapHelper.BitmapToIntPtr(logoImage, logoImageBuffer, logoImage.Width, logoImage.Height,
                        PixelFormat.Format32bppArgb);
                }

                if (textUpdate)
                {
                    textUpdate = false;
                    BitmapHelper.BitmapToIntPtr(logoImage, logoImageBuffer, logoImage.Width, logoImage.Height,
                        PixelFormat.Format32bppArgb);
                }

                // Draw image
                FastImageProcessing.Draw_RGB32OnRGB24(logoImageBuffer, logoImage.Width, logoImage.Height, e.Frame.Data, e.Frame.Info.Width,
                e.Frame.Info.Height, 0, 0);

                e.UpdateData = true;
            }
        }

        private void btUpdateText1_Click(object sender, EventArgs e)
        {
            UpdateText(1, "Hello world", new Font("Arial", 48, FontStyle.Underline),
                new SolidBrush(Color.Aquamarine));
        }
```

### New Features in the Advanced Implementation

1. **Thread Safety**: We use a lock object to prevent concurrent access to shared resources
2. **Update Mechanism**: The `UpdateText` method provides a clean interface for changing text properties
3. **Text Property Storage**: Each text element has its own variables for content, font, and color
4. **Change Detection**: We use a flag (`textUpdate`) to indicate when text properties have changed
5. **Resource Management**: We dispose of the old bitmap when text properties change
6. **Buffer Update**: We update the memory buffer when text properties change
7. **UI Integration**: A sample button click handler demonstrates how to trigger text updates

## Performance Optimization Tips

When implementing text overlays with this method, consider these performance optimizations:

1. **Minimize Bitmap Recreations**: Only recreate the bitmap when necessary (text changes, resolution changes)
2. **Cache Font Objects**: Font creation is expensive; create fonts once and reuse them
3. **Use Memory Efficiently**: Free unmanaged memory when it's no longer needed
4. **Optimize Drawing Operations**: Use hardware acceleration when available
5. **Consider Update Frequency**: For frequent updates, consider double-buffering techniques
6. **Profile Your Code**: Use performance profiling tools to identify bottlenecks

## Advanced Features to Consider

This basic implementation can be extended with additional features:

1. **Text Animation**: Implement text movement, fading, or other animations
2. **Text Formatting**: Add support for rich text formatting (bold, italic, etc.)
3. **Text Effects**: Implement shadows, outlines, or glow effects
4. **Text Alignment**: Add support for different text alignment options
5. **Multi-Line Text**: Implement proper handling of multi-line text with wrapping
6. **Localization**: Add support for different languages and text directions
7. **Performance Monitoring**: Add diagnostics to monitor rendering performance

## Memory Management Considerations

When working with unmanaged memory, it's crucial to handle resource cleanup properly:

1. Implement the `IDisposable` pattern in your class
2. Free unmanaged memory in the `Dispose` method
3. Consider using `SafeHandle` or similar constructs for safer resource management
4. Set buffer pointers to `IntPtr.Zero` after freeing them
5. Use structured exception handling around memory operations

## Cleanup Example

```
protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        // Dispose managed resources
        if (logoImage != null)
        {
            logoImage.Dispose();
            logoImage = null;
        }
    }

    // Free unmanaged resources
    if (logoImageBuffer != IntPtr.Zero)
    {
        Marshal.FreeCoTaskMem(logoImageBuffer);
        logoImageBuffer = IntPtr.Zero;
        logoImageBufferSize = 0;
    }

    base.Dispose(disposing);
}
```

## Required Dependencies

- SDK redistributable components

## Conclusion

Implementing custom text overlays using the `OnVideoFrameBuffer` event provides a powerful and flexible solution for applications that require advanced text display capabilities. While it requires more code than using built-in API methods, the additional flexibility and control make it worthwhile for sophisticated video applications.

By following the patterns demonstrated in this guide, you can create dynamic, high-quality text overlays that can be updated in real-time, providing a rich user experience in your video applications.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Render Live Video in WinForms PictureBox — C# .NET Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/draw-video-picturebox/
**Description:** Thread-safe frame updates, bitmap disposal, and double buffering to prevent flicker. Frame skipping for high-FPS sources. VisioForge SDK zoom and size modes.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows, C#
**API:** VideoFrameBitmapEventArgs

# Drawing Video on PictureBox in .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction to Video Rendering in WinForms

Displaying video content in desktop applications is a common requirement for many software developers working with multimedia. Whether you're building applications for video surveillance, media players, video editing tools, or any software that processes video streams, understanding how to effectively render video is crucial.

The PictureBox control is one of the most straightforward ways to display video frames in Windows Forms applications. While it wasn't specifically designed for video playback, with proper implementation, it can provide smooth video rendering with minimal resource consumption.

This guide focuses on implementing video rendering on PictureBox controls in .NET WinForms applications. We'll cover the entire process from setup to implementation, addressing common pitfalls and optimization techniques.

## Why Use PictureBox for Video Display?

Before diving into implementation details, let's examine the advantages of using PictureBox for video display:

- **Simplicity**: PictureBox is a straightforward control that most .NET developers are already familiar with.
- **Flexibility**: It allows customization of how images are displayed through its SizeMode property.
- **Integration**: It integrates seamlessly with other WinForms controls.
- **Low overhead**: For many applications, it provides sufficient performance without requiring more complex DirectX or OpenGL implementations.

However, it's important to note that PictureBox wasn't designed specifically for high-performance video playback. For applications requiring professional-grade video performance or hardware acceleration, more specialized rendering approaches might be necessary.

## Prerequisites

To implement video rendering on a PictureBox, you'll need:

- Basic knowledge of C# and .NET WinForms development
- Visual Studio or another IDE for .NET development
- A video source (from Video Capture SDK, Video Edit SDK, or Media Player SDK)
- Understanding of event-driven programming

## Setting Up Your Environment

### Configuring the PictureBox Control

1. Add a PictureBox control to your form through the designer or programmatically.
2. Configure the basic properties for optimal video display:

```
// Configure PictureBox for video display
pictureBox1.BackColor = Color.Black;
pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
```

The `BackColor` property set to `Black` provides a clean background for video display, especially during initialization or when the video has black borders. The `SizeMode` property determines how the video frame fits within the control:

- `StretchImage`: Stretches the image to fill the PictureBox (may distort aspect ratio)
- `Zoom`: Maintains aspect ratio while filling the control
- `CenterImage`: Centers the image without scaling
- `Normal`: Displays the image at its original size

For most video applications, `StretchImage` or `Zoom` work best, depending on whether maintaining aspect ratio is important.

## Implementation Steps

### Step 1: Prepare Your Class with Required Variables

Add a boolean class member to track when an image is being applied to the PictureBox. This prevents race conditions when multiple frames arrive in quick succession:

```
private bool applyingPictureBoxImage = false;
```

### Step 2: Initialize Video Settings in the Start Handler

When starting your video capture or playback, ensure the flag is properly initialized:

```
private async void btnStart_Click(object sender, EventArgs e)
{
    // Reset the flag before starting capture/playback.
    applyingPictureBoxImage = false;

    // Subscribe to OnVideoFrameBitmap before starting so the first frame is not missed.
    // The event is EventHandler<VideoFrameBitmapEventArgs>, fired from a worker thread.
    videoCapture1.OnVideoFrameBitmap += VideoCapture1_OnVideoFrameBitmap;

    // Video Capture SDK example — swap for MediaPlayer1 / VideoEdit1 if you are using those engines.
    videoCapture1.Video_CaptureDevice = new VideoCaptureSource("USB Camera");
    videoCapture1.Mode = VideoCaptureMode.VideoPreview;
    videoCapture1.Audio_RecordAudio = false;

    await videoCapture1.StartAsync();
}
```

The same `OnVideoFrameBitmap` event exists on all three engines — `VideoCaptureCore`, `MediaPlayerCore`, and `VideoEditCore` — so the handler below works unchanged no matter which SDK raised it.

### Step 3: Implement the Frame Handler

The core of video rendering is the frame handler. This event fires each time a new video frame is available. Here's how to implement it efficiently:

```
private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    // Prevent concurrent updates that could cause threading issues
    if (applyingPictureBoxImage)
    {
        return;
    }

    applyingPictureBoxImage = true;

    try
    {
        // Store current image for proper disposal
        var currentImage = pictureBox1.Image;

        // Create a new bitmap from the frame
        pictureBox1.Image = new Bitmap(e.Frame);

        // Properly dispose of the previous image to prevent memory leaks
        currentImage?.Dispose();
    }
    catch (Exception ex)
    {
        // Consider logging the exception
        Console.WriteLine($"Error updating frame: {ex.Message}");
    }
    finally
    {
        // Ensure flag is reset even if an exception occurs
        applyingPictureBoxImage = false;
    }
}
```

This implementation includes several important concepts:

1. **Thread safety**: Using the `applyingPictureBoxImage` flag prevents concurrent updates.
2. **Memory management**: Properly disposing of the previous image prevents memory leaks.
3. **Exception handling**: Catching exceptions prevents application crashes during rendering.

### Step 4: Implement Cleanup When Stopping Video

When stopping video capture or playback, you need to clean up resources properly:

```
private void btnStop_Click(object sender, EventArgs e)
{
    // Your video stop code here
    // videoCapture1.Stop(); or similar SDK call

    // Wait until any in-progress frame updates complete
    while (applyingPictureBoxImage)
    {
        Thread.Sleep(50);
    }

    // Clean up resources
    if (pictureBox1.Image != null)
    {
        pictureBox1.Image.Dispose();
        pictureBox1.Image = null;
    }
}
```

This cleanup process:

1. Waits for any in-progress frame updates to complete
2. Properly disposes of the image
3. Sets the PictureBox image to null for visual cleanup

## Advanced Implementation Considerations

### Handling High Frame Rates

For high-frame-rate video sources, you might want to implement frame skipping to maintain application responsiveness:

```
private DateTime lastFrameTime = DateTime.MinValue;
private TimeSpan frameInterval = TimeSpan.FromMilliseconds(33); // About 30fps

private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    // Skip frames if they're coming too quickly
    if (DateTime.Now - lastFrameTime < frameInterval)
    {
        return;
    }

    if (applyingPictureBoxImage)
    {
        return;
    }

    applyingPictureBoxImage = true;
    lastFrameTime = DateTime.Now;

    // Frame processing code as before...
}
```

### Cross-Thread Invocation

When handling video frames from background threads, you'll need to use cross-thread invocation:

```
private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    if (applyingPictureBoxImage)
    {
        return;
    }

    applyingPictureBoxImage = true;

    if (pictureBox1.InvokeRequired)
    {
        pictureBox1.BeginInvoke(new Action(() => {
            var currentImage = pictureBox1.Image;
            pictureBox1.Image = new Bitmap(e.Frame);
            currentImage?.Dispose();
            applyingPictureBoxImage = false;
        }));
    }
    else
    {
        // Direct update code as before...
    }
}
```

## Performance Optimization Tips

### Reduce Bitmap Creation Overhead

Creating a new Bitmap for each frame can be expensive. Consider reusing Bitmap objects:

```
private Bitmap displayBitmap;

private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    if (applyingPictureBoxImage)
    {
        return;
    }

    applyingPictureBoxImage = true;

    try
    {
        // Initialize bitmap if needed
        if (displayBitmap == null ||
            displayBitmap.Width != e.Frame.Width ||
            displayBitmap.Height != e.Frame.Height)
        {
            displayBitmap?.Dispose();
            displayBitmap = new Bitmap(e.Frame.Width, e.Frame.Height);
        }

        // Copy frame to display bitmap
        using (Graphics g = Graphics.FromImage(displayBitmap))
        {
            g.DrawImage(e.Frame, 0, 0, e.Frame.Width, e.Frame.Height);
        }

        // Update display
        var oldImage = pictureBox1.Image;
        pictureBox1.Image = displayBitmap;
        oldImage?.Dispose();
    }
    finally
    {
        applyingPictureBoxImage = false;
    }
}
```

### Consider Using Double Buffering

For smoother display, enable double buffering on your form:

```
// In your form constructor
this.DoubleBuffered = true;
```

## Troubleshooting Common Issues

### Memory Leaks

If your application experiences increasing memory usage, check:

- Proper disposal of old Bitmap objects
- References to frames that might prevent garbage collection
- Whether frames are being skipped when necessary

### Flickering Display

If video display flickers:

- Ensure double buffering is enabled
- Check if multiple threads are updating the PictureBox simultaneously
- Consider implementing a more sophisticated frame synchronization mechanism

### High CPU Usage

If rendering causes high CPU usage:

- Implement frame skipping as shown above
- Consider reducing the frame rate of the source if possible
- Optimize bitmap handling to reduce GC pressure

## Required Dependencies

To implement this solution, you'll need:

- .NET Framework or .NET Core/5+
- SDK redist files for the specific video SDK you're using

## Conclusion

Implementing video rendering on a PictureBox control provides a straightforward way to display video in Windows Forms applications. By following the patterns outlined in this guide, you can achieve smooth video display while avoiding common pitfalls like memory leaks, thread safety issues, and performance bottlenecks.

Remember that while PictureBox is suitable for many applications, high-performance video applications might benefit from more specialized rendering approaches using DirectX or OpenGL.

---

For more code samples, visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) repository.

---END OF PAGE---


## How to Exclude DirectShow Filters in .NET Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/exclude-filters/
**Description:** Identify and exclude problematic DirectShow filters from multimedia pipelines in .NET video capture, editing, and playback applications.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, DirectShow, VideoCaptureCore, Windows, Capture, Playback, Streaming, Encoding, Decoding, Mixing, Conversion, C#
**API:** VideoCaptureCore

# Excluding DirectShow Filters in .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction

When developing multimedia applications in .NET, you'll frequently interact with DirectShow — Microsoft's framework for multimedia streaming. DirectShow uses a filter-based architecture where individual components (filters) process media data. However, not all filters are created equal. Some can cause performance issues, compatibility problems, or simply don't meet your application's specific needs.

This guide explores how to effectively identify and exclude problematic DirectShow filters from your application's processing pipeline.

## Understanding DirectShow Filters

DirectShow filters are COM objects that perform specific operations on media data, such as:

- **Source filters**: Read media from files, capture devices, or network streams
- **Transform filters**: Process or convert media data (decoders, encoders, effects)
- **Renderer filters**: Display video or play audio

When DirectShow builds a filter graph, it automatically selects filters based on merit (priority) and compatibility. This automatic selection sometimes includes third-party filters that may:

- Reduce performance
- Cause stability issues
- Introduce compatibility problems
- Override preferred processing methods

## Common Issues with DirectShow Filters

### Decoder Conflicts

Multiple decoders installed on a system can compete to handle the same media formats. For example:

- NVIDIA's video decoder might conflict with Intel's hardware decoder
- Third-party codec packs might introduce low-quality decoders
- Legacy decoders might be selected over newer, more efficient ones

### Performance Bottlenecks

Some filters can significantly impact performance:

- Non-optimized video processing filters
- Filters without hardware acceleration support
- Debugging filters that add logging overhead

### Compatibility Problems

Not all filters work well together:

- Version mismatches between filters
- Filters with different pixel format expectations
- Non-standard implementation of interfaces

## When to Exclude DirectShow Filters

Consider excluding DirectShow filters when:

1. You notice unexplained performance issues during media playback or processing
2. Your application crashes when handling specific media formats
3. Media quality is unexpectedly poor
4. You want to enforce consistent behavior across different user systems
5. You're implementing a custom processing pipeline with specific requirements

## Implementing Filter Exclusion

Our .NET SDKs provide a straightforward API for managing DirectShow filter exclusions.

### Clearing the Blacklist

Before setting up your exclusion list, you may want to clear any previously blacklisted filters:

```
// Clear any existing blacklisted filters
videoProcessor.DirectShow_Filters_Blacklist_Clear();
```

This ensures you're starting with a clean slate and your exclusion list contains only the filters you explicitly specify.

### Adding Filters to the Blacklist

To exclude specific filters, you'll use the `DirectShow_Filters_Blacklist_Add` method with the exact filter name:

```
// Exclude specific filters by name
videoProcessor.DirectShow_Filters_Blacklist_Add("NVIDIA NVENC Encoder");
videoProcessor.DirectShow_Filters_Blacklist_Add("Intel® Hardware H.264 Encoder");
videoProcessor.DirectShow_Filters_Blacklist_Add("Fraunhofer IIS MPEG Audio Layer 3 Decoder");
```

### Complete Code Example

Here's a more complete example demonstrating filter exclusion in a video processing application:

```
using System;
using VisioForge.Core.VideoCapture;
using VisioForge.Core.VideoEdit;
using VisioForge.Core.MediaPlayer;

public class FilterExclusionExample
{
    private VideoCaptureCore captureCore;

    public void SetupFilterExclusions()
    {
        captureCore = new VideoCaptureCore();

        // Clear any existing blacklisted filters
        captureCore.DirectShow_Filters_Blacklist_Clear();

        // Add problematic filters to the blacklist
        captureCore.DirectShow_Filters_Blacklist_Add("SampleGrabber");
        captureCore.DirectShow_Filters_Blacklist_Add("Overlay Mixer");
        captureCore.DirectShow_Filters_Blacklist_Add("VirtualDub H.264 Decoder");

        Console.WriteLine("DirectShow filters successfully excluded.");
    }

    // Additional application logic...
}
```

## Best Practices for Filter Exclusion

### Identify Before Excluding

Before blacklisting filters, identify which ones are causing issues:

1. Use DirectShow diagnostic tools like GraphEdit or GraphStudio
2. Enable logging in your application to track which filters are being used
3. Test with different filter configurations to isolate problematic components

### Be Specific with Filter Names

Use exact, case-sensitive filter names when excluding:

```
// Correct - uses exact filter name
videoProcessor.DirectShow_Filters_Blacklist_Add("ffdshow Video Decoder");

// Incorrect - may exclude unintended filters or none at all
videoProcessor.DirectShow_Filters_Blacklist_Add("ffdshow");
```

### Consider Alternative Approaches

Filter exclusion is not always the best solution:

- **Merit adjustment**: SDK allows adjusting filter merit instead of complete exclusion
- **Explicit graph building**: Build the filter graph manually with preferred filters
- **Alternative frameworks**: Consider MediaFoundation for newer applications

## Troubleshooting

### Filter Still Being Used Despite Blacklisting

If a filter continues to be used despite being blacklisted:

1. Verify you're using the exact filter name (case-sensitive)
2. Ensure the blacklist is set before building the filter graph
3. Check if the filter is being inserted through an alternative method

### Performance Issues After Blacklisting

If performance degrades after blacklisting certain filters:

1. The blacklisted filter might have been providing hardware acceleration
2. The replacement filter might be less efficient
3. The filter graph might be more complex without the excluded filter

### Application Crashes After Filter Exclusion

If your application becomes unstable after filter exclusion:

1. Some filters might be required for proper operation
2. The alternative filter path might have compatibility issues
3. The filter graph might be incomplete without certain filters

## Conclusion

Excluding problematic DirectShow filters provides a powerful tool for optimizing and stabilizing your multimedia applications. By carefully identifying and blacklisting problematic filters, you can ensure consistent behavior, better performance, and higher quality media processing across different user systems.

Remember to test thoroughly after implementing filter exclusions, as the DirectShow filter graph may behave differently when certain components are unavailable.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples and implementation examples.

---END OF PAGE---


## Process Video Frames in C# .NET — OnVideoFrameBuffer Event
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/image-onvideoframebuffer/
**Description:** Access the raw video frame buffer in C# / .NET via the OnVideoFrameBuffer event. Modify pixels, draw images, apply custom blends — full frame control.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, DirectShow, MediaPlayerCoreX, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Playback, Encoding, C#
**API:** VideoFrameXBufferEventArgs, VideoCaptureCoreX, MediaPlayerCoreX, VideoCaptureCore, VideoFrameBufferEventArgs

# Drawing Images with OnVideoFrameBuffer in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction

The `OnVideoFrameBuffer` event gives direct, pixel-level access to every video frame as it passes through the pipeline. Event handlers receive a raw buffer and can inspect, modify, or overwrite pixels before the frame continues to the next stage (preview, encoder, file output). Drawing an image onto the frame — for a watermark, logo, debug overlay, or computer-vision annotation — is the most common use case and the one this guide walks through.

Looking for the high-level overlay feature?

If you just need to drop a static or animated image on the video (PNG / JPG / GIF / BMP), use the dedicated [image overlay effect](../../video-effects/image-overlay/) — one line of code via `Video_Effects_Add(new VideoEffectImageLogo(...))`. Use `OnVideoFrameBuffer` (this page) when you need **pixel-level control**: custom blend modes, per-frame logic, CV annotations, or integration with third-party imaging libraries.

### Supported engines

The `OnVideoFrameBuffer` event is exposed on both engine families:

| Engine | Event args type | Frame pixel format |
| --- | --- | --- |
| `VideoCaptureCore` (DirectShow, Windows) | `VideoFrameBufferEventArgs` | RGB24 / RGB32 |
| `VideoCaptureCoreX` (GStreamer, cross-platform) | `VideoFrameXBufferEventArgs` | BGRA (most common) |
| `MediaPlayerCoreX` (GStreamer, cross-platform) | `VideoFrameXBufferEventArgs` | BGRA (most common) |

Both engines follow the same pattern — subscribe to the event, read `e.Frame.Data` (an `IntPtr`) along with `Width` / `Height` / `Stride`, optionally modify the buffer in place, and set `e.UpdateData = true` to have the changes propagated downstream.

## Understanding the process

When working with video frames you need to:

1. Load your image (logo, watermark, etc.) into memory.
2. Convert the image to a compatible buffer format (RGB24/RGB32 for the legacy engine, BGRA for the X engines).
3. Subscribe to the `OnVideoFrameBuffer` event.
4. Draw the image onto each video frame as it is processed.
5. Set `e.UpdateData = true` so the modified frame replaces the original downstream.

## VideoCaptureCore (DirectShow) example

Let's walk through the implementation step by step:

### Step 1: Load Your Image

First, load the image file you want to overlay on the video:

```
// Bitmap loading from file
private Bitmap logoImage = new Bitmap(@"logo24.jpg");
// You can also use PNG with alpha channel for transparency
//private Bitmap logoImage = new Bitmap(@"logo32.png");
```

### Step 2: Prepare Memory Buffers

Initialize pointers for the image buffer:

```
// Logo RGB24/RGB32 buffer
private IntPtr logoImageBuffer = IntPtr.Zero;
private int logoImageBufferSize = 0;
```

### Step 3: Implement the OnVideoFrameBuffer Event Handler

The full event handler implementation:

```
private void VideoCapture1_OnVideoFrameBuffer(Object sender, VideoFrameBufferEventArgs e)
{
    // Create logo buffer if not allocated or have zero size
    if (logoImageBuffer == IntPtr.Zero || logoImageBufferSize == 0)
    {
        if (logoImageBuffer == IntPtr.Zero)
        {
            if (logoImage.PixelFormat == PixelFormat.Format32bppArgb)
            {
                logoImageBufferSize = ImageHelper.GetStrideRGB32(logoImage.Width) * logoImage.Height;
                logoImageBuffer = Marshal.AllocCoTaskMem(logoImageBufferSize);
            }
            else
            {
                logoImageBufferSize = ImageHelper.GetStrideRGB24(logoImage.Width) * logoImage.Height;
                logoImageBuffer = Marshal.AllocCoTaskMem(logoImageBufferSize);
            }
        }
        else
        {
            if (logoImage.PixelFormat == PixelFormat.Format32bppArgb)
            {
                logoImageBufferSize = ImageHelper.GetStrideRGB32(logoImage.Width) * logoImage.Height;

                Marshal.FreeCoTaskMem(logoImageBuffer);
                logoImageBuffer = Marshal.AllocCoTaskMem(logoImageBufferSize);
            }
            else
            {
                logoImageBufferSize = ImageHelper.GetStrideRGB24(logoImage.Width) * logoImage.Height;

                Marshal.FreeCoTaskMem(logoImageBuffer);
                logoImageBuffer = Marshal.AllocCoTaskMem(logoImageBufferSize);
            }
        }

        if (logoImage.PixelFormat == PixelFormat.Format32bppArgb)
        {
            BitmapHelper.BitmapToIntPtr(logoImage, logoImageBuffer, logoImage.Width, logoImage.Height,
                PixelFormat.Format32bppArgb);
        }
        else
        {
            BitmapHelper.BitmapToIntPtr(logoImage, logoImageBuffer, logoImage.Width, logoImage.Height,
                PixelFormat.Format24bppRgb);
        }
    }

    // Draw image — the classic VideoFrame struct keeps Width/Height/Stride inside Frame.Info
    if (logoImage.PixelFormat == PixelFormat.Format32bppArgb)
    {
        FastImageProcessing.Draw_RGB32OnRGB24(logoImageBuffer, logoImage.Width, logoImage.Height, e.Frame.Data, e.Frame.Info.Width,
            e.Frame.Info.Height, 0, 0);
    }
    else
    {
        FastImageProcessing.Draw_RGB24OnRGB24Old(logoImageBuffer, logoImage.Width, logoImage.Height, e.Frame.Data, e.Frame.Info.Width,
            e.Frame.Info.Height, 0, 0);
    }

    e.UpdateData = true;
}
```

## Detailed Explanation

### Memory Management

The code handles both 24-bit and 32-bit image formats. Here's what happens:

1. **Buffer Initialization Check**: The code first checks if the logo buffer needs to be created or recreated.
2. **Format Detection**: It determines whether to use RGB24 or RGB32 format based on the loaded image:
3. RGB24: Standard 24-bit color (8 bits each for R, G, B)
4. RGB32: 32-bit color with alpha channel for transparency (8 bits each for R, G, B, A)
5. **Memory Allocation**: Allocates unmanaged memory using `Marshal.AllocCoTaskMem()` to store the image data.
6. **Image Conversion**: Converts the Bitmap to raw pixel data in the allocated buffer using `BitmapHelper.BitmapToIntPtr()`.

### Drawing Process

Once the buffer is prepared, drawing takes place:

1. **Format-Specific Drawing**: The code selects the appropriate drawing method based on the image format:
2. `FastImageProcessing.Draw_RGB32OnRGB24()` for 32-bit images with transparency
3. `FastImageProcessing.Draw_RGB24OnRGB24Old()` for standard 24-bit images (8-arg form) or `Draw_RGB24OnRGB24S()` when source/destination strides are known
4. **Position Parameters**: The `0, 0` parameters specify where to draw the image (top-left corner in this example).
5. **Frame Update**: Setting `e.UpdateData = true` ensures the modified frame data is used for display or further processing.

## VideoCaptureCoreX / MediaPlayerCoreX (X engines) example

On the cross-platform X engines the event signature changes to `VideoFrameXBufferEventArgs` and the frame buffer typically arrives in **BGRA** format (4 bytes per pixel). The same pattern applies — subscribe, inspect, modify, flag updates. The example below uses SkiaSharp to wrap the raw buffer and draw a PNG logo on top; SkiaSharp is already a transitive dependency of the X engines, so no extra NuGet package is needed.

```
using SkiaSharp;

// Load logo once (PNG with alpha works well for watermarks)
private SKBitmap _logo = SKBitmap.Decode(@"logo.png");

// Subscribe after constructing VideoCaptureCoreX / MediaPlayerCoreX
_videoCapture.OnVideoFrameBuffer += VideoCapture_OnVideoFrameBuffer;

private void VideoCapture_OnVideoFrameBuffer(object sender, VideoFrameXBufferEventArgs e)
{
    if (e.Frame == null || e.Frame.Data == IntPtr.Zero)
    {
        return;
    }

    // Wrap the raw BGRA buffer in a SkiaSharp canvas (no extra allocation)
    var info = new SKImageInfo(e.Frame.Width, e.Frame.Height, SKColorType.Bgra8888, SKAlphaType.Premul);

    using (var pixmap = new SKPixmap(info, e.Frame.Data, e.Frame.Stride))
    using (var surface = SKSurface.Create(pixmap))
    {
        var canvas = surface.Canvas;

        // Draw the logo at bottom-right with 16px padding
        var x = e.Frame.Width - _logo.Width - 16;
        var y = e.Frame.Height - _logo.Height - 16;
        canvas.DrawBitmap(_logo, x, y);
        canvas.Flush();
    }

    // Propagate the modified frame downstream
    e.UpdateData = true;
}
```

**Why BGRA matters.** The X engines request BGRA by default for frame callbacks because it maps 1:1 to SkiaSharp, System.Drawing, and most GPU-friendly interop paths. If you need a different format (I420, NV12, RGB24), request a format conversion block upstream of your handler rather than converting on every frame.

**Alternative imaging stacks.** You can also use `System.Drawing.Bitmap` via `new Bitmap(width, height, stride, PixelFormat.Format32bppArgb, data)` on Windows, or manual byte writes via `Marshal.Copy` / `Span<byte>` for maximum control. SkiaSharp is the recommended option on macOS / Linux / iOS / Android.

**Engine-level parity.** Everything documented in the [Memory Management](#memory-management), [Error Handling](#error-handling), and [Performance Optimization](#performance-optimization) sections below applies equally to the X engines — the event fires on a processing thread, `UpdateData` toggles whether the buffer is re-used downstream, and heavy work should be offloaded to avoid dropping frames.

## Best Practices for Image Overlay

For optimal performance when overlaying images on video frames:

1. **Memory Management**: Always free allocated memory when it's no longer needed to prevent memory leaks.
2. **Buffer Reuse**: Create the buffer once and reuse it for subsequent frames rather than recreating it for each frame.
3. **Image Size Considerations**: Use appropriately sized images; overlaying large images can impact performance.
4. **Format Selection**:
5. Use PNG (RGB32) when you need transparency
6. Use JPG (RGB24) when transparency isn't required (more efficient)
7. **Position Calculation**: For dynamic positioning, calculate coordinates based on frame dimensions. On the classic engine (`VideoFrameBufferEventArgs`) Width/Height live on `e.Frame.Info`; on the X engines (`VideoFrameXBufferEventArgs`) they're flat on `e.Frame`.

```
// Classic engine — Width/Height live on e.Frame.Info
int xPos = e.Frame.Info.Width - logoImage.Width - 10;
int yPos = e.Frame.Info.Height - logoImage.Height - 10;
```

## Error Handling

When implementing this functionality, consider adding error handling:

```
try
{
    // Your existing implementation
}
catch (OutOfMemoryException ex)
{
    // Handle memory allocation failures
    Console.WriteLine("Failed to allocate memory: " + ex.Message);
}
catch (Exception ex)
{
    // Handle other exceptions
    Console.WriteLine("Error during frame processing: " + ex.Message);
}
finally
{
    // Optional cleanup code
}
```

## Performance Optimization

For high-performance applications, consider these optimizations:

1. **Buffer Pre-allocation**: Initialize buffers during application startup rather than during video processing.
2. **Conditional Processing**: Only process frames that need the overlay (e.g., skip processing for certain frames).
3. **Parallel Processing**: For complex operations, consider using parallel processing techniques.

## Conclusion

The `OnVideoFrameBuffer` event gives direct access to every raw frame on both the legacy `VideoCaptureCore` engine (RGB24/RGB32 via `VideoFrameBufferEventArgs`) and the cross-platform X engines (`VideoCaptureCoreX` / `MediaPlayerCoreX`, BGRA via `VideoFrameXBufferEventArgs`). This is the right tool when you need pixel-level control — custom blend modes, per-frame CV annotations, or integration with third-party imaging libraries.

For static or animated image overlays without writing a per-frame handler, the one-line [image overlay effect](../../video-effects/image-overlay/) is usually the better choice.

## Related documentation

- [Image overlay effect](../../video-effects/image-overlay/) — high-level, declarative watermark / logo overlay without writing a callback.
- [Text overlay via OnVideoFrameBuffer](../text-onvideoframebuffer/) — same technique applied to text instead of images.
- [Drawing video in a PictureBox](../draw-video-picturebox/) — WinForms rendering pattern that often pairs with pixel-level frame work.

---

Looking for more code samples? Visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) for additional examples and resources.

---END OF PAGE---


## Essential .NET SDK Code Samples for Media Developers
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/
**Description:** Implementation examples for DirectShow filters, audio/video processing, rendering, and media manipulation in .NET SDK applications.
**Tags:** .NET, DirectShow, Editing

# .NET SDK Code Samples: Practical Implementation Guide

In this guide, you'll find a collection of practical code samples and implementation techniques for working with our .NET SDKs. These examples address common development scenarios and demonstrate how to leverage our libraries effectively for media processing applications.

## DirectShow Filter Implementation

DirectShow provides a powerful framework for handling multimedia streams. Our SDKs simplify working with these components through well-designed interfaces and helper methods.

### Media Indexing and Format Handling

- [ASF and WMV Files Indexing](asf-wmv-files-indexing/) - Learn techniques for properly indexing Windows Media formats to enable seeking and efficient playback position control. This sample demonstrates how to establish accurate navigation points within media files and handle large ASF/WMV content effectively.

### Custom Filter Integration

- [Custom DirectShow Filter Interface Usage](custom-filter-interface/) - This tutorial walks through the process of implementing and connecting custom DirectShow filters within your application. You'll learn how to create filter interfaces that integrate seamlessly with the existing DirectShow architecture while adding your own specialized functionality.

### Third-Party Integration

- [Integrating Third-Party Video Processing Filters](3rd-party-video-effects/) - Discover how to incorporate external video processing components into your DirectShow filter graph. This example demonstrates proper filter registration, connection methods, and parameter configuration for third-party video effects and transformations.

### Filter Management

- [Manual DirectShow Filter Uninstallation](uninstall-directshow-filter/) - This guide explains the registry entries, COM object registration, and system directories involved in completely removing DirectShow filters when standard uninstallation isn't sufficient or available.
- [Excluding Specific DirectShow Filters](exclude-filters/) - Learn techniques for selectively bypassing certain DirectShow filters in your filter graph construction. This sample shows how to exclude specific decoders, encoders, or processing filters while maintaining proper media handling.

## Audio and Video Processing Techniques

Manipulating audio and video streams is a core requirement for many media applications. These samples demonstrate different approaches to accessing and modifying media data.

### Real-time Video Effects

- [Custom Video Effects Using Frame Events](custom-video-effects/) - Learn two powerful approaches for implementing real-time video effects through the OnVideoFrameBitmap and OnVideoFrameBuffer events. This comprehensive sample demonstrates how to access video frames, apply effects, and optimize performance.

### Advanced Overlay Techniques

- [Multi-text Overlay Drawing](draw-multitext-onvideoframebuffer/) - This sample demonstrates techniques for rendering multiple text elements on video frames with precise positioning and style control. You'll learn how to handle text formatting, alpha blending, and performance optimization.
- [Text Overlay Implementation](text-onvideoframebuffer/) - A focused tutorial on adding dynamic text annotations to video content. This example covers font selection, positioning, and real-time updates of overlay text.
- [Image Overlay Integration](image-onvideoframebuffer/) - Learn how to composite images onto video frames with proper scaling, alpha blending, and positioning. This example shows techniques for watermarking, logo placement, and dynamic image overlays.

### Video Transformation

- [Manual Zoom Effect Implementation](zoom-onvideoframebuffer/) - This detailed example demonstrates how to implement a custom zoom functionality by directly manipulating video frame buffers. You'll learn techniques for region selection, scaling algorithms, and smooth transitions between zoom levels.

### Bitmap-Based Frame Processing

- [OnVideoFrameBitmap Event Usage](onvideoframebitmap-usage/) - This guide explores the bitmap-based approach to video frame processing, which offers simplified access to frame data through GDI+ compatible objects. Learn how this differs from buffer-based processing and when to choose each approach.

## Video Rendering Solutions

Displaying video content with flexibility and performance requires understanding various rendering techniques. These samples demonstrate different approaches for visual presentation.

### Windows Forms Integration

- [PictureBox Video Rendering](draw-video-picturebox/) - This sample demonstrates how to properly render video content within a standard Windows Forms PictureBox control. You'll learn about frame timing, aspect ratio preservation, and performance considerations.

### Multi-Display Functionality

- [Multiple Renderer Zoom Configuration](zoom-video-multiple-renderer/) - Learn techniques for independently controlling zoom levels across multiple video renderers. This sample is essential for applications requiring synchronized but visually distinct video outputs.
- [WPF Multi-screen Video Output](multiple-screens-wpf/) - This example shows how to implement multiple independent video display surfaces within a WPF application. You'll learn proper control initialization, resource management, and synchronization techniques.

### Renderer Selection and Customization

- [Video Renderer Selection (WinForms)](select-video-renderer-winforms/) - This tutorial explains how to choose and configure the most appropriate video renderer for your Windows Forms application. You'll understand the tradeoffs between EVR, VMR9, and other renderer types.
- [Overlaying WPF Controls on Video](wpf-controls-over-video/) - Learn how to place WPF buttons, banners and transport controls on top of the video preview. This guide covers the D3D11 composable renderer, the software `WriteableBitmap` mode, the WPF airspace limitation, and migrating from `WPF_WinUI_Callback` to the X engines.

### User Interaction

- [Mouse Wheel Event Integration](mouse-wheel-usage/) - Learn how to handle mouse wheel events for interactive video displays. This sample demonstrates zoom control, timeline scrubbing, and other wheel-based interactions.
- [Custom Image Video View](video-view-set-custom-image/) - This guide shows how to replace the standard video frame with a custom image for scenarios like connection loss, buffering states, or application-specific messaging.

## Media Information and Visualization

These samples demonstrate how to extract information from media files and create useful visualizations.

### File Analysis

- [Media File Information Extraction](read-file-info/) - Learn techniques for reading detailed metadata, stream properties, and format information from media files. This example shows how to access duration, bitrate, codec information, and other essential media properties.

### Audio Visualization

- [VU Meter and Waveform Visualization](vu-meters/) - This comprehensive sample demonstrates how to create real-time audio visualizations including volume unit meters and waveform displays. You'll learn about audio level analysis, drawing techniques, and synchronization with playback.

## Performance Optimization

Each sample in this collection is designed with performance considerations in mind. You'll find techniques for efficient buffer handling, memory management, and processing optimizations that help you build responsive media applications, even when working with high-resolution content or applying complex effects.

## Cross-Platform Considerations

While focusing on .NET implementations, many of the concepts demonstrated in these samples apply to other platforms as well. Where appropriate, we've noted platform-specific considerations and alternative approaches for cross-platform development scenarios.

## Getting Started

To use these examples effectively, we recommend reviewing the appropriate SDK documentation for your specific product version. Each sample includes the necessary references and initialization code, but may require configuration based on your development environment and target platform.

These code samples serve as building blocks for your media applications, providing proven implementation patterns that you can adapt and extend for your specific requirements.

---END OF PAGE---


## Mouse Wheel Event Handling in .NET Video Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/mouse-wheel-usage/
**Description:** Handle mouse wheel events in .NET video apps for zooming, scrolling, and timeline navigation with best practices and optimization techniques.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows, Editing, C#

# Implementing Mouse Wheel Events in .NET SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction to Mouse Wheel Events

Mouse wheel events provide an intuitive way for users to interact with video content in multimedia applications. Whether you're developing a video player, editor, or capture application, implementing proper mouse wheel event handling enhances user experience by allowing smooth zooming, scrolling, or timeline navigation.

In .NET applications, the `MouseWheel` event is triggered when the user rotates the mouse wheel. This event provides crucial information about the direction and intensity of the wheel movement through the `MouseEventArgs` parameter.

## Why Implement Mouse Wheel Events?

Mouse wheel functionality offers several benefits to your video applications:

- **Improved User Experience**: Enables intuitive zoom functionality in video viewers
- **Enhanced Navigation**: Allows quick timeline scrubbing in video editors
- **Volume Control**: Provides convenient volume adjustment in media players
- **Efficient UI Interaction**: Reduces reliance on on-screen controls

## Basic Implementation

### Setting Up Event Handlers

To implement mouse wheel functionality in your .NET application, you need to set up three key event handlers:

1. `MouseEnter`: Ensures the control gains focus when the mouse enters
2. `MouseLeave`: Releases focus when the mouse leaves
3. `MouseWheel`: Handles the actual wheel rotation event

Here's a basic implementation:

```
private void VideoView1_MouseEnter(object sender, EventArgs e)
{
  if (!VideoView1.Focused)
  {
    VideoView1.Focus();
  }
}

private void VideoView1_MouseLeave(object sender, EventArgs e)
{
  if (VideoView1.Focused)
  {
    VideoView1.Parent.Focus();
  }
}

private void VideoView1_MouseWheel(object sender, MouseEventArgs e)
{
  mmLog.Text += "Delta: " + e.Delta + Environment.NewLine;
}
```

The `MouseWheel` event handler receives a `MouseEventArgs` parameter that includes the `Delta` property. This value indicates the direction and distance the wheel has rotated:

- **Positive Delta**: The wheel rotated forward (away from the user)
- **Negative Delta**: The wheel rotated backward (toward the user)
- **Delta Magnitude**: Indicates the intensity of the rotation

## Advanced Implementation Techniques

### Implementing Zoom Functionality

One common use of the mouse wheel in video applications is to zoom in and out. Here's how you might implement zoom functionality:

```
private void VideoView1_MouseWheel(object sender, MouseEventArgs e)
{
    // Determine zoom direction based on delta
    if (e.Delta > 0)
    {
        // Zoom in code
        ZoomIn(0.1); // Increase zoom by 10%
    }
    else
    {
        // Zoom out code
        ZoomOut(0.1); // Decrease zoom by 10%
    }
}

private double _zoomRatio = 1.0;

private void ZoomIn(double factor)
{
    // Zoom is exposed on the renderer (classic engine) or via a ZoomEffect on the X engine,
    // not on VideoView. The classic engine uses `videoCapture1.Video_Renderer.Zoom_Ratio`
    // (and Zoom_ShiftX / Zoom_ShiftY for the centre offset).
    _zoomRatio = Math.Min(_zoomRatio + factor, 3.0); // Max zoom of 300%
    videoCapture1.Video_Renderer.Zoom_Ratio = _zoomRatio;
    videoCapture1.Video_Renderer_Update();
}

private void ZoomOut(double factor)
{
    _zoomRatio = Math.Max(_zoomRatio - factor, 0.5); // Min zoom of 50%
    videoCapture1.Video_Renderer.Zoom_Ratio = _zoomRatio;
    videoCapture1.Video_Renderer_Update();
}
```

### Timeline Navigation

For video editing applications, the mouse wheel can be used to navigate through the timeline:

```
private void TimelineControl_MouseWheel(object sender, MouseEventArgs e)
{
    // Calculate how much to move based on delta and timeline length
    double moveFactor = e.Delta / 120.0; // Normalize to increments of 1.0
    double moveAmount = moveFactor * 5.0; // 5 seconds per wheel "click"

    // Move position
    double newPosition = TimelineControl.CurrentPosition + moveAmount;

    // Ensure we stay within bounds
    newPosition = Math.Max(0, Math.Min(newPosition, TimelineControl.Duration));

    // Apply the new position
    TimelineControl.CurrentPosition = newPosition;
}
```

### Volume Control

Another common use case is controlling volume in media player applications:

```
private void VideoView1_MouseWheel(object sender, MouseEventArgs e)
{
    // Volume is engine-level (not on VideoView). The classic engine exposes
    // Audio_OutputDevice_Volume in 0–100 percent range; the X engine exposes
    // Audio_OutputDevice_Volume in 0.0–1.0 range. Sample below targets the
    // classic VideoCaptureCore / MediaPlayerCore — adjust the percent math
    // to a 0–1 ratio if you are on the X engine.
    int volumeChangePercent = (int)Math.Round(e.Delta / 120.0 * 5.0); // 5 percentage points per wheel "click"

    int newVolume = videoCapture1.Audio_OutputDevice_Volume + volumeChangePercent;
    newVolume = Math.Max(0, Math.Min(newVolume, 100));

    videoCapture1.Audio_OutputDevice_Volume = newVolume;

    // Optional: Display volume indicator (0–1 ratio for the indicator UI)
    ShowVolumeIndicator(newVolume / 100f);
}
```

## Handling Focus Management

Proper focus management is crucial for mouse wheel events to work correctly. The example code shows a basic implementation, but in more complex applications, you may need a more sophisticated approach:

```
private void VideoView1_MouseEnter(object sender, EventArgs e)
{
    // Store the previously focused control
    _previouslyFocused = Form.ActiveControl;

    // Focus our control
    VideoView1.Focus();

    // Optional: Visual indication that the control has focus
    VideoView1.BorderStyle = BorderStyle.FixedSingle;
}

private void VideoView1_MouseLeave(object sender, EventArgs e)
{
    // Return focus to previous control if appropriate
    if (_previouslyFocused != null && _previouslyFocused.CanFocus)
    {
        _previouslyFocused.Focus();
    }
    else
    {
        // If no previous control, focus the parent
        VideoView1.Parent.Focus();
    }

    // Reset visual indication
    VideoView1.BorderStyle = BorderStyle.None;
}
```

## Performance Considerations

When implementing mouse wheel events, consider these performance tips:

1. **Debounce Wheel Events**: Mouse wheels can generate many events in quick succession
2. **Optimize Calculations**: Avoid complex calculations in the wheel event handler
3. **Use Animation**: For smooth zooming, consider using animation rather than abrupt changes

Here's an example of debouncing wheel events:

```
private DateTime _lastWheelEvent = DateTime.MinValue;
private const int DebounceMs = 50;

private void VideoView1_MouseWheel(object sender, MouseEventArgs e)
{
    // Check if enough time has passed since the last event
    TimeSpan elapsed = DateTime.Now - _lastWheelEvent;
    if (elapsed.TotalMilliseconds < DebounceMs)
    {
        return; // Ignore event if it's too soon
    }

    // Process the wheel event
    ProcessWheelEvent(e.Delta);

    // Update the last event time
    _lastWheelEvent = DateTime.Now;
}
```

## Cross-Platform Considerations

If you're developing cross-platform .NET applications, be aware that mouse wheel behavior can vary:

- **Windows**: Typically 120 units per "click"
- **macOS**: May have different sensitivity settings
- **Linux**: Can vary based on distribution and configuration

Your code should account for these differences:

```
private void VideoView1_MouseWheel(object sender, MouseEventArgs e)
{
    // Normalize delta based on platform
    double normalizedDelta;

    if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
    {
        normalizedDelta = e.Delta / 120.0;
    }
    else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
    {
        normalizedDelta = e.Delta / 100.0;
    }
    else
    {
        normalizedDelta = e.Delta / 120.0; // Default for Linux and others
    }

    // Use normalized delta for calculations
    ApplyZoom(normalizedDelta);
}
```

## Troubleshooting Common Issues

### Mouse Wheel Events Not Firing

If your mouse wheel events aren't firing, check:

1. **Focus Issues**: Ensure the control has focus when the mouse is over it
2. **Event Registration**: Verify the event handler is properly registered
3. **Control Properties**: Some controls need specific properties set to receive wheel events

### Inconsistent Behavior

If wheel events behave inconsistently:

1. **Delta Normalization**: Ensure you're properly normalizing delta values
2. **User Settings**: Account for user-specific mouse settings
3. **Hardware Variations**: Different mouse hardware can produce different delta values

## Conclusion

Mouse wheel event handling is an essential aspect of creating intuitive and user-friendly video applications. By implementing the techniques outlined in this guide, you can enhance your .NET video applications with smooth, intuitive controls that improve the overall user experience.

The implementation can vary depending on your specific requirements, but the core principles remain the same: handle focus properly, normalize wheel delta values, and apply appropriate changes based on user input.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Multiple Video Screens in WPF — C# .NET Multi-Display Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/multiple-screens-wpf/
**Description:** Create multi-display video applications in WPF with Image controls, event handling, memory management, and performance optimization techniques.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows, WPF, C#
**API:** VideoCaptureCore, VideoCaptureSource, VideoFrameBufferEventArgs, MultiscreenVideoView, VideoView

# Implementing Multiple Video Output Screens in WPF Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

When developing WPF applications that require handling multiple video feeds simultaneously, developers often face challenges with performance, synchronization, and resource management. This guide provides a comprehensive approach to implementing multiple video output screens in your WPF applications using C# and the Image control.

## Getting Started with Multiple Video Screens

Check the installation guide for WPF [here](../../../install/).

To begin implementing multiple video outputs in your WPF application, you'll need to:

1. Add the appropriate Video View control to your application
2. Set up event handling for video frame processing
3. Configure your rendering pipeline for optimal performance

### Two supported patterns

To show the same video feed on multiple views in WPF, pick one of these two real patterns:

1. **`MultiscreenVideoView` + `OnVideoFrameBuffer`** — one SDK engine pushes each frame into as many `MultiscreenVideoView` controls as you like. Use this when a single capture/playback engine drives several on-screen copies.
2. **One engine per `VideoView`** — each display gets its own `VideoCaptureCore` / `MediaPlayerCore` / `VideoEditCore` instance bound to its own regular `VideoView`. Use this when the displays show **different** sources (e.g. a four-camera security grid). See the [Four-Camera Security System](#practical-example-four-camera-security-system) example below.

Regular `VisioForge.Core.UI.WPF.VideoView` does not expose a `RenderFrame` method — it is driven automatically by the engine it's bound to via `CreateAsync(IVideoView)`. Frame fan-out requires `MultiscreenVideoView`.

### Setting Up Your WPF Project for Frame Fan-out

Drop one or more `VisioForge.Core.UI.WPF.MultiscreenVideoView` controls on your WPF window. Give them descriptive names (e.g. `multiView1`, `multiView2`). These are the controls that accept pushed frames.

### Handling Video Frames

Subscribe to the SDK engine's `OnVideoFrameBuffer` event. The event args carry a `VideoFrameBufferEventArgs` that each `MultiscreenVideoView` can render.

## Implementing the Video Frame Handler

```
private void VideoCapture1_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    multiView1.RenderFrame(e);
}
```

`MultiscreenVideoView.RenderFrame(VideoFrameBufferEventArgs)` copies the frame into its own internal surface, so the engine's buffer can be released when the handler returns.

## Advanced Implementation Techniques

### Creating Dynamic MultiscreenVideoViews

For applications requiring a variable number of video outputs, dynamically create `MultiscreenVideoView` controls:

```
private List<VisioForge.Core.UI.WPF.MultiscreenVideoView> multiViews =
    new List<VisioForge.Core.UI.WPF.MultiscreenVideoView>();

private void CreateMultiView(Grid container, int row, int column)
{
    var view = new VisioForge.Core.UI.WPF.MultiscreenVideoView();
    Grid.SetRow(view, row);
    Grid.SetColumn(view, column);

    container.Children.Add(view);
    multiViews.Add(view);
}

// Usage example:
// CreateMultiView(mainGrid, 0, 0);
// CreateMultiView(mainGrid, 0, 1);
```

### Distributing Video Frames to Multiple Views

Fan out incoming frames to every registered `MultiscreenVideoView`:

```
private void VideoCapture1_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    // Render to all MultiscreenVideoView instances
    foreach (var view in multiViews)
    {
        view.RenderFrame(e);
    }
}
```

## Performance Optimization Strategies

### Reducing Render Load

For multiple video views, consider these optimization techniques:

1. **Frame skipping**: Not every view needs to update at full frame rate
2. **Hide off-screen views**: WPF culls rendering for collapsed controls — use `Visibility.Collapsed` on views that aren't visible

```
private int frameCounter;

private void VideoCapture1_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    // Primary view gets every frame
    primaryMultiView.RenderFrame(e);

    // Secondary views get every second frame
    if (frameCounter % 2 == 0)
    {
        foreach (var view in secondaryMultiViews)
        {
            view.RenderFrame(e);
        }
    }

    frameCounter++;
}
```

## Practical Example: Four-Camera Security System

Here's a more complete example of implementing a four-camera security system using the Video Capture SDK's `VideoCaptureCore` engine. Each camera gets its own engine instance bound to a dedicated `VideoView`.

```
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using VisioForge.Core.Types;
using VisioForge.Core.Types.VideoCapture;
using VisioForge.Core.UI.WPF;
using VisioForge.Core.VideoCapture;

public partial class SecurityMonitorWindow : Window
{
    private readonly List<VideoView> _cameraViews = new List<VideoView>();
    private readonly List<VideoCaptureCore> _cameras = new List<VideoCaptureCore>();

    public SecurityMonitorWindow()
    {
        InitializeComponent();
    }

    public async Task InitializeCamerasAsync(IEnumerable<string> deviceNames)
    {
        // Enumerate the first four capture devices if names aren't provided.
        var names = deviceNames?.Take(4).ToList();

        // Build a 2x2 grid of VideoView controls paired with VideoCaptureCore engines.
        int i = 0;
        for (int row = 0; row < 2; row++)
        {
            for (int col = 0; col < 2; col++, i++)
            {
                var view = new VideoView();
                Grid.SetRow(view, row);
                Grid.SetColumn(view, col);
                mainGrid.Children.Add(view);
                _cameraViews.Add(view);

                // The classic engine uses a constructor; CreateAsync is the X-engine pattern.
                // For VideoCaptureCoreX use `await VideoCaptureCoreX.CreateAsync(view)` instead.
                var camera = new VideoCaptureCore(view);
                _cameras.Add(camera);

                if (names != null && i < names.Count)
                {
                    camera.Video_CaptureDevice = new VideoCaptureSource(names[i]);
                    camera.Video_CaptureDevice.Format_UseBest = true;
                    camera.Mode = VideoCaptureMode.VideoPreview;
                    camera.Audio_PlayAudio = false;
                    camera.Audio_RecordAudio = false;
                }
            }
        }
    }

    public async Task StartCamerasAsync()
    {
        foreach (var camera in _cameras)
        {
            await camera.StartAsync();
        }
    }

    public async Task StopCamerasAsync()
    {
        foreach (var camera in _cameras)
        {
            await camera.StopAsync();
        }

        foreach (var camera in _cameras)
        {
            camera.Dispose();
        }
    }
}
```

Enumerate available devices with `camera.Video_CaptureDevices()` (or its async variant) to populate the `deviceNames` argument at runtime — see [the device enumeration guide](../../../videocapture/video-sources/video-capture-devices/enumerate-and-select/).

## Troubleshooting Common Issues

### Handling Frame Synchronization

If you experience frame timing issues across multiple displays:

```
private readonly object syncLock = new object();

private void VideoCapture1_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    lock (syncLock)
    {
        foreach (var view in multiViews)
        {
            view.RenderFrame(e);
        }
    }
}
```

---

For more code samples and advanced implementation techniques, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## OnVideoFrameBitmap — Real-Time Video Frame Access in .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/onvideoframebitmap-usage/
**Description:** Access and modify video frames in real-time with OnVideoFrameBitmap events for advanced video manipulation in C# applications.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows, C#
**API:** VideoFrameBitmapEventArgs

# OnVideoFrameBitmap Real-Time Frame Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

The `OnVideoFrameBitmap` event is a powerful feature in .NET video processing libraries that allows developers to access and modify video frames in real-time. This guide explores the practical applications, implementation techniques, and performance considerations when working with bitmap frame manipulation in C# applications.

## Understanding OnVideoFrameBitmap Events

The `OnVideoFrameBitmap` event provides a direct interface to access video frames as they're processed by the SDK. This capability is essential for applications that require:

- Real-time video analysis
- Frame-by-frame manipulation
- Dynamic overlay implementation
- Custom video effects
- Computer vision integration

When the event fires, it delivers a bitmap representation of the current video frame, allowing for pixel-level access and manipulation before the frame continues through the processing pipeline.

## Basic Implementation

`OnVideoFrameBitmap` exists on the Windows-only engines: `VideoCaptureCore`, `MediaPlayerCore`, and `VideoEditCore`. In the snippets below, `VideoCapture1` is a `VideoCaptureCore` instance — swap in `MediaPlayer1` or `VideoEdit1` if you are using a different engine.

Subscribe before starting the pipeline so the first frame is not missed:

```
// Event type: EventHandler<VideoFrameBitmapEventArgs>. Fires on a worker thread.
VideoCapture1.OnVideoFrameBitmap += VideoCapture1_OnVideoFrameBitmap;

// Implement the event handler
private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    // e.Frame — the current frame as a System.Drawing.Bitmap (owned by the SDK; do not dispose).
    // Set e.UpdateData = true if you mutate the bitmap in place.
}
```

## Manipulating Video Frames

### Simple Bitmap Overlay Example

The following example demonstrates how to overlay an image on each video frame:

```
Bitmap bmp = new Bitmap(@"c:\samples\pics\1.jpg");

using (Graphics g = Graphics.FromImage(e.Frame))
{
    g.DrawImage(bmp, 0, 0, bmp.Width, bmp.Height);
    e.UpdateData = true;
}

bmp.Dispose();
```

In this code:

1. We create a `Bitmap` object from an image file
2. We use the `Graphics` class to draw onto the frame bitmap
3. We set `e.UpdateData = true` to inform the SDK that we've modified the frame
4. We dispose of our resources properly to prevent memory leaks

> **Important:** Always set `e.UpdateData = true` when you modify the frame bitmap. This signals the SDK to use your modified frame instead of the original.

### Adding Text Overlays

Text overlays are commonly used for timestamps, captions, or informational displays:

```
using (Graphics g = Graphics.FromImage(e.Frame))
{
    // Create a semi-transparent background for text
    using (SolidBrush brush = new SolidBrush(Color.FromArgb(150, 0, 0, 0)))
    {
        g.FillRectangle(brush, 10, 10, 200, 30);
    }

    // Add text overlay
    using (Font font = new Font("Arial", 12))
    using (SolidBrush textBrush = new SolidBrush(Color.White))
    {
        g.DrawString(DateTime.Now.ToString(), font, textBrush, new PointF(15, 15));
    }

    e.UpdateData = true;
}
```

## Performance Considerations

When working with `OnVideoFrameBitmap`, it's crucial to optimize your code for performance. Each frame processing operation must complete quickly to maintain smooth video playback.

### Resource Management

Proper resource management is essential:

```
// Poor performance approach
private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    Bitmap overlay = new Bitmap(@"c:\logo.png");
    Graphics g = Graphics.FromImage(e.Frame);
    g.DrawImage(overlay, 0, 0);
    e.UpdateData = true;
    // Memory leak! Graphics and Bitmap not disposed
}

// Optimized approach
private Bitmap _cachedOverlay;

private void InitializeResources()
{
    _cachedOverlay = new Bitmap(@"c:\logo.png");
}

private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    using (Graphics g = Graphics.FromImage(e.Frame))
    {
        g.DrawImage(_cachedOverlay, 0, 0);
        e.UpdateData = true;
    }
}

private void CleanupResources()
{
    _cachedOverlay?.Dispose();
}
```

### Optimizing Processing Time

To maintain smooth video playback:

1. **Pre-compute where possible**: Prepare resources before processing begins
2. **Cache frequently used objects**: Avoid creating new objects for each frame
3. **Process only when necessary**: Add conditional logic to skip frames or perform less intensive operations when needed
4. **Use efficient drawing operations**: Choose appropriate GDI+ methods based on your needs

```
private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    // Only process every second frame
    if (_frameCounter % 2 == 0)
    {
        using (Graphics g = Graphics.FromImage(e.Frame))
        {
            // Your frame processing code
            e.UpdateData = true;
        }
    }
    _frameCounter++;
}
```

## Advanced Frame Manipulation Techniques

### Applying Filters and Effects

You can implement custom image processing filters:

```
private void ApplyGrayscaleFilter(Bitmap bitmap)
{
    Rectangle rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
    BitmapData bmpData = bitmap.LockBits(rect, ImageLockMode.ReadWrite, bitmap.PixelFormat);

    IntPtr ptr = bmpData.Scan0;
    int bytes = Math.Abs(bmpData.Stride) * bitmap.Height;
    byte[] rgbValues = new byte[bytes];

    Marshal.Copy(ptr, rgbValues, 0, bytes);

    // Process pixel data
    for (int i = 0; i < rgbValues.Length; i += 4)
    {
        byte gray = (byte)(0.299 * rgbValues[i + 2] + 0.587 * rgbValues[i + 1] + 0.114 * rgbValues[i]);
        rgbValues[i] = gray;     // Blue
        rgbValues[i + 1] = gray; // Green
        rgbValues[i + 2] = gray; // Red
    }

    Marshal.Copy(rgbValues, 0, ptr, bytes);
    bitmap.UnlockBits(bmpData);
}
```

## Integration with Computer Vision Libraries

The `OnVideoFrameBitmap` event can be combined with popular computer vision libraries:

```
// Example using a hypothetical computer vision library
private void VideoCapture1_OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    // Convert bitmap to format needed by CV library
    byte[] imageData = ConvertBitmapToByteArray(e.Frame);

    // Process with CV library
    var results = _computerVisionProcessor.DetectFaces(imageData, e.Frame.Width, e.Frame.Height);

    // Draw results back onto frame
    using (Graphics g = Graphics.FromImage(e.Frame))
    {
        foreach (var face in results)
        {
            g.DrawRectangle(new Pen(Color.Yellow, 2), face.X, face.Y, face.Width, face.Height);
        }

        e.UpdateData = true;
    }
}
```

## Troubleshooting Common Issues

### Memory Leaks

If you experience memory growth during prolonged video processing:

1. Ensure all `Graphics` objects are disposed
2. Properly dispose of any temporary `Bitmap` objects
3. Avoid capturing large objects in lambda expressions

### Performance Degradation

If frame processing becomes sluggish:

1. Profile your event handler to identify bottlenecks
2. Consider reducing processing frequency
3. Optimize GDI+ operations or consider DirectX for performance-critical applications

## SDK Integration

The `OnVideoFrameBitmap` event is available in the following SDKs:

## Required Dependencies

To use the functionality described in this guide, you'll need:

- SDK redistribution package
- System.Drawing (included in .NET Framework)
- Windows GDI+ support

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples and projects demonstrating these techniques in action.

---END OF PAGE---


## Read Video File Info in C# .NET — Duration, Codec, Streams
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/read-file-info/
**Description:** MediaInfoReader API returns video/audio stream details, subtitle tracks, FOURCC codes, and ID3 tags. Cross-platform file analysis with VisioForge SDK.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows, Metadata, MP4, C#
**API:** MediaInfoReader

# Reading Media File Information in C

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction

Accessing detailed information embedded within media files is essential for developing sophisticated applications like media players, video editors, content management systems, and file analysis tools. Understanding properties such as codecs, resolution, frame rate, bitrate, duration, and embedded tags allows developers to build more intelligent and user-friendly software.

This guide demonstrates how to read comprehensive information from video and audio files using C# and the `MediaInfoReader` class. The techniques shown are applicable across various .NET projects and provide a foundation for handling media files programmatically.

## Why Extract Media File Information?

Media file information serves multiple purposes in application development:

- **User Experience**: Display technical details to users in media players
- **Compatibility Checks**: Verify if files meet required specifications
- **Automated Processing**: Configure encoding parameters based on source properties
- **Content Organization**: Catalog media libraries with accurate metadata
- **Quality Assessment**: Evaluate media files for potential issues

## Implementation Guide

Let's explore the process of extracting media file information in a step-by-step approach. The examples assume a WinForms application with a `TextBox` control named `mmInfo` for displaying the extracted information.

### Step 1: Initialize the Media Information Reader

The first step involves creating an instance of the `MediaInfoReader` class:

```
// Import the necessary namespace
using VisioForge.Core.MediaInfo; // Namespace for MediaInfoReader
using VisioForge.Core.Helpers;  // Namespace for TagLibHelper (optional)

// Create an instance of MediaInfoReader
var infoReader = new MediaInfoReader();
```

This initialization prepares the reader to process media files.

### Step 2: Verify File Playability (Optional)

Before diving into detailed analysis, it's often useful to check if the file is supported:

```
// Define variables to hold potential error information
FilePlaybackError errorCode;
string errorText;

// Specify the path to the media file
string filename = @"C:\path\to\your\mediafile.mp4"; // Replace with your actual file path

// Check if the file is playable
if (MediaInfoReader.IsFilePlayable(filename, out errorCode, out errorText))
{
    // Display success message
    mmInfo.Text += "Status: This file appears to be playable." + Environment.NewLine;
}
else
{
    // Display error message including the error code and description
    mmInfo.Text += $"Status: This file might not be playable. Error: {errorCode} - {errorText}" + Environment.NewLine;
}

mmInfo.Text += "------------------------------------" + Environment.NewLine;
```

This verification provides early feedback on file integrity and compatibility.

### Step 3: Extract Detailed Stream Information

Now we can extract the rich metadata from the file:

```
try
{
    // Assign the filename to the reader
    infoReader.Filename = filename;

    // Read the file information (true for full analysis)
    infoReader.ReadFileInfo(true);

    // Process Video Streams
    mmInfo.Text += $"Found {infoReader.VideoStreams.Count} video stream(s)." + Environment.NewLine;

    for (int i = 0; i < infoReader.VideoStreams.Count; i++)
    {
        var stream = infoReader.VideoStreams[i];

        mmInfo.Text += Environment.NewLine;
        mmInfo.Text += $"--- Video Stream #{i + 1} ---" + Environment.NewLine;
        mmInfo.Text += $"  Codec: {stream.Codec}" + Environment.NewLine;
        mmInfo.Text += $"  Duration: {stream.Duration}" + Environment.NewLine;
        mmInfo.Text += $"  Dimensions: {stream.Width}x{stream.Height}" + Environment.NewLine;
        mmInfo.Text += $"  FOURCC: {stream.FourCC}" + Environment.NewLine;

        if (stream.AspectRatio != null && stream.AspectRatio.Item1 > 0 && stream.AspectRatio.Item2 > 0)
        {
             mmInfo.Text += $"  Aspect Ratio: {stream.AspectRatio.Item1}:{stream.AspectRatio.Item2}" + Environment.NewLine;
        }

        // VideoFrameRate is a struct (numerator/denominator) and not IFormattable — format via .Value (double).
        mmInfo.Text += $"  Frame Rate: {stream.FrameRate.Value:F2} fps" + Environment.NewLine;
        mmInfo.Text += $"  Bitrate: {stream.Bitrate / 1000.0:F0} kbps" + Environment.NewLine;
        mmInfo.Text += $"  Frames Count: {stream.FramesCount}" + Environment.NewLine;
    }

    // Process Audio Streams
    mmInfo.Text += Environment.NewLine;
    mmInfo.Text += $"Found {infoReader.AudioStreams.Count} audio stream(s)." + Environment.NewLine;

    for (int i = 0; i < infoReader.AudioStreams.Count; i++)
    {
        var stream = infoReader.AudioStreams[i];

        mmInfo.Text += Environment.NewLine;
        mmInfo.Text += $"--- Audio Stream #{i + 1} ---" + Environment.NewLine;
        mmInfo.Text += $"  Codec: {stream.Codec}" + Environment.NewLine;
        mmInfo.Text += $"  Codec Info: {stream.CodecInfo}" + Environment.NewLine;
        mmInfo.Text += $"  Duration: {stream.Duration}" + Environment.NewLine;
        mmInfo.Text += $"  Bitrate: {stream.Bitrate / 1000.0:F0} kbps" + Environment.NewLine;
        mmInfo.Text += $"  Channels: {stream.Channels}" + Environment.NewLine;
        mmInfo.Text += $"  Sample Rate: {stream.SampleRate} Hz" + Environment.NewLine;
        mmInfo.Text += $"  Bits Per Sample (BPS): {stream.BPS}" + Environment.NewLine;
        mmInfo.Text += $"  Language: {stream.Language}" + Environment.NewLine;
    }

    // Process Subtitle Streams
    mmInfo.Text += Environment.NewLine;
    mmInfo.Text += $"Found {infoReader.Subtitles.Count} subtitle stream(s)." + Environment.NewLine;

    for (int i = 0; i < infoReader.Subtitles.Count; i++)
    {
        var stream = infoReader.Subtitles[i];

        mmInfo.Text += Environment.NewLine;
        mmInfo.Text += $"--- Subtitle Stream #{i + 1} ---" + Environment.NewLine;
        mmInfo.Text += $"  Codec/Format: {stream.Codec}" + Environment.NewLine;
        mmInfo.Text += $"  Name: {stream.Name}" + Environment.NewLine;
        mmInfo.Text += $"  Language: {stream.Language}" + Environment.NewLine;
    }
}
catch (Exception ex)
{
    // Handle potential errors during file reading
    mmInfo.Text += $"{Environment.NewLine}Error reading file info: {ex.Message}{Environment.NewLine}";
}
finally
{
    // Important: Dispose the reader to release file handles and resources
    infoReader.Dispose();
}
```

The code iterates through each collection (`VideoStreams`, `AudioStreams`, and `Subtitles`), extracting and displaying relevant information for every stream found.

### Step 4: Extract Metadata Tags

Beyond technical stream information, media files often contain metadata tags:

```
// Read Metadata Tags
mmInfo.Text += Environment.NewLine + "--- Metadata Tags ---" + Environment.NewLine;
try
{
    // Use TagLibHelper to read tags from the file
    var tags = TagLibHelper.ReadTags(filename);

    // Check if tags were successfully read
    if (tags != null)
    {
        mmInfo.Text += $"Title: {tags.Title}" + Environment.NewLine;
        mmInfo.Text += $"Artist(s): {string.Join(", ", tags.Performers ?? new string[0])}" + Environment.NewLine;
        mmInfo.Text += $"Album: {tags.Album}" + Environment.NewLine;
        mmInfo.Text += $"Year: {tags.Year}" + Environment.NewLine;
        mmInfo.Text += $"Genre: {string.Join(", ", tags.Genres ?? new string[0])}" + Environment.NewLine;
        mmInfo.Text += $"Comment: {tags.Comment}" + Environment.NewLine;
    }
    else
    {
        mmInfo.Text += "No standard metadata tags found or readable." + Environment.NewLine;
    }
}
catch (Exception ex)
{
    // Handle errors during tag reading
    mmInfo.Text += $"Error reading tags: {ex.Message}" + Environment.NewLine;
}
```

## Best Practices for Media File Analysis

When implementing media file analysis in your applications, consider these best practices:

### Error Handling

Always wrap file operations in appropriate try-catch blocks. Media files can be corrupted, inaccessible, or in unexpected formats, which might cause exceptions.

```
try {
    // Media file operations
}
catch (Exception ex) {
    // Log error and provide user feedback
}
```

### Resource Management

Properly dispose of objects that access file resources to prevent file locking issues:

```
using (var infoReader = new MediaInfoReader())
{
    // Use the reader
}
// Or manually in a finally block
try {
    // Operations
}
finally {
    infoReader.Dispose();
}
```

### Performance Considerations

For large media libraries, consider:

1. Implementing caching mechanisms for repeated analysis
2. Using background threads for processing to keep UI responsive
3. Limiting the depth of analysis for initial quick scans

## Required Components

For successful implementation, ensure your project includes the necessary dependencies as specified in the SDK documentation.

## Conclusion

Extracting information from media files is a powerful capability for developers building applications that work with audio and video content. With the techniques outlined in this guide, you can access detailed technical properties and metadata tags to enhance your application's functionality.

The `MediaInfoReader` class provides a convenient and efficient way to extract the necessary metadata, allowing you to build more sophisticated media handling features in your C# applications.

For more advanced scenarios, explore the full capabilities of the SDK and consult the detailed documentation. You can find additional code samples and examples on GitHub to further expand your media file processing capabilities.

---END OF PAGE---


## Video Renderer in C# .NET — EVR, Direct2D, WPF, MadVR
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/select-video-renderer-winforms/
**Description:** Configure video rendering in C# / .NET across WinForms, WPF, and WinUI 3. EVR, Direct2D, madVR, native HWND, callback modes — setup and hardware acceleration.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, DirectShow, MediaPlayerCoreX, VideoCaptureCoreX, VideoEditCore, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Playback, Streaming, Encoding, Editing, Conversion, C#
**API:** VideoRenderer, VideoRendererMode, VideoView, VideoRendererStretchMode, VideoCaptureCoreX

# Video Renderer Options in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction

The classic engines (`VideoCaptureCore`, `VideoEditCore`, `MediaPlayerCore`) expose **10 video renderer modes** through the `VideoRendererMode` enum. Choosing the right one controls how frames reach the screen: raw DirectShow filters, Direct2D GPU surfaces, native HWND embedded in WPF, frame callbacks for custom rendering, WinUI 3 controls, or the third-party madVR renderer. This guide walks through each mode with minimal enable code, platform availability, and a decision guide at the top so you can skip straight to the mode your app needs.

Classic engines only

This page covers the DirectShow-based classic engines. The cross-platform `VideoCaptureCoreX` / `MediaPlayerCoreX` engines use a `VideoView` control with GStreamer sinks and do not expose a `VideoRendererMode` enum on the engine — the render mode is selected on the `VideoView` control itself. See [Overlaying WPF Controls on Video](../wpf-controls-over-video/) for the WPF render modes of both engine families.

## Quick pick — which renderer for which app?

| Mode | UI framework | Best for |
| --- | --- | --- |
| `VideoRenderer` (legacy GDI) | WinForms | Maximum compatibility on very old hardware |
| `VMR9` | WinForms | Windows XP / Vista, software + light HW accel |
| `EVR` | WinForms | Default pick on modern Windows (Vista+) |
| `Direct2D` | WinForms, WPF | GPU-accelerated 2D, 4K+ content, modern apps |
| `Direct2DManaged` | WPF | Managed Direct2D with WPF-aware pause on minimize |
| `WPF_NativeHWND` | WPF | Native HWND embedded in WPF for higher perf than pure WPF |
| `WPF_WinUI_Callback` (`FrameCallback`) | WPF, WinUI, custom | Per-frame callbacks for CV, AI, custom rendering |
| `WinUI` | WinUI 3 | Native WinUI 3 apps (Windows 10/11) |
| `MadVR` | WinForms | Reference-grade scaling + color, needs external madVR install |
| `None` | any | Headless / audio-only / file conversion without preview |

## Understanding Available Video Renderer Options

The detailed sections below describe each mode, starting with the three classic DirectShow renderers.

### Legacy Video Renderer (GDI-based)

The Video Renderer is the oldest option in the DirectShow ecosystem. It relies on GDI (Graphics Device Interface) for drawing operations.

**Key characteristics:**

- Software-based rendering without hardware acceleration
- Compatible with older systems and configurations
- Lower performance ceiling compared to modern alternatives
- Simple implementation with minimal configuration options

**Implementation example:**

```
VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.VideoRenderer;
```

**When to use:**

- Compatibility is the primary concern
- Application targets older hardware or operating systems
- Minimal video processing requirements
- Troubleshooting issues with newer renderers

### Video Mixing Renderer 9 (VMR9)

VMR9 represents a significant improvement over the legacy renderer, introducing support for hardware acceleration and advanced features.

**Key characteristics:**

- Hardware-accelerated rendering through DirectX 9
- Support for multiple video streams mixing
- Advanced deinterlacing options
- Alpha blending and compositing capabilities
- Custom video effects processing

**Implementation example:**

```
VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.VMR9;
```

**When to use:**

- Modern applications requiring good performance
- Video editing or composition features are needed
- Multiple video stream scenarios
- Applications that need to balance performance and compatibility

### Enhanced Video Renderer (EVR)

EVR is the most advanced option, available in Windows Vista and later operating systems. It leverages the Media Foundation framework rather than pure DirectShow.

**Key characteristics:**

- Latest hardware acceleration technologies
- Superior video quality and performance
- Enhanced color space processing
- Better multi-monitor support
- More efficient CPU usage
- Improved synchronization mechanisms

**Implementation example:**

```
VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.EVR;
```

**When to use:**

- Modern applications targeting Windows Vista or later
- Maximum performance and quality are required
- Applications handling HD or 4K content
- When advanced synchronization is important
- Multiple display environments

### Direct2D Renderer

Direct2D provides high-performance 2D rendering with GPU acceleration. It is available on both WinForms and WPF hosts and is the recommended modern choice when you need hardware-accelerated rendering with simple rotation, flip, and stretch controls.

**Key characteristics:**

- Hardware-accelerated via Direct2D / Direct3D 11
- Works on both WinForms and WPF
- Supports rotation (0 / 90 / 180 / 270), horizontal and vertical flip
- Clean stretch mode integration (`Stretch` / `Letterbox`)
- Low CPU overhead, scales well to 4K / 8K content

**Implementation example:**

```
VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.Direct2D;
VideoCapture1.Video_Renderer.RotationAngle = 0;
VideoCapture1.Video_Renderer.StretchMode = VideoRendererStretchMode.Letterbox;
VideoCapture1.Video_Renderer.Flip_Horizontal = false;
VideoCapture1.Video_Renderer.Flip_Vertical = false;
await VideoCapture1.Video_Renderer_UpdateAsync();
```

**When to use:**

- Modern WinForms or WPF apps that want GPU-accelerated rendering
- 4K / 8K sources where CPU-based paths would bottleneck
- Apps that need run-time rotation or flip controls

### Direct2DManaged Renderer (WPF)

A WPF-specific managed variant of Direct2D. Integrates more cleanly with the WPF object model and automatically pauses rendering when the window is minimized — useful for long-running playback apps where you don't want GPU work on hidden windows.

**Implementation example:**

```
VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.Direct2DManaged;
VideoCapture1.Video_Renderer.StretchMode = VideoRendererStretchMode.Letterbox;
await VideoCapture1.Video_Renderer_UpdateAsync();
```

Rotation, flip, and stretch options are shared with the regular `Direct2D` mode. Pause-on-minimize is handled automatically by the WPF `VideoView` control.

**When to use:**

- WPF apps where you want Direct2D performance with WPF-friendly lifecycle
- Multi-window dashboards where inactive windows should not consume GPU cycles

### WPF Native HWND Renderer

Hosts a native Win32 HWND inside the WPF `VideoView` control. Gives you raw DirectShow renderer performance in a WPF layout at the cost of standard WPF-render-chain quirks (airspace issues with overlapping controls).

**Implementation example:**

```
VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.WPF_NativeHWND;
await VideoCapture1.Video_Renderer_UpdateAsync();
```

**When to use:**

- WPF apps that need maximum DirectShow rendering performance
- Apps embedding legacy filters that expect a HWND target
- You don't need to overlay WPF controls on top of the video surface

### FrameCallback Renderer (WPF\_WinUI\_Callback)

A callback-based rendering mode. Instead of drawing frames directly, the engine delivers each frame to your code via events, letting you render with any library (SkiaSharp, `System.Drawing`, custom OpenGL/DirectX, WriteableBitmap) or feed a non-visual pipeline (computer vision, AI inference, streaming to a remote endpoint).

`FrameCallback` is an alias for `WPF_WinUI_Callback` — the same mode with a more self-descriptive name.

**Implementation example:**

```
VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.FrameCallback;
await VideoCapture1.Video_Renderer_UpdateAsync();

// Subscribe to frame events
VideoCapture1.OnVideoFrameBitmap += (sender, e) =>
{
    // e.Frame is a System.Drawing.Bitmap — render to a PictureBox, WriteableBitmap, etc.
};

VideoCapture1.OnVideoFrameBuffer += (sender, e) =>
{
    // e.Frame.Data is IntPtr — wrap with SkiaSharp / Marshal.Copy for pixel-level work
};
```

See [Image drawing via OnVideoFrameBuffer](../image-onvideoframebuffer/) and [Text drawing via OnVideoFrameBuffer](../text-onvideoframebuffer/) for detailed per-frame processing examples.

**When to use:**

- Computer-vision / ML pipelines that consume raw frames
- Custom rendering with SkiaSharp, DirectX, or OpenGL
- WPF / WinUI / MAUI apps that render into a `WriteableBitmap` manually
- Apps with no preview surface at all (frames shipped to a server, encoder, etc.)

### WinUI 3 Renderer

Native rendering for WinUI 3 apps on Windows 10/11. Use this mode when your shell is `Microsoft.UI.Xaml` and you host a `VisioForge.Core.UI.WinUI.VideoView` control.

**Implementation example:**

```
VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.WinUI;
await VideoCapture1.Video_Renderer_UpdateAsync();
```

**When to use:**

- WinUI 3 apps (Windows App SDK, not the old WinUI 2 / UWP)
- You want native look-and-feel consistency with other WinUI content

### madVR Renderer (third-party)

[madVR](https://madvr.com/) is a reference-quality external video renderer popular with home-theatre PCs and high-end video software. It delivers superior scaling algorithms, color management, and deinterlacing at the cost of higher GPU load. Supported only on WinForms hosts; requires a separate madVR installation on the target machine (the CLSID-registered DirectShow filter must be present).

**Implementation example:**

```
VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.MadVR;
await VideoCapture1.Video_Renderer_UpdateAsync();
```

**Runtime requirement:** ensure madVR is installed on the target system. If the filter is missing, `Video_Renderer_UpdateAsync` will fail — use the fallback pattern shown in [Renderer Compatibility Problems](#renderer-compatibility-problems) below to degrade gracefully to EVR.

**When to use:**

- Reference-grade video quality for mastering, HTPC, or media server UIs
- Audiences with GPUs that can absorb the extra rendering cost
- You can ship / document a separate madVR install step

### None (headless)

Disables rendering entirely. The capture / edit / playback graph still runs — frames flow to encoders, file outputs, streaming endpoints, or callbacks — but no preview surface is allocated.

**Implementation example:**

```
VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.None;
await VideoCapture1.Video_Renderer_UpdateAsync();
```

**When to use:**

- Audio-only capture (microphone-to-file) when the SDK has both audio and video branches
- File conversion / transcoding without a preview window
- Server-side rendering pipelines
- Unit tests and headless CI runs

## Advanced Configuration Options

Beyond just selecting a renderer, the SDK provides various configuration options to fine-tune video presentation.

### Working with Deinterlacing Modes

When displaying interlaced video content (common in broadcast sources), proper deinterlacing improves visual quality significantly. The SDK supports various deinterlacing algorithms depending on the renderer chosen.

First, retrieve the available deinterlacing modes. `Video_Renderer_Deinterlace_Modes()` returns the VMR-9 mode names auto-discovered from the current driver:

```
// Populate a dropdown with the available VMR-9 modes
foreach (string deinterlaceMode in VideoCapture1.Video_Renderer_Deinterlace_Modes())
{
  cbDeinterlaceModes.Items.Add(deinterlaceMode);
}
```

Deinterlacing is configured on the two renderers separately. VMR-9 takes a mode-name string; EVR takes a `VideoRendererEVRDeinterlaceMode` enum value:

```
// VMR-9 — set the mode string selected by the user
VideoCapture1.Video_Renderer.Deinterlace_VMR9_Mode = cbDeinterlaceModes.SelectedItem.ToString();
VideoCapture1.Video_Renderer.Deinterlace_VMR9_UseDefault = false;

// EVR — use the enum instead
// VideoCapture1.Video_Renderer.Deinterlace_EVR_Mode = VideoRendererEVRDeinterlaceMode.Auto;

VideoCapture1.Video_Renderer_Update();
```

VMR9 and EVR support various deinterlacing algorithms including:

- Bob (simple line doubling)
- Weave (field interleaving)
- Motion adaptive
- Motion compensated (highest quality)

The availability of specific algorithms depends on the video card capabilities and driver implementation.

### Managing Aspect Ratio and Stretch Modes

When displaying video in a window or control that doesn't match the source's native aspect ratio, you need to decide how to handle this discrepancy. The SDK provides multiple stretch modes to address different scenarios.

#### Stretch Mode

This mode stretches the video to fill the entire display area, potentially distorting the image:

```
VideoCapture1.Video_Renderer.StretchMode = VideoRendererStretchMode.Stretch;
VideoCapture1.Video_Renderer_Update();
```

**Use cases:**

- When aspect ratio is not critical
- Filling the entire display area is more important than proportions
- Source and display have similar aspect ratios
- User interface constraints require full-area usage

#### Letterbox Mode

This mode preserves the original aspect ratio by adding black borders as needed:

```
VideoCapture1.Video_Renderer.StretchMode = VideoRendererStretchMode.Letterbox;
VideoCapture1.Video_Renderer_Update();
```

**Use cases:**

- Maintaining correct proportions is essential
- Professional video applications
- Content where distortion would be noticeable or problematic
- Cinema or broadcast content viewing

#### LetterboxToFill Mode

This mode fills the display area while preserving aspect ratio, cropping any overflow on one axis:

```
VideoCapture1.Video_Renderer.StretchMode = VideoRendererStretchMode.LetterboxToFill;
VideoCapture1.Video_Renderer_Update();
```

**Use cases:**

- Consumer video applications where filling the screen is preferred
- Content where edges are less important than center
- Social media-style video display
- When trying to eliminate letterboxing in already letterboxed content

### Aspect-Ratio Override

To force a specific display aspect ratio (e.g. show 4:3 content letterboxed inside a 16:9 container), enable the override and set the ratio components:

```
VideoCapture1.Video_Renderer.Aspect_Ratio_Override = true;
VideoCapture1.Video_Renderer.Aspect_Ratio_X = 4;
VideoCapture1.Video_Renderer.Aspect_Ratio_Y = 3;
VideoCapture1.Video_Renderer_Update();
```

### Zoom and Pan

`VideoRendererSettings` exposes zoom/shift properties useful for digital PTZ on a preview:

```
VideoCapture1.Video_Renderer.Zoom_Ratio  = 150; // 150%
VideoCapture1.Video_Renderer.Zoom_ShiftX = 0;
VideoCapture1.Video_Renderer.Zoom_ShiftY = 0;
VideoCapture1.Video_Renderer_Update();
```

### Flip and Rotation

```
VideoCapture1.Video_Renderer.Flip_Horizontal = true;
VideoCapture1.Video_Renderer.Flip_Vertical   = false;
// RotationAngle is only respected by the Direct2D renderer and accepts 0, 90, 180, or 270.
VideoCapture1.Video_Renderer.RotationAngle   = 90;
VideoCapture1.Video_Renderer_Update();
```

## Troubleshooting Common Issues

### Renderer Compatibility Problems

If you encounter issues with a specific renderer, try falling back to a more compatible option:

```
try
{
    // Try using EVR first
    VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.EVR;
    VideoCapture1.Video_Renderer_Update();
}
catch
{
    try
    {
        // Fall back to VMR9
        VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.VMR9;
        VideoCapture1.Video_Renderer_Update();
    }
    catch
    {
        // Last resort - legacy renderer
        VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.VideoRenderer;
        VideoCapture1.Video_Renderer_Update();
    }
}
```

## Best Practices and Recommendations

1. **Choose the right renderer for your target environment**:
2. For modern Windows: EVR
3. For broad compatibility: VMR9
4. For legacy systems: Video Renderer
5. **Test on various hardware configurations**: Video rendering can behave differently across GPU vendors and driver versions.
6. **Implement renderer fallback logic**: Always have a backup plan if the preferred renderer fails.
7. **Consider your video content**: Higher resolution or interlaced content will benefit more from advanced renderers.
8. **Balance quality vs. performance**: The highest quality settings might not always deliver the best user experience if they impact performance.

## Required Dependencies

To ensure proper functionality of these renderers, make sure to include:

- SDK redistributable packages
- DirectX End-User Runtime (latest version recommended)
- .NET Framework runtime appropriate for your application

## Conclusion

The classic engines offer 10 renderer modes covering WinForms, WPF, and WinUI 3. **EVR** is the safe default for WinForms, **Direct2D** for modern GPU-accelerated rendering on either WinForms or WPF, **FrameCallback** for custom pipelines (CV / AI / bespoke rendering), **WinUI** for WinUI 3 shells, and **madVR** for reference-quality scenarios that can accommodate the external install. `None` is the right mode when there is no preview at all.

For applications built on the cross-platform `VideoCaptureCoreX` / `MediaPlayerCoreX` engines, renderer choice is handled by the `VideoView` control and does not use this enum.

## Related documentation

- [Image drawing via OnVideoFrameBuffer](../image-onvideoframebuffer/) — pixel-level frame processing, the canonical use case for `FrameCallback`.
- [Text drawing via OnVideoFrameBuffer](../text-onvideoframebuffer/) — text overlays with `FrameCallback`.
- [Rendering video in a PictureBox](../draw-video-picturebox/) — WinForms rendering pattern that pairs well with `FrameCallback`.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Draw Text on Video Frames in C# .NET — OnVideoFrameBuffer
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/text-onvideoframebuffer/
**Description:** Draw dynamic text on video frames in C# / .NET using the OnVideoFrameBuffer event. Timestamps, sensor data, custom fonts — pixel-level rendering.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, DirectShow, MediaPlayerCoreX, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Playback, C#
**API:** VideoEffectTextLogo, VideoFrameBufferEventArgs, VideoFrameXBufferEventArgs, VideoCaptureCoreX, MediaPlayerCoreX

# Creating Custom Text Overlays with OnVideoFrameBuffer in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction

The `OnVideoFrameBuffer` event gives direct, pixel-level access to every video frame as it passes through the pipeline. Drawing text onto the frame — timestamps, sensor readings, debug telemetry, or custom branding — is one of the most common uses. This guide shows how to render text on raw frames with full control over font, color, position, and per-frame logic.

Looking for the high-level text overlay feature?

If you just need a static, animated, or clock-driven text overlay with standard positioning, use the dedicated [text overlay effect](../../video-effects/text-overlay/) — one line of code via `Video_Effects_Add(new VideoEffectTextLogo(...))`. Use `OnVideoFrameBuffer` (this page) when you need **pixel-level control**: custom fonts, advanced layout, per-frame dynamic content, or integration with third-party text/graphics libraries.

### Supported engines

The `OnVideoFrameBuffer` event is exposed on both engine families:

| Engine | Event args type | Frame pixel format |
| --- | --- | --- |
| `VideoCaptureCore` (DirectShow, Windows) | `VideoFrameBufferEventArgs` | RGB24 / RGB32 |
| `VideoCaptureCoreX` (GStreamer, cross-platform) | `VideoFrameXBufferEventArgs` | BGRA (most common) |
| `MediaPlayerCoreX` (GStreamer, cross-platform) | `VideoFrameXBufferEventArgs` | BGRA (most common) |

Both engines follow the same pattern — subscribe to the event, read `e.Frame.Data` (an `IntPtr`) with `Width` / `Height` / `Stride`, render into the buffer in place, and set `e.UpdateData = true` to propagate changes downstream.

## Understanding the OnVideoFrameBuffer Event

The OnVideoFrameBuffer event is a powerful hook that gives developers direct access to the video frame buffer during processing. This event fires for each frame of video, providing an opportunity to modify the frame data before it's displayed or encoded.

Key benefits of using OnVideoFrameBuffer for text overlays include:

- **Frame-level access**: Modify individual frames with pixel-perfect precision
- **Dynamic content**: Update text based on real-time data or timestamps
- **Custom styling**: Apply custom fonts, colors, and effects beyond what built-in APIs offer
- **Performance optimizations**: Implement efficient rendering techniques for high-performance applications

## Implementation Overview

The technique presented here uses the following components:

1. An event handler for OnVideoFrameBuffer that processes each video frame
2. A VideoEffectTextLogo object to define text properties
3. The FastImageProcessing API to render text onto the frame buffer

This approach is particularly useful when you need to:

- Display dynamic data like timestamps, metadata, or sensor readings
- Create animated text effects
- Position text with pixel-perfect accuracy
- Apply custom styling not available through standard APIs

## Sample Code Implementation

The following C# example demonstrates how to implement a basic text overlay system using the OnVideoFrameBuffer event:

```
private void SDK_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    if (!logoInitiated)
    {
        logoInitiated = true;

        InitTextLogo();
    }

    // AddTextLogo(context, pixels, pixels32bit, pixels32tmp, frameWidth, frameHeight,
    //             ref textLogo, timeStamp, frameNumber)
    // Pass pixels32bit: false + pixels32tmp: IntPtr.Zero for RGB24 frames.
    FastImageProcessing.AddTextLogo(
        context: null,
        pixels: e.Frame.Data,
        pixels32bit: false,
        pixels32tmp: IntPtr.Zero,
        frameWidth: e.Frame.Info.Width,
        frameHeight: e.Frame.Info.Height,
        textLogo: ref textLogo,
        timeStamp: e.Frame.Timestamp,
        frameNumber: 0);
}

private bool logoInitiated = false;

private VideoEffectTextLogo textLogo = null;

private void InitTextLogo()
{
    textLogo = new VideoEffectTextLogo(true);
    textLogo.Text = "Hello world!";
    textLogo.Left = 50;
    textLogo.Top = 50;
}
```

## Detailed Code Explanation

Let's break down the key components of this implementation:

### The Event Handler

```
private void SDK_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
```

This method is triggered for each video frame. The VideoFrameBufferEventArgs provides access to:

- Frame data (pixel buffer)
- Frame dimensions (width and height)
- Timestamp information

### Initialization Logic

```
if (!logoInitiated)
{
    logoInitiated = true;
    InitTextLogo();
}
```

This code ensures the text logo is only initialized once, preventing unnecessary object creation for each frame. This pattern is important for performance when processing video at high frame rates.

### Text Logo Setup

```
private void InitTextLogo()
{
    textLogo = new VideoEffectTextLogo(true);
    textLogo.Text = "Hello world!";
    textLogo.Left = 50;
    textLogo.Top = 50;
}
```

The VideoEffectTextLogo class is used to define the properties of the text overlay:

- The text content ("Hello world!")
- Position coordinates (50 pixels from both left and top)

### Rendering the Text Overlay

```
FastImageProcessing.AddTextLogo(
    context: null,
    pixels: e.Frame.Data,
    pixels32bit: false,        // true when the engine delivers RGB32
    pixels32tmp: IntPtr.Zero,  // optional scratch buffer; IntPtr.Zero lets the helper allocate on demand
    frameWidth:  e.Frame.Info.Width,
    frameHeight: e.Frame.Info.Height,
    textLogo: ref textLogo,
    timeStamp: e.Frame.Timestamp,
    frameNumber: 0);
```

The 9-arg signature mirrors `FastImageProcessing.AddTextLogo` exactly. Width/height live inside `e.Frame.Info` on the classic `VideoFrame` struct; the timestamp lives on `e.Frame.Timestamp`. Pass `pixels32bit: true` when your source is RGB32.

## Advanced Customization Options

While the basic example demonstrates a simple static text overlay, the VideoEffectTextLogo class supports numerous customization options:

### Text Formatting

```
// Font is a full System.Drawing.Font — any typeface + style combo works.
textLogo.Font = new System.Drawing.Font("Arial", 24, System.Drawing.FontStyle.Bold);
textLogo.FontColor = System.Drawing.Color.White;
textLogo.TransparencyLevel = 200;   // 0 (fully transparent) - 255 (opaque)
```

### Background and Borders

```
textLogo.BackgroundTransparent = false;
textLogo.BackgroundColor = System.Drawing.Color.Black;

// Border ring is configured via BorderMode + per-ring colors and sizes (inner/outer).
// TextEffectMode values: None, Inner, Outer, InnerAndOuter, Embossed, Outline, FilledOutline, Halo.
textLogo.BorderMode = TextEffectMode.InnerAndOuter;
textLogo.BorderInnerColor = System.Drawing.Color.Yellow;
textLogo.BorderInnerSize = 2;
textLogo.BorderOuterColor = System.Drawing.Color.Black;
textLogo.BorderOuterSize = 1;
```

### Animation and Dynamic Content

For dynamic content that changes per frame:

```
private void SDK_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    if (!logoInitiated)
    {
        logoInitiated = true;
        InitTextLogo();
    }

    // Timestamp lives on e.Frame.Timestamp (TimeSpan)
    textLogo.Text = $"Timestamp: {e.Frame.Timestamp:hh\\:mm\\:ss\\.fff}";

    // Animate position
    textLogo.Left = 50 + (int)(Math.Sin(e.Frame.Timestamp.TotalSeconds) * 50);

    FastImageProcessing.AddTextLogo(
        context: null,
        pixels: e.Frame.Data,
        pixels32bit: false,
        pixels32tmp: IntPtr.Zero,
        frameWidth:  e.Frame.Info.Width,
        frameHeight: e.Frame.Info.Height,
        textLogo: ref textLogo,
        timeStamp: e.Frame.Timestamp,
        frameNumber: 0);
}
```

## Performance Considerations

When implementing custom text overlays, consider these performance best practices:

1. **Initialize objects once**: Create the VideoEffectTextLogo object only once, not per frame
2. **Minimize text changes**: Update text content only when necessary
3. **Use efficient fonts**: Simple fonts render faster than complex ones
4. **Consider resolution**: Higher resolution videos require more processing power
5. **Test on target hardware**: Ensure your implementation performs well on production systems

## Multiple Text Elements

To display multiple text elements on the same frame:

```
private VideoEffectTextLogo titleLogo = null;
private VideoEffectTextLogo timestampLogo = null;

private void InitTextLogos()
{
    titleLogo = new VideoEffectTextLogo(true);
    titleLogo.Text = "Camera Feed";
    titleLogo.Left = 50;
    titleLogo.Top = 50;

    timestampLogo = new VideoEffectTextLogo(true);
    timestampLogo.Left = 50;
    timestampLogo.Top = 100;
}

private void SDK_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    if (!logosInitiated)
    {
        logosInitiated = true;
        InitTextLogos();
    }

    // Update dynamic content
    timestampLogo.Text = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");

    // Render both text elements
    FastImageProcessing.AddTextLogo(null, e.Frame.Data, false, IntPtr.Zero,
        e.Frame.Info.Width, e.Frame.Info.Height, ref titleLogo, e.Frame.Timestamp, 0);
    FastImageProcessing.AddTextLogo(null, e.Frame.Data, false, IntPtr.Zero,
        e.Frame.Info.Width, e.Frame.Info.Height, ref timestampLogo, e.Frame.Timestamp, 0);
}
```

## VideoCaptureCoreX / MediaPlayerCoreX (X engines) example

On the cross-platform X engines the event signature is `VideoFrameXBufferEventArgs` and the frame buffer typically arrives in **BGRA** format (4 bytes per pixel). The example below uses SkiaSharp to wrap the raw buffer and draw text on top; SkiaSharp is a transitive dependency of the X engines, so no extra NuGet package is needed.

```
using SkiaSharp;

// Create paints once, reuse across frames
private SKPaint _textPaint = new SKPaint
{
    Color = SKColors.White,
    TextSize = 32,
    IsAntialias = true,
    Typeface = SKTypeface.FromFamilyName("Arial", SKFontStyle.Bold)
};

private SKPaint _shadowPaint = new SKPaint
{
    Color = SKColors.Black.WithAlpha(160),
    TextSize = 32,
    IsAntialias = true,
    Typeface = SKTypeface.FromFamilyName("Arial", SKFontStyle.Bold)
};

// Subscribe after constructing VideoCaptureCoreX / MediaPlayerCoreX
_videoCapture.OnVideoFrameBuffer += VideoCapture_OnVideoFrameBuffer;

private void VideoCapture_OnVideoFrameBuffer(object sender, VideoFrameXBufferEventArgs e)
{
    if (e.Frame == null || e.Frame.Data == IntPtr.Zero)
    {
        return;
    }

    // Wrap the raw BGRA buffer in a SkiaSharp surface (no extra allocation)
    var info = new SKImageInfo(e.Frame.Width, e.Frame.Height, SKColorType.Bgra8888, SKAlphaType.Premul);

    using (var pixmap = new SKPixmap(info, e.Frame.Data, e.Frame.Stride))
    using (var surface = SKSurface.Create(pixmap))
    {
        var canvas = surface.Canvas;

        // Dynamic content built per frame
        var timestamp = e.Frame.Timestamp.ToString(@"hh\:mm\:ss\.fff");
        var line = $"REC  {timestamp}";

        // Draw shadow first, then main text for legibility on any background
        canvas.DrawText(line, 18, 42, _shadowPaint);
        canvas.DrawText(line, 16, 40, _textPaint);
        canvas.Flush();
    }

    // Propagate the modified frame downstream
    e.UpdateData = true;
}
```

**Why BGRA matters.** The X engines request BGRA by default for frame callbacks because it maps 1:1 to SkiaSharp, System.Drawing, and most GPU-friendly interop paths. If you need a different format, request a format conversion block upstream rather than converting on every frame.

**Measuring and positioning text.** Use `_textPaint.MeasureText(line)` to compute width for right- or center-alignment. SkiaSharp also exposes `SKFontMetrics` via `_textPaint.FontMetrics` for baseline / ascent / descent to position text precisely against frame edges.

**Alternative imaging stacks.** You can also use `System.Drawing.Graphics` wrapping a `Bitmap` constructed over the raw buffer on Windows, or direct byte writes with `Marshal.Copy` / `Span<byte>` for full control. SkiaSharp is the recommended option on macOS / Linux / iOS / Android.

**Engine-level parity.** Everything in [Performance Considerations](#performance-considerations) and [Multiple Text Elements](#multiple-text-elements) applies equally to the X engines — the event fires on a processing thread, `UpdateData` propagates changes, and heavy work should be offloaded to avoid dropping frames.

## Required Components

To implement this solution, you'll need:

- SDK redist package installed in your application (NuGet on the X engines, installer on `VideoCaptureCore`).
- Reference to the appropriate SDK (Video Capture SDK, Video Edit SDK, or Media Player SDK — X or classic).
- For the X-engine sample: a transitive SkiaSharp reference (already pulled in by the SDK) or your own text-rendering library.

## Conclusion

The `OnVideoFrameBuffer` event gives direct access to every raw frame on both the classic `VideoCaptureCore` engine (RGB24/RGB32 via `VideoFrameBufferEventArgs` + `FastImageProcessing`) and the cross-platform X engines (`VideoCaptureCoreX` / `MediaPlayerCoreX`, BGRA via `VideoFrameXBufferEventArgs` + SkiaSharp). This is the right tool when you need pixel-level text rendering — custom fonts, per-frame dynamic content, anti-aliasing you control, or integration with third-party text/graphics libraries.

For static or clock-driven text overlays without writing a per-frame handler, the one-line [text overlay effect](../../video-effects/text-overlay/) is usually the better choice.

## Related documentation

- [Text overlay effect](../../video-effects/text-overlay/) — high-level, declarative text overlay without writing a callback.
- [Image drawing via OnVideoFrameBuffer](../image-onvideoframebuffer/) — same technique applied to images instead of text.
- [Drawing video in a PictureBox](../draw-video-picturebox/) — WinForms rendering pattern that often pairs with pixel-level frame work.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Uninstall DirectShow Filters in Windows Using regsvr32
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/uninstall-directshow-filter/
**Description:** Properly uninstall DirectShow filters with manual techniques, troubleshooting steps, and best practices for .NET multimedia applications.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, DirectShow, Windows, Playback

# Remove DirectShow Filters in Windows

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

DirectShow filters are essential components for multimedia applications in Windows environments. They enable software to process audio and video data efficiently. However, there may be situations where you need to uninstall these filters, such as when upgrading your application, resolving conflicts, or completely removing a software package. This guide provides detailed instructions on how to properly uninstall DirectShow filters from your system.

## Understanding DirectShow Filters

DirectShow is a multimedia framework and API designed by Microsoft for software developers to perform various operations with media files. It's built on the Component Object Model (COM) architecture and uses a modular approach where each processing step is handled by a separate component called a filter.

Filters are categorized into three main types:

- **Source filters**: Read data from files, capture devices, or network streams
- **Transform filters**: Process or modify the data (compression, decompression, effects)
- **Rendering filters**: Display video or play audio

When SDK components are installed, they register DirectShow filters in the Windows Registry, making them available to any application that uses the DirectShow framework.

## Why Uninstall DirectShow Filters?

There are several reasons why you might need to uninstall DirectShow filters:

1. **Version conflicts**: Newer versions of the SDK might require removing older filters
2. **System cleanup**: Removing unused components to maintain system efficiency
3. **Troubleshooting**: Resolving issues with multimedia applications
4. **Complete software removal**: Ensuring no components remain after uninstalling the main application
5. **Re-registration**: Sometimes uninstalling and reinstalling filters can resolve registration issues

## Methods for Uninstalling DirectShow Filters

### Method 1: Using the SDK Installer (Recommended)

The most straightforward way to uninstall DirectShow filters is through the SDK (or redist) installer itself. SDK packages include uninstallation routines that properly remove all components, including DirectShow filters.

### Method 2: Manual Unregistration with regsvr32

If automatic uninstallation isn't possible or you need to unregister specific filters, you can use the `regsvr32` command-line tool:

1. Open Command Prompt as Administrator (right-click on Command Prompt and select "Run as administrator")
2. Use the following command syntax to unregister a filter:

```
regsvr32 /u "C:\path\to\filter.dll"
```

1. Replace `C:\path\to\filter.dll` with the actual path to the DirectShow filter file
2. Press Enter to execute the command

For example, to unregister a filter located at `C:\Program Files\Common Files\FilterFolder\example_filter.dll`, you would use:

```
regsvr32 /u "C:\Program Files\Common Files\FilterFolder\example_filter.dll"
```

You should see a confirmation dialog indicating successful unregistration.

## Finding DirectShow Filter Locations

Before you can manually unregister filters, you need to know their locations. Here are several methods to find installed DirectShow filters:

### Using GraphStudio

[GraphStudio](https://github.com/cplussharp/graph-studio-next) is a powerful open-source tool for working with DirectShow filters. To find filter locations:

1. Download and install GraphStudio
2. Launch the application with administrator privileges
3. Go to "Graph > Insert Filters"
4. Browse through the list of installed filters
5. Right-click on a filter and select "Properties"
6. Note the "File:" path shown in the properties dialog

This method provides the exact file path needed for manual unregistration.

### Using System Registry

You can also find DirectShow filters through the Windows Registry:

1. Press `Win + R` to open the Run dialog
2. Type `regedit` and press Enter to open Registry Editor
3. Navigate to `HKEY_CLASSES_ROOT\CLSID`
4. Use the Search function (Ctrl+F) to find filter names
5. Look for the "InprocServer32" key under the filter's CLSID, which contains the file path

## Platform Considerations (x86 vs x64)

DirectShow filters are platform-specific, meaning 32-bit (x86) and 64-bit (x64) versions are separate components. If you've installed both versions, you need to unregister each one separately.

For x64 systems:

- 64-bit filters are typically installed in `C:\Windows\System32`
- 32-bit filters are typically installed in `C:\Windows\SysWOW64`

Use the appropriate version of `regsvr32` for each platform:

- For 64-bit filters: `C:\Windows\System32\regsvr32.exe`
- For 32-bit filters: `C:\Windows\SysWOW64\regsvr32.exe`

## Troubleshooting Filter Uninstallation

If you encounter issues during filter uninstallation, try these troubleshooting steps:

### Unable to Unregister Filter

If you receive an error like "DllUnregisterServer failed with error code 0x80004005":

1. Ensure you're running Command Prompt as Administrator
2. Verify that the path to the filter is correct
3. Check if the filter file exists and isn't in use by any application
4. Close any applications that might be using DirectShow filters
5. In some cases, a system restart may be necessary before unregistration

### Filter Still Present After Unregistration

If a filter appears to be still registered after attempting to unregister it:

1. Use GraphStudio to check if the filter is still listed
2. Look for multiple instances of the filter in different locations
3. Check both 32-bit and 64-bit registry locations
4. Try using the Microsoft-provided tool "OleView" to inspect COM registrations

## Verifying Successful Uninstallation

After uninstalling DirectShow filters, verify the removal was successful:

1. Use GraphStudio to check if the filters no longer appear in the available filters list
2. Check the registry for any remaining entries related to the filters
3. Test any applications that previously used the filters to ensure they handle the absence gracefully

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples and implementation examples for working with DirectShow and multimedia applications in .NET.

---END OF PAGE---


## Setting Custom Placeholder Images for VideoView .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/video-view-set-custom-image/
**Description:** Display custom placeholder images in VideoView controls when no video is playing for professional branding and enhanced user experience in .NET.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows, Playback, C#
**API:** VideoView, VideoPlayerForm

# Setting Custom Images for VideoView Controls in .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction

When developing media applications in .NET, it's often necessary to display a custom image within your VideoView control when no video content is playing. This capability is essential for creating professional-looking applications that maintain visual appeal during inactive states. Custom images can serve as placeholders, branding opportunities, or informational displays to enhance the user experience.

This guide explores the implementation of custom image functionality for VideoView controls across various .NET SDK applications.

## Understanding VideoView Custom Images

The VideoView control is a versatile component that displays video content in your application. However, when the control is not actively playing video, it typically shows a blank or default display. By implementing custom images, you can:

- Display your application or company logo
- Show preview thumbnails of available content
- Present instructional information to users
- Maintain visual consistency across your application
- Indicate the video's status (paused, stopped, loading, etc.)

It's important to note that the custom image is only visible when the control is not playing any video content. Once playback begins, the video stream automatically replaces the custom image.

## Implementation Process

The process of setting a custom image for a VideoView control involves three primary operations:

1. Creating a picture box with appropriate dimensions
2. Setting the desired image
3. Cleaning up resources when no longer needed

Let's explore each of these steps in detail.

## Step 1: Creating the Picture Box

The first step is to initialize a picture box within your VideoView control with the appropriate dimensions. This operation should be performed once during the setup phase:

```
VideoView1.PictureBoxCreate(VideoView1.Width, VideoView1.Height);
```

This method call creates an internal picture box component that will host your custom image. The parameters specify the width and height of the picture box, which should typically match the dimensions of your VideoView control to ensure proper display without stretching or distortion.

### Best Practices for Picture Box Creation

- **Timing Considerations**: Create the picture box during form initialization or after the control has been sized appropriately
- **Dynamic Sizing**: If your application supports resizing, consider recreating the picture box when the control size changes
- **Error Handling**: Implement try-catch blocks to handle potential exceptions during creation

## Step 2: Setting the Custom Image

After creating the picture box, you can set your custom image. Note that there appears to be a duplication in the original documentation - the correct code for setting the image should use the `PictureBoxSetImage` method:

`PictureBoxSetImage` takes a `System.Drawing.Bitmap`, so load the file as `Bitmap` (or cast) rather than `Image`:

```
// Load an image from a file as Bitmap
Bitmap customImage = new Bitmap("path/to/your/image.jpg");
VideoView1.PictureBoxSetImage(customImage);
```

Alternatively, you can use built-in resources or dynamically generated images:

```
// Using a Bitmap resource (the resource must be declared as Bitmap, not Image)
VideoView1.PictureBoxSetImage(Properties.Resources.MyCustomImage);

// Or creating a dynamic image
using (Bitmap dynamicImage = new Bitmap(VideoView1.Width, VideoView1.Height))
{
    using (Graphics g = Graphics.FromImage(dynamicImage))
    {
        // Draw on the image
        g.Clear(Color.DarkBlue);
        g.DrawString("Ready to Play", new Font("Arial", 24), Brushes.White, new PointF(50, 50));
    }

    VideoView1.PictureBoxSetImage((Bitmap)dynamicImage.Clone());
}
```

### Image Format Considerations

The image format you choose can impact performance and visual quality:

- **PNG**: Best for images with transparency
- **JPEG**: Suitable for photographic content
- **BMP**: Uncompressed format with higher memory usage
- **GIF**: Supports simple animations but with limited color depth

### Image Size Optimization

For optimal performance, consider these factors when preparing your custom images:

1. **Match Dimensions**: Resize your image to match the VideoView dimensions to avoid scaling operations
2. **Resolution Awareness**: Consider display DPI for crisp images on high-resolution displays
3. **Memory Consumption**: Large images consume more memory, which may impact application performance

## Step 3: Cleaning Up Resources

When the custom image is no longer required, it's important to clean up the resources to prevent memory leaks:

```
VideoView1.PictureBoxDestroy();
```

This method should be called when:

- The application is closing
- The control is being disposed
- You're switching to video playback mode and won't need the custom image anymore

### Resource Management Best Practices

Proper resource management is crucial for maintaining application stability:

- **Explicit Cleanup**: Always call `PictureBoxDestroy()` when you're done with the custom image
- **Disposal Timing**: Include the cleanup call in your form's `Dispose` or `Closing` events
- **State Tracking**: Keep track of whether a picture box has been created to avoid destroying a non-existent resource

## Advanced Scenarios

### Dynamic Image Updates

In some applications, you may need to update the custom image dynamically:

```
private void UpdateCustomImage(string imagePath)
{
    // Ensure picture box exists
    if (VideoView1.PictureBoxExists())
    {
        // Update image
        Bitmap newImage = new Bitmap(imagePath);
        VideoView1.PictureBoxSetImage(newImage);
    }
    else
    {
        // Create picture box first
        VideoView1.PictureBoxCreate(VideoView1.Width, VideoView1.Height);
        Bitmap newImage = new Bitmap(imagePath);
        VideoView1.PictureBoxSetImage(newImage);
    }
}
```

### Handling Control Resizing

If your application allows resizing of the VideoView control, you'll need to handle image scaling:

```
private void VideoView1_SizeChanged(object sender, EventArgs e)
{
    // Recreate picture box with new dimensions
    if (VideoView1.PictureBoxExists())
    {
        VideoView1.PictureBoxDestroy();
    }

    VideoView1.PictureBoxCreate(VideoView1.Width, VideoView1.Height);

    // Set image again with appropriate scaling
    SetScaledCustomImage();
}
```

### Multiple VideoView Controls

When working with multiple VideoView controls, ensure proper management for each:

```
private void InitializeAllVideoViews()
{
    // Initialize each VideoView with appropriate custom images
    VideoView1.PictureBoxCreate(VideoView1.Width, VideoView1.Height);
    VideoView1.PictureBoxSetImage(Properties.Resources.Camera1Placeholder);

    VideoView2.PictureBoxCreate(VideoView2.Width, VideoView2.Height);
    VideoView2.PictureBoxSetImage(Properties.Resources.Camera2Placeholder);

    // Additional VideoView controls...
}
```

## Troubleshooting Common Issues

### Image Not Displaying

If your custom image isn't appearing:

1. **Check Timing**: Ensure you're setting the image after the picture box is created
2. **Verify Video State**: Confirm the control isn't currently playing video
3. **Image Loading**: Verify the image path is correct and accessible
4. **Control Visibility**: Ensure the VideoView control is visible in the UI

### Memory Leaks

To prevent memory leaks:

1. **Dispose Images**: Always dispose Image objects after they're no longer needed
2. **Destroy Picture Box**: Call `PictureBoxDestroy()` when appropriate
3. **Resource Tracking**: Implement proper tracking of created resources

## Complete Implementation Example

Here's a complete implementation example that demonstrates the proper lifecycle management:

```
public partial class VideoPlayerForm : Form
{
    private bool isPictureBoxCreated = false;

    public VideoPlayerForm()
    {
        InitializeComponent();
        this.Load += VideoPlayerForm_Load;
        this.FormClosing += VideoPlayerForm_FormClosing;
    }

    private void VideoPlayerForm_Load(object sender, EventArgs e)
    {
        InitializeCustomImage();
    }

    private void InitializeCustomImage()
    {
        try
        {
            VideoView1.PictureBoxCreate(VideoView1.Width, VideoView1.Height);
            isPictureBoxCreated = true;

            // PictureBoxSetImage expects System.Drawing.Bitmap — declare the resource as Bitmap (or cast from Image).
            using (Bitmap customImage = (Bitmap)Properties.Resources.VideoPlaceholder)
            {
                VideoView1.PictureBoxSetImage(customImage);
            }
        }
        catch (Exception ex)
        {
            // Handle exceptions
            MessageBox.Show($"Error setting custom image: {ex.Message}");
        }
    }

    private void btnPlay_Click(object sender, EventArgs e)
    {
        // Play video logic here
        // The custom image will automatically be replaced during playback
    }

    private void VideoPlayerForm_FormClosing(object sender, FormClosingEventArgs e)
    {
        CleanupResources();
    }

    private void CleanupResources()
    {
        if (isPictureBoxCreated)
        {
            VideoView1.PictureBoxDestroy();
            isPictureBoxCreated = false;
        }
    }
}
```

## Conclusion

Implementing custom images for VideoView controls enhances the user experience and professional appearance of your .NET media applications. By following the steps outlined in this guide, you can effectively display branded or informative content when videos aren't playing.

Remember the key points:

1. Create the picture box with the appropriate dimensions
2. Set your custom image with proper resource management
3. Clean up resources when they're no longer needed
4. Handle resizing and other special scenarios as required

With these techniques, you can create more polished and user-friendly video applications in .NET.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples and implementation examples.

---END OF PAGE---


## Implementing Audio VU Meters & Waveform Visualizers
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/vu-meters/
**Description:** Build VU meters and waveform visualizers in WinForms and WPF for real-time audio level monitoring with mono and stereo channel support in .NET.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows, WinForms, WPF, C#
**API:** AudioLevelEventArgs, VUMeterMaxSampleEventArgs

# Audio Visualization: Implementing VU Meters and Waveform Displays in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

Audio visualization is a crucial component of modern media applications, providing users with visual feedback about audio levels and waveform patterns. This guide demonstrates how to implement VU (Volume Unit) meters and waveform visualizers in both WinForms and WPF applications.

## Understanding Audio Visualization Components

Before diving into implementation, it's important to understand the two main visualization tools we'll be working with:

### VU Meters

VU meters display the instantaneous audio level of a signal, typically showing how loud the audio is at any given moment. They provide real-time feedback about audio levels, helping users monitor signal strength and prevent distortion or clipping.

### Waveform Painters

Waveform visualizers display the audio signal as a continuous line that represents amplitude changes over time. They provide a more detailed representation of the audio content, showing patterns and characteristics that might not be apparent from listening alone.

## Implementation in WinForms Applications

WinForms provides a straightforward way to implement audio visualization components with minimal code. Let's explore the implementation of both VU meters and waveform painters.

### WinForms VU Meter Implementation

Implementing a VU meter in WinForms requires just a few steps:

1. **Add the VU Meter Control**: First, add the VU meter control to your form. For stereo audio, you'll typically add two controls—one for each channel.

```
// Add this to your form design
VisioForge.Core.UI.WinForms.VolumeMeterPro.VolumeMeter volumeMeter1;
VisioForge.Core.UI.WinForms.VolumeMeterPro.VolumeMeter volumeMeter2; // For stereo
```

1. **Enable VU Meter in Your Media Control**: Before starting playback or capture, enable the VU meter functionality in your media control.

```
// Enable VU meter before starting playback/capture
mediaPlayer.Audio_VUMeter_Pro_Enabled = true;
```

1. **Implement the Event Handler**: Add an event handler to process the audio level data and update the VU meter display.

```
private void VideoCapture1_OnAudioVUMeterProVolume(object sender, AudioLevelEventArgs e)
{
    volumeMeter1.Amplitude = e.ChannelLevelsDb[0];
    if (e.ChannelLevelsDb.Length > 1)
    {
        volumeMeter2.Amplitude = e.ChannelLevelsDb[1];
    }
}
```

With these steps, your VU meter will dynamically update based on the audio levels of your media playback or capture.

### WinForms Waveform Painter Implementation

The waveform painter implementation follows a similar pattern:

1. **Add the Waveform Painter Control**: Add the waveform painter control to your form. For stereo audio, add two controls.

```
// Add this to your form design
VisioForge.Core.UI.WinForms.VolumeMeterPro.WaveformPainter waveformPainter1;
VisioForge.Core.UI.WinForms.VolumeMeterPro.WaveformPainter waveformPainter2; // For stereo
```

1. **Enable VU Meter Processing**: Enable the VU meter functionality to provide data for the waveform painter.

```
// Enable VU meter before starting playback/capture
mediaPlayer.Audio_VUMeter_Pro_Enabled = true;
```

1. **Implement the Event Handler**: Add an event handler to process the audio data and update the waveform display.

```
private void VideoCapture1_OnAudioVUMeterProVolume(object sender, AudioLevelEventArgs e)
{
    waveformPainter1.AddMax(e.ChannelLevelsDb[0]);
    if (e.ChannelLevelsDb.Length > 1)
    {
        waveformPainter2.AddMax(e.ChannelLevelsDb[1]);
    }
}
```

## Implementation in WPF Applications

WPF requires a slightly different approach due to its threading model and UI framework. Let's look at how to implement both visualization types in WPF.

### WPF VU Meter Implementation

1. **Add the VU Meter Control**: Add the VU meter control to your XAML layout. For stereo audio, add two controls.

```
<VisioForge.Core.UI.WPF.VolumeMeterPro.VolumeMeter x:Name="volumeMeter1" />
<VisioForge.Core.UI.WPF.VolumeMeterPro.VolumeMeter x:Name="volumeMeter2" /> <!-- For stereo -->
```

1. **Enable VU Meter Processing and Start the Meters**:

```
VideoCapture1.Audio_VUMeter_Pro_Enabled = true;

volumeMeter1.Start();
volumeMeter2.Start();
```

1. **Implement the Event Handler with Dispatcher**: In WPF, you need to use the Dispatcher to update UI elements from non-UI threads.

```
private delegate void AudioVUMeterProVolumeDelegate(AudioLevelEventArgs e);

private void AudioVUMeterProVolumeDelegateMethod(AudioLevelEventArgs e)
{
    volumeMeter1.Amplitude = e.ChannelLevelsDb[0];
    volumeMeter1.Update();

    if (e.ChannelLevelsDb.Length > 1)
    {
        volumeMeter2.Amplitude = e.ChannelLevelsDb[1];
        volumeMeter2.Update();
    }
}

private void VideoCapture1_OnAudioVUMeterProVolume(object sender, AudioLevelEventArgs e)
{
    Dispatcher.BeginInvoke(new AudioVUMeterProVolumeDelegate(AudioVUMeterProVolumeDelegateMethod), e);
}
```

1. **Clean Up After Playback**: When playback stops, clean up the VU meters to release resources.

```
volumeMeter1.Stop();
volumeMeter1.Clear();

volumeMeter2.Stop();
volumeMeter2.Clear();
```

### WPF Waveform Painter Implementation

1. **Add the Waveform Painter Control**: Add the waveform painter control to your XAML layout.

```
<VisioForge.Core.UI.WPF.VolumeMeterPro.WaveformPainter x:Name="waveformPainter" />
```

1. **Enable VU Meter Processing and Start the Waveform Painter**:

```
VideoCapture1.Audio_VUMeter_Pro_Enabled = true;
waveformPainter.Start();
```

1. **Implement the Maximum Calculated Event Handler**: For waveform painters in WPF, we use a different event.

```
private delegate void AudioVUMeterProMaximumCalculatedDelegate(VUMeterMaxSampleEventArgs e);

private void AudioVUMeterProMaximumCalculatedelegateMethod(VUMeterMaxSampleEventArgs e)
{
    waveformPainter.AddValue(e.MaxSample, e.MinSample);
}

private void VideoCapture1_OnAudioVUMeterProMaximumCalculated(object sender, VUMeterMaxSampleEventArgs e)
{
    Dispatcher.BeginInvoke(new AudioVUMeterProMaximumCalculatedDelegate(AudioVUMeterProMaximumCalculatedelegateMethod), e);
}
```

1. **Clean Up After Playback**: When playback stops, clean up the waveform painter.

```
waveformPainter.Stop();
waveformPainter.Clear();
```

## Advanced Customization Options

Both the VU meter and waveform painter controls offer extensive customization options to match your application's design and user experience requirements.

### Customizing VU Meters

The `VolumeMeter` control exposes the following real properties:

- **`MinDb` / `MaxDb`**: decibel range displayed by the meter
- **`Boost`**: gain multiplier applied before rendering
- **`Orientation`**: horizontal or vertical bar direction
- **`ForeColor`**: bar color (inherited from `Control`)
- **`MinimalUpdateInterval`** (WPF only): throttles redraws

Example of customizing a VU meter:

```
volumeMeter1.MinDb = -60;
volumeMeter1.MaxDb = 6;
volumeMeter1.Boost = 1.0f;
volumeMeter1.ForeColor = System.Drawing.Color.Green;  // WinForms
volumeMeter1.Orientation = System.Windows.Forms.Orientation.Vertical;
```

### Customizing Waveform Painters

The `WaveformPainter` control has a small real surface:

- **`Boost`** (WinForms): pre-render gain multiplier
- **`ForeColor` / `BackColor`**: line and background colors (inherited from `Control`)
- **`Clear()`**: resets the painted history
- **`AddMax(float)`** (WinForms) / **`AddValue(float, float)`** (WPF): append a new sample

Example of customizing a waveform painter:

```
waveformPainter.ForeColor = System.Drawing.Color.SkyBlue;
waveformPainter.BackColor = System.Drawing.Color.Black;
waveformPainter.Boost = 1.5f;
```

## Performance Considerations

When implementing audio visualization, consider these performance tips:

1. **Update Frequency**: Balance visual responsiveness with CPU usage by adjusting how frequently you update the visuals
2. **UI Thread Management**: Always update UI elements on the appropriate thread (especially important in WPF)
3. **Resource Cleanup**: Properly stop and clear visualization controls when not in use
4. **Buffering**: Consider implementing buffering for smoother visualization during high CPU usage

## Conclusion

Implementing VU meters and waveform painters adds valuable visual feedback to media applications. Whether you're developing in WinForms or WPF, these audio visualization components help users monitor and understand audio levels and patterns more intuitively.

By following the implementation steps outlined in this guide, you can enhance your .NET media applications with professional-quality audio visualization features that improve the overall user experience.

---

For more code examples and related SDKs, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Overlay WPF Controls on Video in C# .NET Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/wpf-controls-over-video/
**Description:** Place WPF buttons, text and panels on top of VideoView. D3D11 composable renderer, WriteableBitmap mode, airspace issues, and the WPF_WinUI_Callback migration.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, Media Blocks SDK, .NET, WPF, MediaPlayerCoreX, VideoCaptureCoreX, MediaPlayerCore, VideoCaptureCore, Windows, Playback, Capture, C#
**API:** VideoView, VideoRendererMode, IVideoSurfaceProvider, MediaPlayerCoreX, VideoCaptureCore

# Overlaying WPF Controls on Video

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

## Introduction

Placing WPF elements — buttons, overlays, status banners, transport controls — on top of the video preview only works when the video is drawn *inside* the WPF visual tree. If the frames go to a native child window (HWND), WPF cannot paint anything over them: that is the classic WPF **airspace** limitation, and no amount of `Panel.ZIndex` fixes it.

The WPF `VisioForge.Core.UI.WPF.VideoView` control supports three ways to draw a frame. Two of them compose with WPF, one does not:

| Render mode | How to enable | WPF controls on top | Notes |
| --- | --- | --- | --- |
| `D3D11Composable` | `VideoView1.UseD3D11ComposableRenderer()` | Yes | Frames stay on the GPU, presented to WPF as a `D3DImage`. Recommended. |
| Software (`WriteableBitmap`) | X engines: `VideoView1.SetNativeRendering(false)`; classic engines: `VideoRendererMode.FrameCallback` on the engine | Yes | CPU upload per frame. The classic `WPF_WinUI_Callback` mode. |
| Native HWND | default (`VideoView1.SetNativeRendering(true)`) | No | Fastest path, but airspace blocks every overlay. |

Coming from `VideoRendererMode.WPF_WinUI_Callback`?

In the classic engines the mode was set on the engine: `VideoCapture1.Video_Renderer.VideoRenderer`. The cross-platform X engines (`VideoCaptureCoreX`, `MediaPlayerCoreX`, `VideoEditCoreX`) have no `Video_Renderer` object — the render mode moved onto the `VideoView` control itself, so a single view works with any engine. See [Migrating from WPF\_WinUI\_Callback](#migrating-from-wpf_winui_callback) below.

## D3D11 composable renderer (recommended)

`D3D11Composable` uploads each frame into a shared Direct3D 11 texture, opens it on a hidden Direct3D 9Ex device and exposes it to WPF as a `D3DImage`. The video becomes an ordinary element of the visual tree: render transforms, opacity, z-order and rounded clipping all apply to it, and there is no HWND to fight with.

**Requirements:** Windows Vista or later (Direct3D 9Ex) and a Direct3D 10/11-class GPU.

### Enabling it with the X engines

Call `UseD3D11ComposableRenderer()` before you start playback or capture — the call is idempotent, so it is safe to repeat it after an engine restart:

```
// Before creating / starting the engine.
VideoView1.UseD3D11ComposableRenderer();

_player = new MediaPlayerCoreX(VideoView1);

var source = await UniversalSourceSettingsV2.CreateAsync(new Uri(filename));
await _player.OpenAsync(source);
await _player.PlayAsync();
```

The same call works for `VideoCaptureCoreX` and `VideoEditCoreX`, and for a `VideoRendererBlock` built on the same view in Media Blocks SDK .NET.

### Enabling it with the classic engines

`VideoCaptureCore`, `MediaPlayerCore` and `VideoEditCore` use exactly the same call on the view:

```
VideoView1.UseD3D11ComposableRenderer();
```

The engine is switched to the frame-callback channel behind the scenes and its frames are uploaded into the shared texture. Prefer this call over selecting `VideoRendererMode.D3D11Composable` on the engine's `Video_Renderer` settings: the view starts in native rendering mode, and while it stays there it overrides the engine's choice with a native HWND. `UseD3D11ComposableRenderer()` takes care of that for you.

### XAML layout

Put the view and the overlay into the same `Grid` cell. Later children are drawn on top:

```
<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:WPF="clr-namespace:VisioForge.Core.UI.WPF;assembly=VisioForge.Core"
    x:Class="MyPlayer.MainWindow">
    <Grid>
        <WPF:VideoView x:Name="VideoView1" />

        <Border Background="#88000000" CornerRadius="8"
                VerticalAlignment="Top" HorizontalAlignment="Left"
                Margin="8" Padding="10,6">
            <TextBlock Text="LIVE" Foreground="White" FontWeight="SemiBold" />
        </Border>

        <StackPanel Orientation="Horizontal" VerticalAlignment="Bottom"
                    HorizontalAlignment="Center" Margin="0,0,0,16">
            <Button Content="Play" Width="80" Click="btPlay_Click" />
            <Button Content="Pause" Width="80" Margin="8,0,0,0" Click="btPause_Click" />
        </StackPanel>
    </Grid>
</Window>
```

Because the video is a normal WPF element in this mode, the view itself can be transformed as well:

```
VideoView1.RenderTransformOrigin = new Point(0.5, 0.5);
VideoView1.RenderTransform = new RotateTransform(10);
VideoView1.Opacity = 0.7;
```

### Custom GPU processing on top of the frame

In `D3D11Composable` mode the view exposes the shared texture, so you can run your own shaders on each frame without a round trip through CPU memory:

```
var provider = VideoView1.GetSurfaceProvider();
if (provider != null)
{
    provider.FrameReady += (sender, e) =>
    {
        // e.SharedHandle — DXGI shared handle, open it on your own ID3D11Device
        // via OpenSharedResource; e.Width / e.Height — texture size.
    };
}
```

`FrameReady` is raised synchronously on the thread that pushed the frame — a DirectShow callback or a GStreamer streaming thread, not the WPF dispatcher, and not necessarily the same thread on every frame. Marshal to the dispatcher before touching any WPF control, and keep thread-affine resources out of the handler.

`GetSurfaceProvider()` returns `null` in every other render mode — a quick way to confirm the composable panel is really active.

## Software rendering mode

If you cannot use Direct3D — a virtual machine without GPU acceleration, a remote desktop session, or a very old target — switch to the software path. Frames are drawn into a `WriteableBitmap` hosted by a WPF `Image` inside the view, which composes with WPF just as well, at the cost of a per-frame CPU upload.

With the X engines, turn native rendering off on the view before the engine starts:

```
VideoView1.SetNativeRendering(false);
```

On the classic engines the mode belongs to the engine. Set it before `PlayAsync()` / `StartAsync()` and the view follows it out of native mode on its own:

```
MediaPlayer1.Video_Renderer.VideoRenderer = VideoRendererMode.FrameCallback;
```

On builds released before 2026.8.18 the view stayed in native mode and replaced that setting with a native HWND renderer, so add `VideoView1.SetNativeRendering(false)` before the line above if you target one of them. The extra call remains harmless on current builds.

The XAML above is unchanged in both cases. Software rendering and the composable panel are mutually exclusive: once the panel is installed, `SetNativeRendering(true)` is ignored and logged as a warning.

## Why native HWND rendering blocks overlays

The native path hands the frames to a Win32 child window hosted inside the WPF layout. It is the fastest option and the view's default, but the child window is composed by the desktop window manager *after* WPF has drawn its own content, so any WPF element positioned above the video is simply invisible. The same limitation applies to the classic `VideoRendererMode.WPF_NativeHWND` mode.

If you need both maximum throughput and an overlay, prefer `D3D11Composable` — it keeps the frame GPU-resident and still composes with WPF.

## Migrating from WPF\_WinUI\_Callback

Nothing was removed from the classic engines: `VideoRendererMode.WPF_WinUI_Callback` still exists, and `VideoRendererMode.FrameCallback` is an alias for the same value with a more self-descriptive name. It is set on the engine, as shown under [Software rendering mode](#software-rendering-mode).

What changed is where the setting lives when you move to an X engine:

| Classic engine | X engine equivalent |
| --- | --- |
| `Video_Renderer.VideoRenderer = VideoRendererMode.WPF_WinUI_Callback` | `VideoView1.SetNativeRendering(false)` |
| `Video_Renderer.VideoRenderer = VideoRendererMode.D3D11Composable` | `VideoView1.UseD3D11ComposableRenderer()` (both families) |
| `Video_Renderer.VideoRenderer = VideoRendererMode.WPF_NativeHWND` | default behaviour, or `VideoView1.SetNativeRendering(true)` |

For per-frame access to pixel data — computer vision, AI inference, custom drawing — see [Custom Video Effects Using Frame Events](../custom-video-effects/) and [Image drawing via OnVideoFrameBuffer](../image-onvideoframebuffer/).

## Troubleshooting

**A separate video window opens instead of rendering inside the layout.** The view is running the HWND path while your code expects the composable panel. Call `UseD3D11ComposableRenderer()` *before* attaching the engine, and check `GetSurfaceProvider()` for a non-`null` result after playback starts.

**The overlay is invisible, the video plays.** The view is in native rendering mode. Call `UseD3D11ComposableRenderer()`, or — for the software path — `SetNativeRendering(false)` on an X engine, or `Video_Renderer.VideoRenderer = VideoRendererMode.FrameCallback` on a classic one. All of them must run before playback starts, so restart the preview for the change to take effect.

**Preview stays black in a remote desktop / VM session.** Direct3D acceleration may be unavailable there — fall back to the software path described above.

## Demos

- **[Simple Player Demo D3D11 (X engine)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK%20X/WPF/Simple%20Player%20Demo%20D3D11)** — `MediaPlayerCoreX` with a WPF banner over the video, plus view rotation and opacity.
- **[Simple Player Demo D3D11 (classic engine)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK/WPF/CSharp/Simple%20Player%20Demo%20D3D11)** — the same renderer driven by the DirectShow-based `MediaPlayerCore`.

## Related pages

- [Video Renderer Selection (WinForms)](../select-video-renderer-winforms/) — all renderer modes of the classic engines.
- [WPF Multi-screen Video Output](../multiple-screens-wpf/) — several independent preview surfaces in one application.
- [Custom Image Video View](../video-view-set-custom-image/) — replacing the preview with a static image.

---END OF PAGE---


## Zoom Effects in C# .NET Video Apps with Pan Control
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/zoom-onvideoframebuffer/
**Description:** Apply zoom and pan effects in C# / .NET with VideoEffectZoom and VideoEffectPan — runtime-adjustable focal point for capture, playback, and editing.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows, C#
**API:** VideoEffectZoom, VideoEffectPan

# Implementing Zoom Effects in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction

Zoom and pan are a built-in video effect in the VisioForge classic (Windows / DirectShow) engines — `VideoCaptureCore`, `MediaPlayerCore`, and `VideoEditCore`. The `VideoEffectZoom` and `VideoEffectPan` classes handle scaling, centering, and runtime adjustments without touching the frame buffer directly. This is the recommended path when you want zoom.

You only need to drop down to `OnVideoFrameBuffer` when `VideoEffectZoom` cannot express what you need — for example, a custom non-affine warp or integration with an external image library.

## Applying VideoEffectZoom (recommended)

`VideoEffectZoom` gets added to the pipeline once and can be tweaked while video is playing. It scales every frame automatically — no per-frame C# code.

```
using VisioForge.Core.Types.VideoEffects;

var zoomEffect = new VideoEffectZoom(
    zoomX: 2.0,    // 2.0 = 200% horizontal zoom (1.0 = no zoom)
    zoomY: 2.0,    // 2.0 = 200% vertical zoom — keep equal to zoomX for uniform scaling
    shiftX: 0,     // Pixel offset from centre; positive shifts right
    shiftY: 0,     // Pixel offset from centre; positive shifts down
    enabled: true,
    name: "Zoom");

// VideoCapture1 is a VideoCaptureCore instance (same API on MediaPlayerCore / VideoEditCore).
VideoCapture1.Video_Effects_Enabled = true;
VideoCapture1.Video_Effects_Add(zoomEffect);
```

### Adjust zoom at runtime

Keep a reference to the effect and modify its properties while the pipeline is running — the SDK picks up the new values on the next frame:

```
zoomEffect.ZoomX = 3.0;
zoomEffect.ZoomY = 3.0;
zoomEffect.ShiftX = 200;   // Pan focus 200 px to the right of centre
zoomEffect.ShiftY = -100;  // And 100 px up
```

Toggling without removing:

```
zoomEffect.Enabled = false;   // Bypass on the fly
zoomEffect.Enabled = true;    // Re-enable later
```

### Interpolation quality

`InterpolationMode` defaults to `VideoInterpolationMode.Bilinear`. For sharper results at higher zoom factors set it to a higher-quality mode; for lowest CPU set `NearestNeighbor`.

```
zoomEffect.InterpolationMode = VideoInterpolationMode.Bicubic;
```

## Pairing with VideoEffectPan

If you want smooth pan animation across a source that is larger than the output (for example, "Ken Burns" slow zoom over a still image), combine `VideoEffectZoom` with `VideoEffectPan` from the same namespace. Drive both from a timer or animation curve.

## Dropping down to OnVideoFrameBuffer

Implement a custom zoom by hand only when `VideoEffectZoom` can't do what you need — for example, a non-affine warp, per-pixel magnification around the cursor, or integration with a third-party imaging library. You get the raw frame bytes, transform them in place (or into `e.Frame.Data`), and set `e.UpdateData = true` so the modified pixels flow downstream.

```
using System.Runtime.InteropServices;

private void SDK_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    // e.Frame.Data     — IntPtr to the pixel buffer
    // e.Frame.DataSize — buffer size in bytes
    // e.Frame.Info.Width / Info.Height / Info.Stride — frame dimensions (RAWBaseVideoInfo)
    // e.Frame.Timestamp — per-frame TimeSpan

    // 1. Read/copy bytes into your own scratch buffer:
    byte[] scratch = new byte[e.Frame.DataSize];
    Marshal.Copy(e.Frame.Data, scratch, 0, e.Frame.DataSize);

    // 2. Apply whatever custom transform you need on the bytes of `scratch`
    //    (resample, warp, composite, etc.). Keep the output size == input size
    //    because the SDK will not negotiate a new resolution mid-pipeline.

    // 3. Write the result back into the original buffer:
    Marshal.Copy(scratch, 0, e.Frame.Data, e.Frame.DataSize);

    // 4. Tell the pipeline we mutated the pixels.
    e.UpdateData = true;
}
```

### X-engine note

On the cross-platform X engines (`VideoCaptureCoreX`, `MediaPlayerCoreX`) the buffer arrives in `VideoFrameXBufferEventArgs`. Flat dimensions live directly on `e.Frame.Width` / `Height` / `Stride`, and frames are typically BGRA. For heavy pixel math, wrap the buffer in `SKPixmap` (SkiaSharp is already a transitive dependency of the X engines).

## Performance Considerations

- Prefer `VideoEffectZoom` over the frame-buffer path — the native scaler is faster and thread-safe.
- Reuse scratch buffers instead of allocating per frame.
- Keep the output resolution equal to the input resolution from the handler — the pipeline does not renegotiate caps mid-stream.
- Offload heavy CV / AI work to a worker thread; return quickly from the event handler to avoid back-pressure.

## Conclusion

For virtually every application, `VideoEffectZoom` (optionally paired with `VideoEffectPan`) is the right tool — it's one line of setup, runtime-adjustable, and implemented in native code. `OnVideoFrameBuffer` remains available for the cases where you genuinely need to own the bytes.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Setting Zoom Parameters for Multiple Video Renderers
**URL:** https://www.visioforge.com/help/docs/dotnet/general/code-samples/zoom-video-multiple-renderer/
**Description:** Configure independent zoom and position parameters for multiple video renderers across multi-screen displays in .NET multimedia applications.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, Windows, C#
**API:** VideoRendererType

# Configuring Zoom Settings for Multiple Video Renderers in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

When developing multimedia applications that utilize multiple video renderers, controlling the zoom and position parameters independently for each display is essential for creating professional-quality user interfaces. This guide covers the implementation details, parameter configurations, and best practices for setting up multiple video renderers with customized zoom settings in your .NET applications.

## Understanding Multiple Renderer Configurations

Multiple renderer support (also known as multiscreen functionality) allows your application to display video content across different display areas simultaneously. Each renderer can be configured with its own:

- Zoom ratio (magnification level)
- Horizontal shift (X-axis positioning)
- Vertical shift (Y-axis positioning)

This capability is particularly valuable for applications such as:

- Video surveillance systems displaying multiple camera feeds
- Media production software with preview and output windows
- Medical imaging applications requiring different zoom levels for analysis
- Multi-display kiosk systems with synchronized content

## Implementing the MultiScreen\_SetZoom Method

The SDK provides the `MultiScreen_SetZoom` method which takes four key parameters:

1. **Screen Index** (zero-based): Identifies which renderer to configure
2. **Zoom Ratio**: Controls the magnification percentage
3. **Shift X**: Adjusts the horizontal positioning (pixels or percentage)
4. **Shift Y**: Adjusts the vertical positioning (pixels or percentage)

### Method Signature and Parameters

```
// Method signature
void MultiScreen_SetZoom(int screenIndex, int zoomRatio, int shiftX, int shiftY);
```

| Parameter | Description | Valid Range |
| --- | --- | --- |
| screenIndex | Zero-based index of the target renderer | 0 to (number of renderers - 1) |
| zoomRatio | Magnification percentage | 1 to 1000 (%) |
| shiftX | Horizontal offset | -1000 to 1000 |
| shiftY | Vertical offset | -1000 to 1000 |

## Code Sample: Configuring Multiple Renderers

The following example demonstrates how to set different zoom and positioning values for three separate renderers:

```
// Configure the primary renderer (index 0)
// 50% zoom with no horizontal or vertical shift
VideoCapture1.MultiScreen_SetZoom(0, 50, 0, 0);

// Configure the secondary renderer (index 1)
// 20% zoom with slight horizontal and vertical shift
VideoCapture1.MultiScreen_SetZoom(1, 20, 10, 20);

// Configure the tertiary renderer (index 2)
// 30% zoom with no horizontal shift but significant vertical shift
VideoCapture1.MultiScreen_SetZoom(2, 30, 0, 30);
```

## Best Practices for Multiple Renderer Management

When implementing multiple renderer configurations, consider these best practices:

### 1. Initialize All Renderers Before Setting Zoom

Always ensure that all renderers are properly initialized before applying zoom settings:

```
// Initialize multiple renderers
VideoCapture1.MultiScreen_Enabled = true;

// Add 3 renderers
VideoCapture1.MultiScreen_AddScreen(videoView1, 1280, 720);
VideoCapture1.MultiScreen_AddScreen(videoView2, 1920, 1080);
VideoCapture1.MultiScreen_AddScreen(videoView3, 1280, 720);

// Now safe to configure zoom settings
VideoCapture1.MultiScreen_SetZoom(0, 50, 0, 0);
VideoCapture1.MultiScreen_SetZoom(1, 20, 10, 20);
VideoCapture1.MultiScreen_SetZoom(2, 30, 0, 30);

// Additional configurations...
```

### 2. Handle Resolution Changes Appropriately

If the source format changes mid-session, read the current resolution from the `OnVideoFrameBuffer` callback (`e.Frame.Info.Width` / `e.Frame.Info.Height`) and re-apply zoom. Track the screen count yourself — `VideoCaptureCore` doesn't expose a `MultiScreen_Count` property; you know how many screens you added because you called `MultiScreen_AddScreen` yourself.

```
private int _multiScreenCount = 0; // incremented after each MultiScreen_AddScreen call

private void VideoCapture1_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    int newZoom = CalculateOptimalZoom(e.Frame.Info.Width, e.Frame.Info.Height);

    // Apply to all renderers you registered
    for (int i = 0; i < _multiScreenCount; i++)
    {
        VideoCapture1.MultiScreen_SetZoom(i, newZoom, 0, 0);
    }
}
```

### 3. Provide User Controls for Zoom Adjustment

For interactive applications, consider implementing UI controls that allow users to adjust zoom settings:

```
private void zoomTrackBar_ValueChanged(object sender, EventArgs e)
{
    int selectedRenderer = rendererComboBox.SelectedIndex;
    int zoomValue = zoomTrackBar.Value;
    int shiftX = horizontalShiftTrackBar.Value;
    int shiftY = verticalShiftTrackBar.Value;

    // Apply new zoom settings to selected renderer
    VideoCapture1.MultiScreen_SetZoom(selectedRenderer, zoomValue, shiftX, shiftY);
}
```

## Advanced Zoom Configurations

### Dynamic Zoom Transitions

For smooth zoom transitions, consider implementing gradual zoom changes:

```
async Task AnimateZoomAsync(int screenIndex, int startZoom, int targetZoom, int duration)
{
    int steps = 30; // Number of animation steps
    int delay = duration / steps; // Milliseconds between steps

    for (int i = 0; i <= steps; i++)
    {
        // Calculate intermediate zoom value
        int currentZoom = startZoom + ((targetZoom - startZoom) * i / steps);

        // Apply current zoom value
        VideoCapture1.MultiScreen_SetZoom(screenIndex, currentZoom, 0, 0);

        // Wait for next step
        await Task.Delay(delay);
    }
}

// Usage
await AnimateZoomAsync(0, 50, 100, 1000); // Animate from 50% to 100% over 1 second
```

## Optimizing Performance with Multiple Renderers

When working with multiple renderers, be mindful of performance implications:

1. **Limit Frequent Updates**: Avoid rapidly changing zoom settings as it can impact performance
2. **Consider Hardware Acceleration**: Enable hardware acceleration when available
3. **Monitor Memory Usage**: Multiple high-resolution renderers can consume significant memory

```
// Use EVR renderer for hardware-accelerated composition on Windows. Renderer settings
// live inside Video_Renderer (a VideoRendererSettings bag), not on the core directly.
VideoCapture1.Video_Renderer.VideoRenderer = VideoRendererMode.EVR;
VideoCapture1.Video_Renderer.Deinterlace_EVR_Mode = VideoRendererEVRDeinterlaceMode.Auto;
```

## Troubleshooting Common Issues

### Issue: Renderers Show Black Screen After Zoom Changes

This can occur when zoom values exceed valid ranges or when renderers aren't properly initialized:

```
// Reset zoom settings to default for all renderers you registered
public void ResetZoomSettings()
{
    for (int i = 0; i < _multiScreenCount; i++)
    {
        VideoCapture1.MultiScreen_SetZoom(i, 100, 0, 0); // 100% zoom, no shift
    }
}
```

### Issue: Distorted Image After Zoom

Extreme zoom values can cause distortion. Implement boundaries for zoom values:

```
public void SetSafeZoom(int screenIndex, int requestedZoom, int shiftX, int shiftY)
{
    // Clamp values to safe ranges
    int safeZoom = Math.Clamp(requestedZoom, 10, 200); // 10% to 200%
    int safeShiftX = Math.Clamp(shiftX, -100, 100);
    int safeShiftY = Math.Clamp(shiftY, -100, 100);

    VideoCapture1.MultiScreen_SetZoom(screenIndex, safeZoom, safeShiftX, safeShiftY);
}
```

## Conclusion

Properly configured multiple video renderers with independent zoom settings can significantly enhance the user experience in multimedia applications. By following the guidelines and best practices outlined in this document, you can implement sophisticated video display configurations tailored to your specific application requirements.

For additional code examples and implementation guidance, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Record Another App's Audio on Android in C# and .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/guides/android-audio-playback-capture/
**Description:** Capture audio played by other Android apps in C# using AudioPlaybackCapture and MediaProjection with VideoCaptureCoreX and MediaBlocksPipeline.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, VideoCaptureCoreX, MediaBlocksPipeline, Android, MediaProjection, AudioPlaybackCapture, Capture, Recording, Audio, AAC, M4A, C#, NuGet
**API:** VideoCaptureCoreX, MediaBlocksPipeline, AndroidAudioPlaybackCaptureSourceSettings, AndroidAudioPlaybackCaptureSourceBlock, M4AOutput

# Record Another App's Audio on Android in C# and .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction

This guide shows how to record the audio played by **another application** on Android in C# and .NET. The capture uses Android's `AudioPlaybackCapture` API together with a `MediaProjection` consent token (Android 10 / API 29 and newer) and writes the result to an AAC `.m4a` file. VisioForge exposes the feature through two engines, so you can pick the one that fits your app: the high-level `VideoCaptureCoreX` (declarative recording) and the low-level `MediaBlocksPipeline` (full graph control).

For installation and package setup, see the [installation guide](../../../install/). The Android sample projects that this guide is based on ship with the SDK under `Video Capture SDK X/Android/Audio Playback Capture` and `Media Blocks SDK/Android/Audio Playback Capture`.

## How does audio playback capture work on Android?

Android routes the audio of other apps through a special `REMOTE_SUBMIX` source that you can only open after the user grants a screen/audio capture consent dialog. Your app requests that consent, receives a `MediaProjection` token, and hands the token to the VisioForge source. The source opens the playback-capture `AudioRecord`, the SDK encodes the stream to AAC, and a muxer writes the `.m4a` file.

```
graph LR;
    app["Other app audio"] --> submix["REMOTE_SUBMIX (AudioPlaybackCapture)"];
    submix --> src["AndroidAudioPlaybackCaptureSourceSettings / Block"];
    src --> enc["AAC encoder"];
    enc --> sink["M4A / MP4 file"];
```

**Capture is restricted by design.** Only apps that publish audio with `usage` of `Media`, `Game`, or `Unknown` are capturable, and only when the app has **not** opted out via `android:allowAudioPlaybackCapture="false"`. Protected players (Spotify, Netflix, and most DRM-backed apps) opt out, so they produce silence. Test with locally played video or music files, or with your own app.

## Prerequisites and permissions

- **Android 10 (API level 29) or newer.** Set `<SupportedOSPlatformVersion>29.0</SupportedOSPlatformVersion>` in the `.csproj`.
- **Permissions and a foreground service** declared in `AndroidManifest.xml`. The service must use the `mediaProjection` foreground type, and on Android 14+ it must be started **after** the consent is granted.

```
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.visioforge.audioplaybackcapture">
    <application android:label="@string/app_name">
        <service android:name=".AudioCaptureService"
                 android:foregroundServiceType="mediaProjection"
                 android:exported="false" />
    </application>
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
    <uses-permission android:name="android.permission.INTERNET" />
</manifest>
```

`RECORD_AUDIO` is a runtime permission — request it before starting capture. `INTERNET` is only needed if you stream the result; a pure file recorder can drop it.

## Requesting the MediaProjection token

The token flow is identical for both engines. The order matters on Android 14+: request consent, then start the foreground service, then call `GetMediaProjection` once the service is in the foreground.

First, kick off the system consent dialog when the user taps Start:

```
// _projectionManager = (MediaProjectionManager)GetSystemService(MediaProjectionService);
StartActivityForResult(_projectionManager.CreateScreenCaptureIntent(), REQUEST_MEDIA_PROJECTION);
```

The foreground service exposes a `TaskCompletionSource` that is completed from `OnStartCommand`, so the activity can wait until the service is actually in the foreground state:

```
[Service(ForegroundServiceType = ForegroundService.TypeMediaProjection, Exported = false)]
public class AudioCaptureService : Service
{
    public static TaskCompletionSource<bool> ForegroundStarted { get; set; }

    public override IBinder OnBind(Intent intent) => null;

    public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
    {
        CreateNotificationChannel();
        var notification = BuildNotification();
        var tcs = ForegroundStarted;
        ForegroundStarted = null;

        try
        {
            if (Build.VERSION.SdkInt >= BuildVersionCodes.Q)
            {
                StartForeground(NOTIFICATION_ID, notification, ForegroundService.TypeMediaProjection);
            }
            else
            {
                StartForeground(NOTIFICATION_ID, notification);
            }

            tcs?.TrySetResult(true);
        }
        catch (Exception ex)
        {
            Android.Util.Log.Error("AudioCaptureService", ex.ToString());
            tcs?.TrySetResult(false);
        }

        return StartCommandResult.Sticky;
    }
}
```

Finally, in `OnActivityResult`, start the service and obtain the token after it is foregrounded:

```
protected override void OnActivityResult(int requestCode, Android.App.Result resultCode, Intent data)
{
    base.OnActivityResult(requestCode, resultCode, data);

    if (requestCode == REQUEST_MEDIA_PROJECTION && resultCode == Android.App.Result.Ok && data != null)
    {
        var projResultCode = (int)resultCode;

        var fgsTcs = new TaskCompletionSource<bool>();
        AudioCaptureService.ForegroundStarted = fgsTcs;

        // Start the foreground service AFTER consent (required on Android 14+ / targetSDK 34+).
        var serviceIntent = new Intent(this, typeof(AudioCaptureService));
        StartForegroundService(serviceIntent);

        _ = Task.Run(async () =>
        {
            // Wait until the service reaches the foreground state.
            var completed = await Task.WhenAny(fgsTcs.Task, Task.Delay(5000));
            if (completed != fgsTcs.Task) { return; }

            // GetMediaProjection must be called AFTER the FGS is in foreground state.
            _mediaProjection = _projectionManager.GetMediaProjection(projResultCode, data);

            await StartCaptureAsync();
        });
    }
}
```

With `_mediaProjection` in hand, hand it to either engine below.

## How do I record app audio with VideoCaptureCoreX?

`VideoCaptureCoreX` is the recommended path: you set the audio source and add an output, and the engine builds the graph for you. Because there is no camera here, create the engine without a `VideoView` and run it audio-only.

```
using VisioForge.Core.Types.X.Android.Sources;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.VideoCaptureX;

private async Task StartCaptureCoreAsync()
{
    // Audio-only capture: no VideoView, no video source.
    _core = new VideoCaptureCoreX();
    _core.OnError += Core_OnError;

    // Audio playback capture source (records the audio of other apps via MediaProjection).
    _core.Audio_Source = new AndroidAudioPlaybackCaptureSourceSettings(_mediaProjection);
    _core.Audio_Play = false;   // do not play the captured audio back through the speaker
    _core.Audio_Record = true;  // route it into the output

    var musicDir = GetExternalFilesDir(Android.OS.Environment.DirectoryMusic);
    musicDir.Mkdirs();
    _recordingFilename = Path.Combine(musicDir.AbsolutePath, $"appaudio_{DateTime.Now:yyyyMMdd_HHmmss}.m4a");

    // M4A (AAC) audio-only output. autostart: true -> recording begins with StartAsync.
    _core.Outputs_Add(new M4AOutput(_recordingFilename), true);

    await _core.StartAsync();
}
```

To stop and finalize the file, stop and dispose the engine:

```
private async Task StopCaptureCoreAsync()
{
    var core = Interlocked.Exchange(ref _core, null);
    if (core != null)
    {
        core.OnError -= Core_OnError;
        await core.StopAsync();
        await core.DisposeAsync();
    }

    StopService(new Intent(this, typeof(AudioCaptureService)));
}
```

`M4AOutput` defaults to the `AVENCAACEncoderSettings` AAC encoder inside an MP4 container, so the result is a standard `.m4a` file.

## How do I record app audio with MediaBlocksPipeline?

`MediaBlocksPipeline` gives you the explicit graph. You create the source, encoder, and sink blocks yourself and connect their pads. Use this when you need to insert custom processing (for example a volume block, a tee, or a network sink) between capture and the file.

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AudioEncoders;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.Types.X.Android.Sources;
using VisioForge.Core.Types.X.Sinks;

private async Task StartCaptureCoreAsync()
{
    _pipeline = new MediaBlocksPipeline();
    _pipeline.OnError += Pipeline_OnError;

    // Audio playback capture source (records the audio of other apps).
    var settings = new AndroidAudioPlaybackCaptureSourceSettings(_mediaProjection);
    _audioSource = new AndroidAudioPlaybackCaptureSourceBlock(settings);

    // AAC encoder + MP4/M4A sink.
    _audioEncoder = new AACEncoderBlock();

    var musicDir = GetExternalFilesDir(Android.OS.Environment.DirectoryMusic);
    musicDir.Mkdirs();
    _recordingFilename = Path.Combine(musicDir.AbsolutePath, $"appaudio_{DateTime.Now:yyyyMMdd_HHmmss}.m4a");
    _sink = new MP4SinkBlock(new MP4SinkSettings(_recordingFilename));

    // source -> encoder -> sink
    _pipeline.Connect(_audioSource.Output, _audioEncoder.Input);
    _pipeline.Connect(_audioEncoder.Output, (_sink as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Audio));

    await _pipeline.StartAsync();
}
```

```
graph LR;
    src[AndroidAudioPlaybackCaptureSourceBlock] --> enc[AACEncoderBlock];
    enc --> sink[MP4SinkBlock];
```

Stop the pipeline the same way you stop any Media Blocks graph:

```
private async Task StopCaptureCoreAsync()
{
    var pipeline = Interlocked.Exchange(ref _pipeline, null);
    if (pipeline != null)
    {
        pipeline.OnError -= Pipeline_OnError;
        await pipeline.StopAsync(force: false);
        await pipeline.DisposeAsync();
    }

    StopService(new Intent(this, typeof(AudioCaptureService)));
}
```

## Which engine should I choose?

Both engines use the same `AndroidAudioPlaybackCaptureSourceSettings` and produce the same kind of `.m4a` file. The difference is how much of the graph you manage.

| Aspect | VideoCaptureCoreX | MediaBlocksPipeline |
| --- | --- | --- |
| Source | `Audio_Source = new AndroidAudioPlaybackCaptureSourceSettings(token)` | `new AndroidAudioPlaybackCaptureSourceBlock(settings)` |
| Output | `Outputs_Add(new M4AOutput(file), true)` | `AACEncoderBlock` → `MP4SinkBlock` connected by hand |
| Graph | Built by the engine | You connect every pad |
| Best for | Quick recording with minimal code | Custom processing, multiple outputs, streaming |
| Start / stop | `StartAsync` / `StopAsync` / `DisposeAsync` | `StartAsync` / `StopAsync` / `DisposeAsync` |

Start with `VideoCaptureCoreX`; move to `MediaBlocksPipeline` when you need to branch the audio or add elements the high-level output does not expose.

## Saving the file to the device library

Both samples write to the app's private external `Music` directory (`GetExternalFilesDir(DirectoryMusic)`) and then copy the finished file into the shared media library through `MediaStore` so it appears in music apps and file managers:

```
var values = new ContentValues();
values.Put(MediaStore.Audio.Media.InterfaceConsts.DisplayName, fileName);
values.Put(MediaStore.Audio.Media.InterfaceConsts.MimeType, "audio/mp4");
values.Put(MediaStore.Audio.Media.InterfaceConsts.RelativePath, Android.OS.Environment.DirectoryMusic);

var uri = ContentResolver.Insert(MediaStore.Audio.Media.ExternalContentUri, values);
using var output = ContentResolver.OpenOutputStream(uri);
using var input = new FileStream(filePath, FileMode.Open, FileAccess.Read);
input.CopyTo(output);
```

## Frequently Asked Questions

### Can I record audio from Spotify, Netflix, or YouTube?

Generally no. Apps that play protected or DRM content set `android:allowAudioPlaybackCapture="false"` (or publish audio with a non-capturable `usage`), which excludes them from `AudioPlaybackCapture`. Capturing them produces silence. Test with locally played media or apps that allow capture.

### Does audio playback capture require root?

No. It uses the public `AudioPlaybackCapture` API and a user-granted `MediaProjection` consent dialog. No root, no system signature, and no special OEM permission is needed.

### What is the minimum Android version?

Android 10 (API level 29). `AudioPlaybackCapture` did not exist before API 29, so set `SupportedOSPlatformVersion` to `29.0`. On older devices the playback-capture source reports that it is not available and the capture cannot start.

### Can I capture another app's audio and the microphone at the same time?

The source in this guide captures only playback audio. Mixing it with a microphone source requires adding a second audio source and an audio mixer to the graph — that is a separate topic and is best built on `MediaBlocksPipeline` for full control.

### Why is my recording silent?

The two common causes are: the source app opted out of playback capture (protected content), or it simply was not producing sound during the capture window. Confirm with a plain local audio/video file playing audibly, and verify `RECORD_AUDIO` was granted and the foreground service started before `GetMediaProjection` was called.

## See Also

- [Installation guide](../../../install/) — add the VisioForge .NET packages to your project
- [Android implementation and deployment](../../../deployment-x/Android/) — NuGet setup and packaging for Android apps
- [Audio capture and system sound recording](../../../videocapture/audio-capture/) — record the microphone and system audio in C#
- [Audio encoder blocks](../../../mediablocks/AudioEncoders/) — AAC, MP3, FLAC, and Opus encoders for the Media Blocks pipeline
- [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) — the high-level `VideoCaptureCoreX` engine
- [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) — the low-level `MediaBlocksPipeline` engine

---END OF PAGE---


## Capture USB (UVC) Cameras on Android in C# and .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/guides/android-usb-camera/
**Description:** Stream a USB webcam attached to an Android phone over OTG in C#. Covers permissions, MJPEG mode selection, USB 2.0 limits, and disconnect handling.
**Tags:** Media Blocks SDK, Video Capture SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, Android, USB, UVC, OTG, Capture, Webcam, MJPEG, C#, NuGet
**API:** MediaBlocksPipeline, VideoCaptureCoreX, AndroidUVCSourceBlock, AndroidUVCSourceSettings, AndroidUVCDevices, VideoRendererBlock

# Capture USB (UVC) Cameras on Android in C# and .NET

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Introduction

A USB Video Class (UVC) camera plugged into an Android phone over OTG is invisible to the standard Android camera API on most devices. `AndroidUVCSourceBlock` reaches it anyway: it talks to the camera through a bundled native libusb/libuvc bridge and pushes the frames into a `MediaBlocksPipeline`. It needs Android 9 (API level 28) or newer, the `android.permission.CAMERA` permission, and roughly 40 lines of C#.

This guide covers the whole path: why the normal API fails, the manifest and permission setup, the capture code, how a requested format is matched against what the camera offers, what USB 2.0 realistically delivers, and how to handle the camera being unplugged mid-stream.

## Why can't Camera2 see a USB camera on Android?

Android exposes USB cameras to the Camera2 API only through the **External Camera HAL**, an optional component that the device vendor has to build into the firmware. Many popular phones ship without it - on a Samsung Galaxy M55, for example, `pm list features` reports no `android.hardware.camera.external`, and the camera service lists only the built-in front and rear sensors. A UVC camera attached to such a phone is enumerated by the kernel, but no camera API will ever return it.

Two obvious workarounds also fail. The `/dev/video*` nodes the kernel creates belong to the `camera` group, which an ordinary app process is not a member of. And the Java `UsbDeviceConnection` API supports control, bulk, and interrupt transfers but **not isochronous** transfers - the transfer type UVC webcams use in practice.

That leaves one viable route, and it is the one this block takes: obtain the USB file descriptor from `UsbManager`, then drive the device from native code that can submit isochronous transfers.

```
graph LR;
    cam["USB camera (UVC)"] --> usb["UsbManager file descriptor"];
    usb --> bridge["libusb + libuvc bridge"];
    bridge --> src["AndroidUVCSourceBlock"];
    src --> renderer["VideoRendererBlock"];
```

## What you need

- **Android 9 (API level 28) or newer.** Set `<SupportedOSPlatformVersion>28.0</SupportedOSPlatformVersion>` in the `.csproj`.
- **A phone with USB host (OTG) support** and an OTG adapter or cable.
- **The `VisioForge.CrossPlatform.Core.Android` package**, which carries the native payload, plus `VisioForge.DotNet.MediaBlocks` and the `VisioForge.Core.Android.X10` project reference that every Android sample uses. See the [Android deployment guide](../../../deployment-x/Android/).

### Manifest entries

```
<!-- Android denies access to USB video class devices unless the app holds the camera
     permission, even though the Camera2 API is never used here. -->
<uses-permission android:name="android.permission.CAMERA" />
<!-- That permission otherwise makes a built-in camera an implied REQUIREMENT, which would
     hide the app from exactly the devices it targets: ones whose camera arrives over USB. -->
<uses-feature android:name="android.hardware.camera" android:required="false" />
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />
<uses-feature android:name="android.hardware.usb.host" android:required="true" />
```

Keep `android.hardware.usb.host` at `required="true"` only if your whole app is useless without a USB camera - it is a Play Store filter too, and on `true` it hides the app from every device without USB host support.

The `required="false"` line is not optional

Declaring `android.permission.CAMERA` makes Google Play treat a built-in camera as a device requirement. Left implicit, that filters your app out of the store listing on devices that have no built-in camera - which includes much of the hardware most likely to need a USB camera in the first place.

## Requesting the two permissions

USB camera capture needs two separate grants, in this order.

**1. The runtime `CAMERA` permission.** Request it as usual:

```
private const int CameraPermissionRequest = 1004;

protected override void OnCreate(Bundle savedInstanceState)
{
    base.OnCreate(savedInstanceState);

    RequestPermissions(new[] { Manifest.Permission.Camera }, CameraPermissionRequest);
}

public override void OnRequestPermissionsResult(
    int requestCode, string[] permissions, Android.Content.PM.Permission[] grantResults)
{
    base.OnRequestPermissionsResult(requestCode, permissions, grantResults);

    if (requestCode != CameraPermissionRequest)
    {
        return;
    }

    if (AndroidUVCDevices.HasCameraPermission())
    {
        _ = StartPreviewAsync();
    }
}
```

**2. Permission for the specific USB device**, which shows the system dialog:

```
if (!await AndroidUVCDevices.RequestPermissionAsync(camera))
{
    // denied, dismissed, or unanswered for two minutes
    return;
}
```

`RequestPermissionAsync` returns `false` on denial, on a dismissed dialog, and after a two-minute timeout; it throws `OperationCanceledException` only when you cancel it through your own `CancellationToken`.

Missing CAMERA permission fails silently

Without `android.permission.CAMERA` granted, the USB permission request returns `false` **instantly and no dialog is ever shown**. The only clue is in logcat: `UsbUserPermissionManager: Camera permission required for USB video class devices`. Check `AndroidUVCDevices.HasCameraPermission()` first and you will never chase this.

## Capturing from the camera

With both permissions in hand, the capture itself is ordinary Media Blocks code. Note that these types are compiled only for the Android target framework, so in a MAUI or other multi-targeted project this code belongs in an Android-only file or inside `#if ANDROID`:

```
using VisioForge.Core;
using VisioForge.Core.GStreamer.Android.UVC;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.Sources.AndroidUVC;

// list the attached USB cameras
var cameras = AndroidUVCDevices.FindCameras();
if (cameras.Count == 0)
{
    SetStatus("No USB camera found. Connect one over OTG.");
    return;
}

var camera = cameras[0];

if (!await AndroidUVCDevices.RequestPermissionAsync(camera))
{
    SetStatus("Access to the USB camera was denied.");
    return;
}

_pipeline = new MediaBlocksPipeline();
_pipeline.OnError += Pipeline_OnError;
_pipeline.OnStop += Pipeline_OnStop;

var settings = new AndroidUVCSourceSettings
{
    Device = camera,
    Width = 1280,
    Height = 720,
    FrameRate = new VideoFrameRate(30),
};

_videoSource = new AndroidUVCSourceBlock(settings);
_videoRenderer = new VideoRendererBlock(_pipeline, _videoView) { IsSync = false };

_pipeline.Connect(_videoSource.Output, _videoRenderer.Input);

if (!await _pipeline.StartAsync())
{
    SetStatus("Unable to start. Another app may be using the camera.");

    // the camera was already claimed while building, so hand it back
    await DisposePipelineAsync();
    return;
}

SetStatus($"Streaming from {camera.ProductName}");
```

Note that `StartAsync` returns a `bool`. Ignoring it leaves you looking at a black preview with no idea why, so check it and dispose the pipeline when it fails - that is what releases the camera for the next attempt.

To find out whether capture is possible before you build anything, call `AndroidUVCSourceBlock.IsAvailable()`. It confirms the Android release is new enough, the elements every mode needs are present, and the native bridge loads. It deliberately does not probe `jpegdec`, which only an MJPEG mode needs, nor whether a camera is attached - `AndroidUVCSourceBlock.GetDevices()` answers the latter.

## Capturing with VideoCaptureCoreX

The same camera also works as a `VideoCaptureCoreX` video source, which is the shorter route when you want recording, network streaming, video effects or snapshots rather than a pipeline you assemble yourself. Assign the settings to `Video_Source` and the engine builds everything downstream:

```
using VisioForge.Core.GStreamer.Android.UVC;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources.AndroidUVC;
using VisioForge.Core.VideoCaptureX;

var cameras = AndroidUVCDevices.FindCameras();
if (cameras.Count == 0 || !await AndroidUVCDevices.RequestPermissionAsync(cameras[0]))
{
    return;
}

_core = new VideoCaptureCoreX(_videoView);
_core.OnError += Core_OnError;

// a live camera has nothing to sync the recording branch to, and leaving it
// synced makes that branch wait on the clock until its queue fills and stalls
// the preview with it; a capture with audio sets Audio_Output_IsSync the same
// way, but this one is video-only
_core.Video_Output_IsSync = false;

_core.Video_Source = new AndroidUVCSourceSettings
{
    Device = cameras[0],
    Width = 1280,
    Height = 720,
    FrameRate = new VideoFrameRate(30),
};

_core.Video_Play = true;

// registered before StartAsync so the recording branch exists; autoStart false
// means nothing is written until StartCaptureAsync is called
_core.Outputs_Add(new MP4Output(placeholderPath), false);

await _core.StartAsync();

// later, when the user presses record
await _core.StartCaptureAsync(0, targetPath);
```

One recording per engine instance, today

`StartCaptureAsync` starts the output's own pipeline, and restarting a stopped one is a known open defect: the **second** call on the same output index returns `true` and writes no file at all - no exception, no `OnError`, nothing in the log. Check the return value *and* verify the file exists after `StopCaptureAsync`, and recreate the engine between recordings if your app needs to record more than once. Preview is unaffected.

Two differences from the Media Blocks route are worth knowing. `Video_Source_SwitchCamera` handles system cameras only, so switching to or from a USB camera means stopping and restarting the engine rather than a live swap. And `VideoCaptureCoreX` does not report an unplugged camera - see [Handling a disconnected camera](#handling-a-disconnected-camera).

The recording is video-only, and the phone microphone is not a workaround

A UVC video interface carries no audio, so nothing in this pipeline produces sound. Reaching for the phone microphone does not fix it on a typical webcam: a camera with a built-in mic also registers as a USB **audio** input, Android then prefers that input for recording, and it cannot be opened while the bridge is streaming from the same physical device. Adding the audio source fails the whole pipeline with `Internal data stream error` from `openslessrc`. Verified on a Galaxy M55 with a Logitech BRIO. A camera with no microphone leaves the phone mic as the default input, and then audio works normally.

## Which format should you request?

Request MJPEG resolutions, and treat your `Width`, `Height`, and `FrameRate` values as a preference rather than a command. The block matches them against the modes the camera actually advertises: nearest resolution by pixel count first, then MJPEG in preference to uncompressed formats, then the nearest frame rate. A mismatch produces a warning in logcat, not an error, so the pipeline starts on a format you did not ask for. The SDK logs the one it settled on as `USB camera ready: WxH@fps FORMAT` - check that line in logcat if the exact format matters. To decide from the camera's real capabilities rather than a guess, call `AndroidUVCDevices.GetModes(device)` after the USB permission is granted: it returns the resolutions, frame rates and formats you can actually pick from. Formats the SDK cannot stream - a camera's H.264 or NV12 modes - are left out, so the list is what is usable rather than everything the camera advertises. Set `Format` on the settings to ask for the format of the mode you picked; leaving it at `Unknown` favours MJPEG, which is normally what you want. It opens the camera to read them, so call it before starting capture.

The preference for MJPEG is deliberate and it matters more than the frame rate does. Over a USB 2.0 link, an uncompressed stream burns roughly 20 times the bandwidth of the same picture in MJPEG. A camera that advertises 1080p30 in MJPEG typically manages about **5 fps** uncompressed at that resolution - which looks like a broken pipeline rather than a bandwidth limit. If a camera offers only uncompressed formats it still works, just slowly.

## What USB 2.0 actually delivers

Most phones enumerate a USB camera at High Speed - 480 Mbps - rather than at the 5 Gbps a desktop USB 3 port provides, even when the port itself is USB 3 capable. Cameras report their capabilities per link speed, so the high-bandwidth modes are simply absent from the descriptors. A Logitech BRIO, which does 4K on a desktop, exposes no 4K mode at all on a phone; its practical ceiling there is **1080p30 or 720p60 in MJPEG**.

Plan for that when you pick a resolution. 720p30 is a safe default on any UVC camera, and it is what `AndroidUVCSourceSettings` uses if you leave the defaults alone.

## Handling a disconnected camera

Someone will unplug the camera while your app is streaming. When that happens the block ends the stream, so a `MediaBlocksPipeline` raises `OnStop`:

```
private void Pipeline_OnError(object sender, ErrorsEventArgs e)
{
    SetStatus(e.Message);
}

private void Pipeline_OnStop(object sender, StopEventArgs e)
{
    SetStatus("The camera was disconnected.");
}
```

Two details are worth knowing. The renderer keeps displaying the last frame it received, so the preview does not go blank on its own - clear or hide your video view in this handler. And a camera pulled out mid-frame delivers a partial frame, which decodes into visible noise, so that frozen last frame may look corrupted. Hiding the view avoids showing it at all.

Do not dispose the pipeline from inside this handler if your handler runs on the device callback thread; tear down from your own thread - for example from the activity's `OnDestroy`:

```
private async Task DisposePipelineAsync()
{
    if (_pipeline == null)
    {
        return;
    }

    _pipeline.OnError -= Pipeline_OnError;
    _pipeline.OnStop -= Pipeline_OnStop;

    await _pipeline.DisposeAsync();
    _pipeline = null;
}

protected override async void OnDestroy()
{
    // first, before anything that can await - see the note below
    base.OnDestroy();

    try
    {
        await DisposePipelineAsync();
    }
    catch (Exception ex)
    {
        Log.Error(TAG, ex.ToString());
    }

    VisioForgeX.DestroySDK();
}
```

`base.OnDestroy()` has to come first

Android checks that the base implementation ran by the time `OnDestroy` returns, and an `await` returns to the runtime long before the method finishes. Calling it last - after awaiting the teardown - throws `android.util.SuperNotCalledException: Activity did not call through to super.onDestroy()` and kills the process. Call it first; the continuation still runs and disposes the pipeline afterwards.

With `VideoCaptureCoreX` there is no such event. The engine raises `OnStop` from its own stop path and does not observe a stream that ends on its own, so an unplugged camera never reaches `OnStop`. The source does report it through `OnError`, but only once the frames have stopped arriving for a few seconds - the preview is already frozen by then, and a recording in progress is still open. Subscribe to Android's `ACTION_USB_DEVICE_DETACHED` broadcast as well, which arrives the moment the cable comes out: confirm that your camera is the device that went away, then stop the capture and the engine:

```
// once the pipeline is running
RegisterReceiver(
    new UsbDetachReceiver(OnUsbDetached),
    new IntentFilter(UsbManager.ActionUsbDeviceDetached),
    ReceiverFlags.NotExported);
```

Both members belong to your activity - the handler, and the receiver that forwards the broadcast to it:

```
private async void OnUsbDetached()
{
    // the broadcast carries no usable device on current Android levels, but an
    // unplugged camera stops being enumerated - so ignore every other device
    if (AndroidUVCDevices.FindCameras().Any(c => c.DeviceName == _camera.DeviceName))
    {
        return;
    }

    await _core.StopCaptureAsync(0);
    await _core.StopAsync();
}

private class UsbDetachReceiver : BroadcastReceiver
{
    private readonly Action _onDetached;

    public UsbDetachReceiver(Action onDetached)
    {
        _onDetached = onDetached;
    }

    public override void OnReceive(Context context, Intent intent)
    {
        _onDetached();
    }
}
```

Stopping the capture first is what closes the recording properly. The frames already written are flushed either way, so the file stays playable, but the engine keeps thinking it is running until you stop it.

## Troubleshooting

| What you see | What it means |
| --- | --- |
| USB permission denied instantly, no dialog | `android.permission.CAMERA` is not granted. Logcat: `Camera permission required for USB video class devices`. |
| `USB camera capture requires Android 9 (API 28) or later.` | The device is older than API 28. Check `AndroidUVCDevices.IsSupportedPlatform()` before offering the feature. |
| `No permission for the USB camera. Call AndroidUVCDevices.RequestPermissionAsync first.` | The device grant is missing; `StartAsync` was called too early. |
| `The camera advertises no usable video modes.` | The camera exposes neither MJPEG nor YUY2 on this link. |
| `StartAsync` returns `false`, logcat mentions an invalid mode | Another process holds the camera. Only one application can stream from a UVC device at a time. |
| `Requested 1920x1080@30 is not offered; using 1280x720@30.` | Informational: the nearest advertised mode was selected instead. |
| No frames arrive after a re-plug, pipeline stays paused | A transient USB condition after re-plugging. Restart the capture. |
| `Unable to create the jpegdec element.` | The GStreamer payload has no JPEG decoder, so an MJPEG mode cannot be built. `IsAvailable()` does not cover this - it returns `true` because uncompressed modes would still work. |

## Frequently Asked Questions

### Does this work on any Android phone?

It works on any device running Android 9 (API level 28) or newer that supports USB host mode, which is most phones and tablets sold since 2018. Unlike the Camera2 route, it does not depend on the vendor shipping the External Camera HAL, so it works on hardware where the built-in camera API cannot see a USB camera at all. Two things are still required from the device: OTG support in the hardware, and enough USB bus power for the camera - a camera drawing more than the port supplies will fail to enumerate. Call `AndroidUVCDevices.IsSupportedPlatform()` to check the Android version and `AndroidUVCSourceBlock.IsAvailable()` to confirm the native bridge loaded before you offer the feature in your UI.

### Do I need root access?

No. The whole point of this design is that it runs as an ordinary app. Root would be one way to open the `/dev/video*` nodes the kernel creates for a UVC camera, since those belong to the `camera` group that app processes are not in - but that is not the route taken here. Instead the app asks `UsbManager` for permission, receives a file descriptor for the device, and hands that descriptor to the native bridge, which submits the isochronous USB transfers the camera needs. Everything happens through documented Android APIs and the user's own consent, so the app installs and runs normally, and can ship on Google Play.

### Can I record to a file instead of previewing?

Yes. `AndroidUVCSourceBlock` is a normal Media Blocks source with a single video output pad, so it connects to anything the SDK provides: an [MP4 output](../../../mediablocks/Outputs/), an [RTMP or SRT sink](../../../mediablocks/Sinks/) for streaming, or a video processing chain. Connect its `Output` pad to an encoder or output block instead of - or in addition to - the renderer. Frames arrive decoded, so no extra decoding step is needed. The block has no audio pad, so an MP4 recorded from it alone is video-only and an RTMP push without audio is rejected by many services. Adding a separate audio source is the answer, but read the warning above first: on a camera that has its own microphone, Android prefers that USB audio input and it cannot be captured while the camera is being streamed. Bear in mind the bandwidth ceiling when choosing a recording resolution: 720p30 is comfortable, 1080p30 is the practical maximum on most phones.

### Why is MJPEG preferred over uncompressed video?

Because uncompressed video does not fit through a High Speed USB link at any useful frame rate. A 1280x720 frame in YUY2 is about 1.8 MB, so 30 fps needs roughly 440 Mbps. The bus itself runs at 480 Mbps, but the real limit is lower: a high-bandwidth isochronous endpoint carries at most 3072 bytes per microframe, or about 24.5 MB/s - roughly 196 Mbps. Cameras solve this by advertising uncompressed formats only at very low rates: a camera offering 1080p30 in MJPEG typically caps uncompressed 1080p at about 5 fps. Selecting the uncompressed mode therefore looks like a broken or stalled pipeline rather than a deliberate trade-off. Within a resolution the mode selector prefers MJPEG even when its frame rate is further from what you requested, and the pipeline decodes the JPEG frames for you. Resolution is matched first, though, so a camera that offers 1080p only as uncompressed video will still hand you that slow mode if you ask for 1080p - request a resolution the camera offers in MJPEG.

### Which native libraries are included, and under what licence?

Two, both shipped inside the `VisioForge.CrossPlatform.Core.Android` package for all four Android ABIs. **libusb 1.0.30** provides the USB transport and is licensed under the **LGPL v2.1 or later**; it ships as a separate shared object, `libusb1.0.so`, dynamically linked and therefore replaceable, as that licence requires. **libuvc** provides the UVC protocol layer and is licensed under the permissive **BSD 3-Clause** licence; it is compiled into `libVisioForge_UVC.so`. Neither library is patched. The complete notices, including both full licence texts and the exact versions, ship with the package as `THIRD-PARTY-NOTICES.txt`.

## Related documentation

- [USB (UVC) Camera Source Block](../../../mediablocks/Sources/#usb-uvc-camera-source-block) - the block reference
- [Android deployment guide](../../../deployment-x/Android/) - packages, permissions, and native payload
- [Record another app's audio on Android](../android-audio-playback-capture/) - another Android-specific capture flow

---END OF PAGE---


## Capture Video to MPEG-TS with Hardware Encoding in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/guides/video-capture-to-mpegts/
**Description:** Capture video and audio to MPEG-TS files in C# with hardware acceleration, format selection, and cross-platform support for .NET applications.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Webcam, HLS, TS, H.264, AAC, C#
**API:** VideoCaptureCoreX, MediaBlocksPipeline, DeviceEnumerator, MediaBlockPadMediaType, VideoView

# Video Capture to MPEG-TS in C# and .NET: Complete Guide

## Introduction

This technical guide demonstrates how to capture C# TS video from cameras and microphones using two powerful VisioForge multimedia solutions: Video Capture SDK .NET with VideoCaptureCoreX engine and Media Blocks SDK .NET with MediaBlocksPipeline engine. Both SDKs provide robust capabilities for capturing, recording, and editing TS (MPEG Transport Stream) files in .NET applications. We'll explore detailed code samples for implementing video/audio capture to TS in C# with optimized performance and quality.

## Installation and deployment

Please refer to the [installation guide](../../../install/) for detailed instructions on how to install the VisioForge .NET SDKs on your system.

## Video Capture SDK .NET (VideoCaptureCoreX) - Capture MPEG-TS in C

VideoCaptureCoreX provides a streamlined approach to capture TS video and audio in C#. Its component-based architecture handles the complex media pipeline, allowing developers to focus on configuration rather than lower-level implementation details when working with TS files in .NET.

### Core Components

1. **VideoCaptureCoreX**: Main engine for managing video capture, rendering, and TS output.
2. **VideoView**: UI component for real-time video rendering during capture.
3. **DeviceEnumerator**: Class for discovering video/audio devices.
4. **VideoCaptureDeviceSourceSettings**: Configuration for camera input when capturing MPEG-TS.
5. **AudioRendererSettings**: Configuration for audio playback with AAC support.
6. **MPEGTSOutput**: Configuration specifically for MPEG-TS file output.

### Implementation Example

Here's a complete C# implementation to capture and record MPEG-TS files:

```
// Class instance for video capture engine
VideoCaptureCoreX videoCapture;

private async Task StartCaptureAsync()
{
    // Initialize the VisioForge SDK
    await VisioForgeX.InitSDKAsync();

    // Create VideoCaptureCoreX instance and associate with UI VideoView control
    videoCapture = new VideoCaptureCoreX(videoView: VideoView1);

    // Get list of available video capture devices
    var videoSources = await DeviceEnumerator.Shared.VideoSourcesAsync();

    // Initialize video source settings
    VideoCaptureDeviceSourceSettings videoSourceSettings = null;

    // Get first available video capture device
    var videoDevice = videoSources[0];

    // Try to get HD resolution and frame rate capabilities from device
    var videoFormat = videoDevice.GetHDVideoFormatAndFrameRate(out VideoFrameRate frameRate);
    if (videoFormat != null)
    {
        // Configure video source with HD format
        videoSourceSettings = new VideoCaptureDeviceSourceSettings(videoDevice)
        {
            Format = videoFormat.ToFormat()
        };

        // Set capture frame rate
        videoSourceSettings.Format.FrameRate = frameRate;
    }

    // Configure video capture device with settings
    videoCapture.Video_Source = videoSourceSettings;

    // Configure audio capture (microphone)

    // Initialize audio source settings
    IVideoCaptureBaseAudioSourceSettings audioSourceSettings = null;

    // Get available audio capture devices using DirectSound API
    var audioApi = AudioCaptureDeviceAPI.DirectSound;
    var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync(audioApi);

    // Get first available audio capture device
    var audioDevice = audioDevices[0];
    if (audioDevice != null)
    {
        // Get default audio format supported by device
        var audioFormat = audioDevice.GetDefaultFormat();
        if (audioFormat != null)
        {
            // Configure audio source with default format
            audioSourceSettings = audioDevice.CreateSourceSettingsVC(audioFormat);
        }
    }

    // Configure audio capture device with settings
    videoCapture.Audio_Source = audioSourceSettings;

    // Configure audio playback device
    // Get first available audio output device
    var audioOutputDevice = (await DeviceEnumerator.Shared.AudioOutputsAsync())[0];

    // Configure audio renderer for playback through selected device
    videoCapture.Audio_OutputDevice = new AudioRendererSettings(audioOutputDevice);

    // Enable audio monitoring and recording
    videoCapture.Audio_Play = true;    // Enable real-time audio monitoring
    videoCapture.Audio_Record = true;   // Enable audio recording to output file

    // Configure MPEG Transport Stream output
    var mpegtsOutput = new MPEGTSOutput("output.ts");

    // Configure video encoder with hardware acceleration if available
    if (NVENCH264EncoderSettings.IsAvailable())
    {
        // Use NVIDIA hardware encoder
        mpegtsOutput.Video = new NVENCH264EncoderSettings();
    }
    else if (QSVH264EncoderSettings.IsAvailable())
    {
        // Use Intel Quick Sync hardware encoder
        mpegtsOutput.Video = new QSVH264EncoderSettings();
    }
    else if (AMFH264EncoderSettings.IsAvailable())
    {
        // Use AMD hardware encoder
        mpegtsOutput.Video = new AMFH264EncoderSettings();
    }
    else
    {
        // Fallback to software encoder
        mpegtsOutput.Video = new OpenH264EncoderSettings();
    }

    // Configure audio encoder for MPEG-TS output
    // mpegtsOutput.Audio = ...

    // Add MPEG-TS output to capture pipeline
    // autostart: true means output starts automatically with capture
    videoCapture.Outputs_Add(mpegtsOutput, autostart: true);

    // Start the capture process
    await videoCapture.StartAsync();
}

private async Task StopCaptureAsync()
{
    // Stop all capture and encoding
    await videoCapture.StopAsync();

    // Clean up resources
    await videoCapture.DisposeAsync();
}
```

### VideoCaptureCoreX Advanced Features for MPEG-TS Recording

1. **Hardware Acceleration**: Support for NVIDIA (NVENC), Intel (QSV), and AMD (AMF) hardware encoding.
2. **Format Selection**: The SDK provides access to the native camera formats and frame rates.
3. **Audio Configuration**: Provides volume control and format selection.
4. **Multiple Outputs**: Ability to add multiple output formats simultaneously.

## Media Blocks SDK .NET (MediaBlocksPipeline) - Capture TS in C

The MediaBlocksPipeline engine in Media Blocks SDK .Net takes a different architectural approach, focusing on a modular block-based system where each component (block) has specific responsibilities in the media processing pipeline.

### Core Blocks

1. **MediaBlocksPipeline**: The main container and controller for the media blocks pipeline.
2. **SystemVideoSourceBlock**: Captures video from webcams.
3. **SystemAudioSourceBlock**: Captures audio from microphones.
4. **VideoRendererBlock**: Renders the video to a VideoView control.
5. **AudioRendererBlock**: Handles audio playback.
6. **TeeBlock**: Splits media streams for simultaneous processing (e.g., display and encoding).
7. **H264EncoderBlock**: Encodes video using H.264.
8. **AACEncoderBlock**: Encodes audio using AAC.
9. **MPEGTSSinkBlock**: Saves encoded streams to an MPEG-TS file.

### Implementation Example

Here's how to implement advanced capture of TS files in C#:

```
// Pipeline instance
MediaBlocksPipeline pipeline;

private async Task StartCaptureAsync()
{
    // Initialize the SDK
    await VisioForgeX.InitSDKAsync();

    // Create new pipeline instance
    pipeline = new MediaBlocksPipeline();

    // Get first available video device and configure HD format
    var device = (await DeviceEnumerator.Shared.VideoSourcesAsync())[0];
    var formatItem = device.GetHDVideoFormatAndFrameRate(out VideoFrameRate frameRate);
    var videoSourceSettings = new VideoCaptureDeviceSourceSettings(device)
    {
        Format = formatItem.ToFormat()
    };
    videoSourceSettings.Format.FrameRate = frameRate;

    // Create video source block with configured settings
    var videoSource = new SystemVideoSourceBlock(videoSourceSettings);

    // Get first available audio device and configure default format
    var audioDevice = (await DeviceEnumerator.Shared.AudioSourcesAsync())[0];
    var audioFormat = audioDevice.GetDefaultFormat();
    var audioSourceSettings = audioDevice.CreateSourceSettings(audioFormat);
    var audioSource = new SystemAudioSourceBlock(audioSourceSettings);

    // Create video renderer block and connect to UI VideoView control
    var videoRenderer = new VideoRendererBlock(pipeline, videoView: VideoView1) { IsSync = false };

    // Create audio renderer block for playback
    var audioRenderer = new AudioRendererBlock() { IsSync = false };

    // Note: IsSync is false to maximize encoding performance

    // Create video and audio tees
    var videoTee = new TeeBlock(2, MediaBlockPadMediaType.Video);
    var audioTee = new TeeBlock(2, MediaBlockPadMediaType.Audio);

    // Create MPEG-TS muxer
    var muxer = new MPEGTSSinkBlock(new MPEGTSSinkSettings("output.ts"));

    // Create video and audio encoders with hardware acceleration if available
    var videoEncoder = new H264EncoderBlock();
    var audioEncoder = new AACEncoderBlock();

    // Connect video processing blocks:
    // Source -> Tee -> Renderer (preview) and Encoder -> Muxer
    pipeline.Connect(videoSource.Output, videoTee.Input);
    pipeline.Connect(videoTee.Outputs[0], videoRenderer.Input);
    pipeline.Connect(videoTee.Outputs[1], videoEncoder.Input);
    pipeline.Connect(videoEncoder.Output, (muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Video));

    // Connect audio processing blocks:
    // Source -> Tee -> Renderer (playback) and Encoder -> Muxer
    pipeline.Connect(audioSource.Output, audioTee.Input);
    pipeline.Connect(audioTee.Outputs[0], audioRenderer.Input);
    pipeline.Connect(audioTee.Outputs[1], audioEncoder.Input);
    pipeline.Connect(audioEncoder.Output, (muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Audio));

    // Start the pipeline processing
    await pipeline.StartAsync();
}

private async Task StopCaptureAsync()
{
    // Stop all pipeline processing
    await pipeline.StopAsync();

    // Clean up resources
    await pipeline.DisposeAsync();
    pipeline = null;
}
```

### MediaBlocksPipeline Advanced Features

1. **Fine-Grained Control**: Direct control over each processing step in the pipeline.
2. **Dynamic Pipeline Construction**: Ability to create complex processing pipelines by connecting blocks.
3. **Multiple Processing Paths**: Using TeeBlock to split streams for different processing paths.
4. **Custom Blocks**: Ability to create and integrate custom processing blocks.
5. **Granular Error Handling**: Error events at each block level.

## TS Output Configuration with AAC Audio

Both SDKs provide robust support for MPEG-TS output, which is particularly useful for broadcasting and streaming applications due to its error resilience and low latency characteristics.

### File Splitting for MPEG-TS Recording

Both SDKs support automatic file splitting for MPEG-TS output, enabling segmented recording based on duration, file size, or timecode. This is essential for:

- **HLS Streaming**: Create segmented files for HTTP Live Streaming
- **Storage Management**: Limit file sizes and implement rolling buffers
- **DVR Functionality**: Record continuous streams with automatic file rotation
- **Time-Lapse Recording**: Split recordings at regular intervals

#### Using File Splitting with VideoCaptureCoreX

```
using VisioForge.Core.Types.X.Sinks;

// Create split settings for 5-minute segments
var mpegtsOutput = new MPEGTSOutput("recording_%05d.ts", useAAC: true);
mpegtsOutput.Sink = new MPEGTSSplitSinkSettings("recording_%05d.ts")
{
    SplitDuration = TimeSpan.FromMinutes(5),  // New file every 5 minutes
    SplitMaxFiles = 12,  // Keep only last 12 files (1 hour total)
    M2TSMode = false
};

// Add to capture pipeline
videoCapture.Outputs_Add(mpegtsOutput, autostart: true);
```

#### Using File Splitting with MediaBlocksPipeline

```
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.MediaBlocks.Sinks;

// Create MPEG-TS muxer with split settings
var splitSettings = new MPEGTSSplitSinkSettings("output_%05d.ts")
{
    SplitDuration = TimeSpan.FromMinutes(10),  // Split every 10 minutes
    SplitFileSize = 100 * 1024 * 1024,  // Or when file reaches 100 MB
    SplitMaxFiles = 6,  // Keep last 6 files
    StartIndex = 0
};

var muxer = new MPEGTSSinkBlock(splitSettings);

// Connect video and audio encoders to the muxer
pipeline.Connect(videoEncoder.Output, (muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(audioEncoder.Output, (muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Audio));
```

#### Split Configuration Options

The `MPEGTSSplitSinkSettings` class provides several options:

- **SplitDuration**: Maximum duration per file (TimeSpan)
- **SplitFileSize**: Maximum file size in bytes (ulong)
- **SplitMaxSizeTimecode**: Split based on timecode difference (string, format: "HH:MM:SS:FF")
- **SplitMaxFiles**: Maximum number of files to keep; older files are automatically deleted (uint, 0 = unlimited)
- **StartIndex**: Starting index for segment numbering (int)
- **M2TSMode**: Use Blu-ray M2TS format with 192-byte packets (bool)

Files will be split when **any** of the configured criteria (duration, size, or timecode) is met first.

#### Filename Pattern

The filename pattern uses printf-style formatting for segment numbers: - `"video_%05d.ts"` → `video_00000.ts`, `video_00001.ts`, ... - `"stream_%02d.ts"` → `stream_00.ts`, `stream_01.ts`, ...

Read more about video and audio encoders available for TS capture in .NET:

- [H264 encoders](../../video-encoders/h264/)
- [HEVC encoders](../../video-encoders/hevc/)
- [AAC encoders](../../audio-encoders/aac/)
- [MP3 encoders](../../audio-encoders/mp3/)
- [MPEG-TS output](../../output-formats/mpegts/)

## Cross-Platform Considerations

Both SDKs offer cross-platform capabilities, but with different approaches:

1. **VideoCaptureCoreX**: Provides a unified API across platforms with platform-specific implementations.
2. **MediaBlocksPipeline**: Uses a consistent block-based architecture across platforms, with blocks handling platform differences internally.

## Sample applications

- [VideoCaptureCoreX Sample Application](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WPF/CSharp/Simple%20Video%20Capture)
- [MediaBlocksPipeline Sample Application](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Simple%20Capture%20Demo)

## Conclusion: Choosing the Right SDK for C# MPEG-TS Capture

VisioForge offers two powerful solutions for recording MPEG-TS files in C# and .NET:

- **VideoCaptureCoreX** provides a streamlined API for quick implementation of MPEG-TS capture in C#, ideal for projects where ease of use is essential.
- **MediaBlocksPipeline** offers maximum flexibility for complex MPEG-TS recording and editing scenarios in .NET through its modular block architecture.

Both SDKs excel at capturing video from cameras and audio from microphones, with comprehensive support for MPEG-TS output, making them valuable tools for developing a wide range of multimedia applications.

Choose VideoCaptureCoreX for rapid implementation of standard TS capture scenarios, or MediaBlocksPipeline for advanced editing and custom processing workflows with TS files in your .NET applications.

---END OF PAGE---


## WMA Audio Recording and Editing in .NET SDK with C#
**URL:** https://www.visioforge.com/help/docs/dotnet/general/guides/wma-recording-editing/
**Description:** Record WMA audio from microphone and edit WMA files in .NET with VideoCaptureCoreX and VideoEditCoreX classes for Windows Media Audio capture and editing.
**Tags:** Video Capture SDK, Video Edit SDK, .NET, VideoCaptureCoreX, VideoEditCoreX, Windows, WinForms, GStreamer, Capture, Encoding, Editing, Effects, MP3, WMA, C#, NuGet
**API:** VideoEditCoreX, VideoCaptureCoreX, WMAOutput, WMAEncoderSettings, AudioFileSource

# Record and Edit WMA Files in C# and .NET: A Comprehensive Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

## Introduction to WMA Recording and Editing in .NET

This article provides a comprehensive guide for developers working with Windows Media Audio (WMA) files in .NET applications. We'll explore how to record .NET WMA audio from microphones and other capture devices using the VideoCaptureCoreX class, and how to edit dotnet WMA files using the VideoEditCoreX class from the VisioForge .NET SDKs.

Windows Media Audio is a popular audio format developed by Microsoft that offers excellent compression while maintaining good audio quality. The WMA format is widely used in Windows applications and supports various bitrates and sample rates, making it suitable for both voice records and high-quality music.

The VisioForge library provides powerful classes for capturing audio data from system devices and processing audio video content. Whether you need to create a simple voice recorder console application or a complex WinForms audio editor, these SDKs deliver the functionality you need. This guide will show you how to capture dotnet WMA audio and record csharp WMA files with ease.

## Prerequisites and Installation

Before you begin recording or editing WMA files in your dotnet application, ensure you have the following:

- Visual Studio 2019 or later
- .NET 6.0 or later (or .NET Framework 4.7.2+)
- VisioForge Video Capture SDK .NET or Video Edit SDK .NET

### Installing the NuGet Packages

Install the required packages using the NuGet Package Manager:

```
# For WMA recording with VideoCaptureCoreX
Install-Package VisioForge.DotNet.VideoCapture

# For WMA editing with VideoEditCoreX
Install-Package VisioForge.DotNet.VideoEdit
```

For detailed installation instructions, please refer to the [installation guide](../../../install/).

## Recording WMA Files from Microphone Using VideoCaptureCoreX

The VideoCaptureCoreX class provides a straightforward approach to capture csharp WMA audio from microphones and other audio input devices. This section demonstrates how to record csharp WMA audio files with proper device enumeration and encoder configuration. Learn how to capture csharp WMA content for various application scenarios.

### Core Components for WMA Recording

1. **VideoCaptureCoreX**: Main engine class for managing audio capture and WMA output in .NET.
2. **DeviceEnumerator**: Class for discovering available audio capture devices on the system.
3. **AudioCaptureDeviceSourceSettings**: Configuration settings for microphone or audio input device.
4. **WMAOutput**: Output format configuration specifically for Windows Media Audio file creation.
5. **WMAEncoderSettings**: Settings class for WMA encoder parameters like bitrate and sample rate.

### Basic WMA Recording Implementation

Here's a complete csharp implementation to capture and record WMA files from a microphone:

```
using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.VideoCaptureX;

public class WmaRecorder
{
    private VideoCaptureCoreX _videoCapture;

    // Call this method once during application startup or form load
    public async Task InitializeAsync()
    {
        // Initialize the VisioForge SDK
        await VisioForgeX.InitSDKAsync();
    }

    public async Task StartRecordingAsync(string outputPath)
    {
        // Create VideoCaptureCoreX instance for audio capture
        _videoCapture = new VideoCaptureCoreX();

        // Configure audio capture device (microphone)
        await ConfigureAudioSourceAsync();

        // Disable video capture - we only need audio
        _videoCapture.Video_Source = null;
        _videoCapture.Video_Play = false;

        // Configure audio settings
        _videoCapture.Audio_Play = false;    // Disable audio monitoring during recording
        _videoCapture.Audio_Record = true;   // Enable audio recording to file

        // Configure WMA output format
        var wmaOutput = new WMAOutput(outputPath);

        // Configure WMA encoder settings
        wmaOutput.Audio.Bitrate = 192;       // 192 Kbps bitrate
        wmaOutput.Audio.SampleRate = 48000;  // 48 kHz sample rate
        wmaOutput.Audio.Channels = 2;        // Stereo recording

        // Add WMA output to capture pipeline
        _videoCapture.Outputs_Add(wmaOutput, autostart: true);

        // Start the audio capture process
        await _videoCapture.StartAsync();

        Console.WriteLine("Recording started. Press any key to stop...");
    }

    private async Task ConfigureAudioSourceAsync()
    {
        // Get available audio capture devices using DirectSound API
        var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync(
            AudioCaptureDeviceAPI.DirectSound);

        if (audioDevices.Length == 0)
        {
            throw new Exception("No audio capture device found.");
        }

        // Get first available audio capture device (usually the default microphone)
        var audioDevice = audioDevices[0];

        // Get supported format from the device
        var audioFormat = audioDevice.GetDefaultFormat();

        // Create audio source settings with the selected device and format
        var audioSourceSettings = audioDevice.CreateSourceSettingsVC(audioFormat);

        // Configure audio capture device
        _videoCapture.Audio_Source = audioSourceSettings;
    }

    public async Task StopRecordingAsync()
    {
        if (_videoCapture != null)
        {
            // Stop all capture and encoding
            await _videoCapture.StopAsync();

            // Clean up resources
            await _videoCapture.DisposeAsync();
            _videoCapture = null;

            Console.WriteLine("Recording stopped and file saved.");
        }
    }
}
```

### Console Application Example for WMA Recording

Here's a complete console application that records WMA audio from a microphone:

```
using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.VideoCaptureX;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("WMA Audio Recorder - Console Application");
        Console.WriteLine("========================================");

        // Initialize SDK
        await VisioForgeX.InitSDKAsync();

        // Create capture instance
        var videoCapture = new VideoCaptureCoreX();

        try
        {
            // Enumerate and display available audio capture devices
            var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync(
                AudioCaptureDeviceAPI.DirectSound);

            Console.WriteLine("\nAvailable audio capture devices:");
            for (int i = 0; i < audioDevices.Length; i++)
            {
                Console.WriteLine($"  {i + 1}. {audioDevices[i].DisplayName}");
            }

            if (audioDevices.Length == 0)
            {
                Console.WriteLine("No audio capture device found. Exiting.");
                return;
            }

            // Select first device for recording
            var selectedDevice = audioDevices[0];
            var audioFormat = selectedDevice.GetDefaultFormat();
            var audioSourceSettings = selectedDevice.CreateSourceSettingsVC(audioFormat);

            // Configure video capture for audio-only recording
            videoCapture.Audio_Source = audioSourceSettings;
            videoCapture.Video_Source = null;
            videoCapture.Video_Play = false;
            videoCapture.Audio_Play = false;
            videoCapture.Audio_Record = true;

            // Configure WMA output file
            string outputPath = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.MyMusic),
                $"recording_{DateTime.Now:yyyyMMdd_HHmmss}.wma");

            var wmaOutput = new WMAOutput(outputPath);
            wmaOutput.Audio.Bitrate = 192;
            wmaOutput.Audio.SampleRate = 48000;
            wmaOutput.Audio.Channels = 2;

            videoCapture.Outputs_Add(wmaOutput, autostart: true);

            // Start recording
            Console.WriteLine($"\nRecording to: {outputPath}");
            Console.WriteLine("Press ENTER to stop recording...\n");

            await videoCapture.StartAsync();

            // Wait for user input to stop
            Console.ReadLine();

            // Stop recording
            await videoCapture.StopAsync();
            Console.WriteLine($"\nRecording saved to: {outputPath}");
        }
        finally
        {
            // Cleanup
            await videoCapture.DisposeAsync();
            VisioForgeX.DestroySDK();
        }
    }
}
```

### WinForms Application for WMA Recording

For a Windows Forms application with visual controls, here's an implementation example:

```
using System;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using VisioForge.Core;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.VideoCaptureX;

public partial class WmaRecorderForm : Form
{
    private VideoCaptureCoreX _videoCapture;
    private bool _isRecording = false;

    public WmaRecorderForm()
    {
        InitializeComponent();
    }

    private async void Form_Load(object sender, EventArgs e)
    {
        // Initialize SDK
        await VisioForgeX.InitSDKAsync();

        // Populate audio device dropdown
        var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync(
            AudioCaptureDeviceAPI.DirectSound);

        foreach (var device in audioDevices)
        {
            cmbAudioDevices.Items.Add(device.DisplayName);
        }

        if (cmbAudioDevices.Items.Count > 0)
        {
            cmbAudioDevices.SelectedIndex = 0;
        }

        // Set default output path
        txtOutputPath.Text = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.MyMusic),
            "recording.wma");
    }

    private async void btnStartStop_Click(object sender, EventArgs e)
    {
        if (!_isRecording)
        {
            await StartRecordingAsync();
        }
        else
        {
            await StopRecordingAsync();
        }
    }

    private async Task StartRecordingAsync()
    {
        _videoCapture = new VideoCaptureCoreX();

        // Get selected audio device
        var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync(
            AudioCaptureDeviceAPI.DirectSound);
        var selectedDevice = audioDevices.FirstOrDefault(
            d => d.DisplayName == cmbAudioDevices.SelectedItem.ToString());

        if (selectedDevice == null)
        {
            MessageBox.Show("Please select an audio device.");
            return;
        }

        // Configure audio source
        var audioFormat = selectedDevice.GetDefaultFormat();
        var audioSourceSettings = selectedDevice.CreateSourceSettingsVC(audioFormat);
        _videoCapture.Audio_Source = audioSourceSettings;

        // Configure for audio-only capture
        _videoCapture.Video_Source = null;
        _videoCapture.Video_Play = false;
        _videoCapture.Audio_Play = false;
        _videoCapture.Audio_Record = true;

        // Configure WMA output
        var wmaOutput = new WMAOutput(txtOutputPath.Text);
        wmaOutput.Audio.Bitrate = (int)numBitrate.Value;
        wmaOutput.Audio.SampleRate = 48000;
        wmaOutput.Audio.Channels = rbStereo.Checked ? 2 : 1;

        _videoCapture.Outputs_Add(wmaOutput, autostart: true);

        // Start recording
        await _videoCapture.StartAsync();

        _isRecording = true;
        btnStartStop.Text = "Stop Recording";
        lblStatus.Text = "Recording...";
    }

    private async Task StopRecordingAsync()
    {
        if (_videoCapture != null)
        {
            await _videoCapture.StopAsync();
            await _videoCapture.DisposeAsync();
            _videoCapture = null;
        }

        _isRecording = false;
        btnStartStop.Text = "Start Recording";
        lblStatus.Text = "Recording saved.";
    }

    private void Form_FormClosing(object sender, FormClosingEventArgs e)
    {
        if (_isRecording)
        {
            StopRecordingAsync().Wait();
        }

        VisioForgeX.DestroySDK();
    }
}
```

### Advanced Audio Capture Settings

The VideoCaptureCoreX class supports various audio capture configurations for different recording scenarios:

```
// Configure high-quality WMA recording
var wmaOutput = new WMAOutput("high_quality.wma");
wmaOutput.Audio.Bitrate = 320;       // Maximum quality bitrate
wmaOutput.Audio.SampleRate = 48000;  // Professional sample rate
wmaOutput.Audio.Channels = 2;        // Stereo

// Configure voice recording (smaller file size)
var voiceOutput = new WMAOutput("voice_memo.wma");
voiceOutput.Audio.Bitrate = 128;     // Good for voice
voiceOutput.Audio.SampleRate = 44100; // Standard sample rate
voiceOutput.Audio.Channels = 1;       // Mono is sufficient for voice

// Check if WMA encoder is available on the system
if (!WMAEncoderSettings.IsAvailable())
{
    Console.WriteLine("WMA encoder is not available on this system.");
    // Consider falling back to MP3 or other format
}
```

## Editing WMA Files Using VideoEditCoreX

The VideoEditCoreX class provides powerful capabilities for editing WMA files and converting audio video content to Windows Media format. This section demonstrates how to edit dotnet WMA files with trimming, merging, and format conversion.

### Core Components for WMA Editing

1. **VideoEditCoreX**: Main engine class for managing audio and video editing operations.
2. **AudioFileSource**: Class for adding audio file sources to the editing timeline.
3. **WMAOutput**: Output format configuration for Windows Media Audio export.
4. **Audio\_Effects**: Collection for applying audio effects during editing.

### Basic WMA File Editing

Here's how to edit WMA files using the VideoEditCoreX class:

```
using System;
using System.IO;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.VideoEdit;
using VisioForge.Core.VideoEditX;

public class WmaEditor
{
    private VideoEditCoreX _videoEdit;

    // Call this method once during application startup or form load
    public async Task InitializeAsync()
    {
        // Initialize the VisioForge SDK
        await VisioForgeX.InitSDKAsync();
    }

    public async Task EditWmaFileAsync(
        string inputPath,
        string outputPath,
        TimeSpan? startTime = null,
        TimeSpan? endTime = null)
    {
        // Create VideoEditCoreX instance
        _videoEdit = new VideoEditCoreX();

        // Set up event handlers
        _videoEdit.OnProgress += VideoEdit_OnProgress;
        _videoEdit.OnStop += VideoEdit_OnStop;
        _videoEdit.OnError += VideoEdit_OnError;

        // Add input WMA file with optional trimming
        var audioFile = new AudioFileSource(
            inputPath,
            startTime,  // Start time for trimming (null for beginning)
            endTime);   // End time for trimming (null for end)

        _videoEdit.Input_AddAudioFile(audioFile, insertTime: null);

        // Configure WMA output format
        var wmaOutput = new WMAOutput(outputPath);
        wmaOutput.Audio.Bitrate = 192;
        wmaOutput.Audio.SampleRate = 48000;
        wmaOutput.Audio.Channels = 2;

        _videoEdit.Output_Format = wmaOutput;

        // Start the editing process
        _videoEdit.Start();

        Console.WriteLine("Editing in progress...");
    }

    private void VideoEdit_OnProgress(object sender, ProgressEventArgs e)
    {
        Console.WriteLine($"Progress: {e.Progress}%");
    }

    private void VideoEdit_OnStop(object sender, StopEventArgs e)
    {
        if (e.Successful)
        {
            Console.WriteLine("Editing completed successfully!");
        }
        else
        {
            Console.WriteLine("Editing stopped with errors.");
        }

        // Cleanup
        _videoEdit?.Dispose();
        _videoEdit = null;
    }

    private void VideoEdit_OnError(object sender, ErrorsEventArgs e)
    {
        Console.WriteLine($"Error: {e.Message}");
    }
}
```

### Merging Multiple WMA Files

The VideoEditCoreX class allows you to merge multiple audio files into a single WMA output:

```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.VideoEdit;
using VisioForge.Core.VideoEditX;

public class WmaMerger
{
    // Call this method once during application startup or form load
    public async Task InitializeAsync()
    {
        // Initialize SDK
        await VisioForgeX.InitSDKAsync();
    }

    public async Task MergeWmaFilesAsync(
        List<string> inputFiles,
        string outputPath)
    {
        var videoEdit = new VideoEditCoreX();

        try
        {
            // Set up progress reporting
            videoEdit.OnProgress += (s, e) =>
                Console.WriteLine($"Merging progress: {e.Progress}%");

            videoEdit.OnError += (s, e) =>
                Console.WriteLine($"Error: {e.Message}");

            // Add each input file sequentially
            foreach (var inputFile in inputFiles)
            {
                var audioFile = new AudioFileSource(inputFile);

                // Adding with null insertTime appends to end of timeline
                videoEdit.Input_AddAudioFile(audioFile, insertTime: null);

                Console.WriteLine($"Added: {inputFile}");
            }

            // Configure output format
            var wmaOutput = new WMAOutput(outputPath);
            wmaOutput.Audio.Bitrate = 192;
            wmaOutput.Audio.SampleRate = 48000;
            wmaOutput.Audio.Channels = 2;

            videoEdit.Output_Format = wmaOutput;

            // Create completion signal
            var completionSource = new TaskCompletionSource<bool>();
            videoEdit.OnStop += (s, e) => completionSource.SetResult(e.Successful);

            // Start merging
            videoEdit.Start();

            // Wait for completion
            bool success = await completionSource.Task;

            if (success)
            {
                Console.WriteLine($"Files merged successfully to: {outputPath}");
            }
            else
            {
                Console.WriteLine("Merge operation failed.");
            }
        }
        finally
        {
            videoEdit.Dispose();
            VisioForgeX.DestroySDK();
        }
    }
}
```

### Trimming WMA Files

Extract a specific portion of a WMA file:

```
// Note: Call VisioForgeX.InitSDKAsync() once during application startup or form load
public async Task TrimWmaFileAsync(
    string inputPath,
    string outputPath,
    TimeSpan startTime,
    TimeSpan endTime)
{
    var videoEdit = new VideoEditCoreX();

    try
    {
        // Add input file with specific start and end times
        var audioFile = new AudioFileSource(
            inputPath,
            startTime,   // e.g., TimeSpan.FromSeconds(10)
            endTime);    // e.g., TimeSpan.FromSeconds(60)

        videoEdit.Input_AddAudioFile(audioFile, insertTime: null);

        // Configure WMA output
        var wmaOutput = new WMAOutput(outputPath);
        wmaOutput.Audio.Bitrate = 192;
        wmaOutput.Audio.SampleRate = 48000;
        wmaOutput.Audio.Channels = 2;

        videoEdit.Output_Format = wmaOutput;

        // Create completion signal
        var completionSource = new TaskCompletionSource<bool>();
        videoEdit.OnStop += (s, e) => completionSource.SetResult(e.Successful);

        // Start trimming
        videoEdit.Start();

        // Wait for completion
        bool success = await completionSource.Task;

        Console.WriteLine(success
            ? "Trim completed successfully!"
            : "Trim operation failed.");
    }
    finally
    {
        videoEdit.Dispose();
    }
}
```

### Converting Video Files to WMA Audio

Extract audio from video files and save as WMA:

```
// Note: Call VisioForgeX.InitSDKAsync() once during application startup or form load
public async Task ExtractAudioToWmaAsync(
    string videoInputPath,
    string wmaOutputPath)
{
    var videoEdit = new VideoEditCoreX();

    try
    {
        // Add video file - audio will be extracted automatically
        var audioFile = new AudioFileSource(videoInputPath);
        videoEdit.Input_AddAudioFile(audioFile, insertTime: null);

        // Configure WMA output for audio extraction
        var wmaOutput = new WMAOutput(wmaOutputPath);
        wmaOutput.Audio.Bitrate = 256;       // Higher quality for music
        wmaOutput.Audio.SampleRate = 48000;
        wmaOutput.Audio.Channels = 2;

        videoEdit.Output_Format = wmaOutput;

        var completionSource = new TaskCompletionSource<bool>();
        videoEdit.OnProgress += (s, e) =>
            Console.WriteLine($"Extraction progress: {e.Progress}%");
        videoEdit.OnStop += (s, e) =>
            completionSource.SetResult(e.Successful);

        videoEdit.Start();

        bool success = await completionSource.Task;

        Console.WriteLine(success
            ? $"Audio extracted to: {wmaOutputPath}"
            : "Audio extraction failed.");
    }
    finally
    {
        videoEdit.Dispose();
    }
}
```

### Applying Audio Effects During WMA Editing

The VideoEditCoreX class supports various audio effects that can be applied during the editing process:

```
using VisioForge.Core.Types.X.AudioEffects;

// Note: Call VisioForgeX.InitSDKAsync() once during application startup or form load
public async Task EditWmaWithEffectsAsync(
    string inputPath,
    string outputPath)
{
    var videoEdit = new VideoEditCoreX();

    try
    {
        // Add input file
        var audioFile = new AudioFileSource(inputPath);
        videoEdit.Input_AddAudioFile(audioFile, insertTime: null);

        // Apply audio effects

        // Volume amplification effect
        var amplifyEffect = new AmplifyAudioEffect(1.5); // 150% volume
        videoEdit.Audio_Effects.Add(amplifyEffect);

        // 10-band equalizer effect
        var eqLevels = new double[]
        {
            3.0,   // 60 Hz
            2.0,   // 170 Hz
            1.0,   // 310 Hz
            0.0,   // 600 Hz
            0.0,   // 1 kHz
            0.0,   // 3 kHz
            1.0,   // 6 kHz
            2.0,   // 12 kHz
            2.0,   // 14 kHz
            3.0    // 16 kHz
        };
        var equalizerEffect = new Equalizer10AudioEffect(eqLevels);
        videoEdit.Audio_Effects.Add(equalizerEffect);

        // Configure WMA output
        var wmaOutput = new WMAOutput(outputPath);
        wmaOutput.Audio.Bitrate = 192;
        wmaOutput.Audio.SampleRate = 48000;
        wmaOutput.Audio.Channels = 2;

        videoEdit.Output_Format = wmaOutput;

        var completionSource = new TaskCompletionSource<bool>();
        videoEdit.OnStop += (s, e) => completionSource.SetResult(e.Successful);

        videoEdit.Start();

        await completionSource.Task;
    }
    finally
    {
        videoEdit.Dispose();
    }
}
```

## WMA Encoder Configuration

The WMAEncoderSettings class provides various configuration options for the Windows Media Audio encoder:

### Available Settings

```
var wmaSettings = new WMAEncoderSettings
{
    // Bitrate in Kbps - supported values: 128, 192, 256, 320
    Bitrate = 192,

    // Sample rate in Hz - supported values: 44100, 48000
    SampleRate = 48000,

    // Number of channels - supported values: 1 (mono), 2 (stereo)
    Channels = 2
};

// Query supported configurations
int[] supportedBitrates = wmaSettings.GetSupportedBitrates();
// Returns: [128, 192, 256, 320]

int[] supportedSampleRates = wmaSettings.GetSupportedSampleRates();
// Returns: [44100, 48000]

int[] supportedChannels = wmaSettings.GetSupportedChannelCounts();
// Returns: [1, 2]
```

### Quality Presets

Here are recommended presets for different use cases:

```
// High-quality music recording
var musicPreset = new WMAEncoderSettings
{
    Bitrate = 320,
    SampleRate = 48000,
    Channels = 2
};

// Voice recording / podcasts
var voicePreset = new WMAEncoderSettings
{
    Bitrate = 128,
    SampleRate = 44100,
    Channels = 1
};

// Balanced quality and file size
var balancedPreset = new WMAEncoderSettings
{
    Bitrate = 192,
    SampleRate = 48000,
    Channels = 2
};
```

## Working with Audio Packets and Buffers

For advanced scenarios, you may need to work directly with audio data packets. The SDK provides mechanisms for accessing raw audio data during capturing and processing.

### Processing Audio Packets

```
// During capture, you can monitor audio levels and packets
_videoCapture.OnAudioVUMeter += (sender, args) =>
{
    // args is VUMeterXEventArgs — channel levels come from MeterData (VUMeterXData)
    var meterData = args.MeterData;
    if (meterData == null || meterData.ChannelsCount == 0) return;

    double leftPeak  = meterData.Peak[0];
    double rightPeak = meterData.ChannelsCount > 1 ? meterData.Peak[1] : leftPeak;

    // Update UI with audio levels
    UpdateVUMeter(leftPeak, rightPeak);
};
```

## Error Handling and Best Practices

### Proper Resource Management

Always ensure proper cleanup of SDK resources:

```
public class WmaProcessor : IDisposable
{
    private VideoCaptureCoreX _videoCapture;
    private bool _disposed = false;

    public async Task InitializeAsync()
    {
        await VisioForgeX.InitSDKAsync();
        _videoCapture = new VideoCaptureCoreX();
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                _videoCapture?.Dispose();
                VisioForgeX.DestroySDK();
            }
            _disposed = true;
        }
    }
}
```

### Error Handling

Implement comprehensive error handling for production applications:

```
try
{
    await _videoCapture.StartAsync();
}
catch (Exception ex)
{
    // Log the error
    Console.WriteLine($"Failed to start recording: {ex.Message}");

    // Clean up resources
    await _videoCapture.DisposeAsync();

    // Notify user or retry
    throw;
}
```

### Checking Encoder Availability

Before creating WMA files, verify the encoder is available:

```
if (!WMAEncoderSettings.IsAvailable())
{
    Console.WriteLine("WMA encoder is not available.");
    Console.WriteLine("Falling back to MP3 format...");

    // Use MP3 as alternative
    var mp3Output = new MP3Output("output.mp3");
    // ... continue with MP3 encoding
}
```

## Cross-Platform Considerations

The WMA format and Windows Media components are primarily designed for Windows systems. When developing cross-platform applications:

- **Windows**: Full WMA support with all encoding options
- **Linux/macOS**: WMA encoding may require additional GStreamer plugins
- **Mobile (Android/iOS)**: Consider using more universal formats like AAC or MP3

For cross-platform audio recording, consider these alternatives:

```
// Check platform and select appropriate format
string outputFormat = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
    ? "output.wma"
    : "output.m4a";  // AAC container for non-Windows

if (outputFormat.EndsWith(".wma"))
{
    var wmaOutput = new WMAOutput(outputFormat);
    _videoCapture.Outputs_Add(wmaOutput, true);
}
else
{
    var m4aOutput = new M4AOutput(outputFormat);
    _videoCapture.Outputs_Add(m4aOutput, true);
}
```

## Sample Applications and Resources

Explore complete sample applications demonstrating WMA recording and editing:

- [Video Capture SDK X Samples](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X)
- [Video Edit SDK X Samples](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Edit%20SDK%20X)

### Additional Documentation

- [Windows Media Audio Encoder Guide](../../audio-encoders/wma/)
- [Windows Media Video Output Guide](../../output-formats/wmv/)
- [Audio Sample Grabber](../../audio-effects/audio-sample-grabber/)
- [API Documentation](https://api.visioforge.org/dotnet/api/index.html)

## Conclusion

This comprehensive guide has demonstrated how to record and edit WMA files using the VisioForge .NET SDKs. You've learned how to record .NET WMA audio, capture dotnet WMA content, and create professional audio applications. The VideoCaptureCoreX class provides powerful capabilities for capturing audio from microphones and other devices, while the VideoEditCoreX class offers flexible options for editing and converting audio content to Windows Media format.

Key takeaways:

- **Record WMA files**: Use VideoCaptureCoreX with WMAOutput for capturing audio from system devices and reserve optimal quality settings for your output
- **Edit WMA files**: Use VideoEditCoreX for trimming, merging, and applying effects to audio records
- **Configuration**: The WMAEncoderSettings class allows fine-tuning of bitrate, sample rate, and channels
- **Cross-platform**: Consider platform-specific requirements when working with Windows Media formats
- **Windows application support**: Create WinForms, WPF, and console applications with ease

Both classes integrate seamlessly with WinForms, WPF, and console applications, making it easy to create powerful audio recording and editing solutions in your .NET applications. The data processing capabilities and library features allow you to build professional-grade audio editor applications.

---END OF PAGE---


## VisioForge .NET SDK General Guides and Documentation
**URL:** https://www.visioforge.com/help/docs/dotnet/general/
**Description:** Comprehensive guides for VisioForge .NET SDKs covering video capture, media playback, editing, encoders, effects, and network streaming.
**Tags:** .NET, Streaming

# VisioForge .Net SDKs: Information, Manuals, and Usage

This section provides essential information, detailed software manuals, and practical usage guides for the suite of VisioForge .Net SDKs. Whether you're working with video capture, media playback, or video editing, find the resources you need below.

- **[MCP Server Usage Guide](mcp-server-usage/)** - Connect your AI coding assistant to the VisioForge MCP Server for instant access to API documentation, deployment guides, and code examples
- **[Using VisioForge in Unity](unity/)** - Import the self-contained Unity package for video playback and RTSP camera streaming in Unity 6 on Windows
- [Code samples](code-samples/)
- [How to send logs?](sendlogs/)

## Guides

- [Video capture to MPEG-TS in VisioForge SDKs](guides/video-capture-to-mpegts/)
- [Record and Edit WMA Files in C# and .NET](guides/wma-recording-editing/)

## SDK Components

Explore the core components of VisioForge .Net SDKs:

### Media Processing & Effects

- **[Video Effects & Processing](video-effects/)**: Enhance your applications with powerful video effects, overlays, and processing capabilities. Learn how to implement professional-grade visual effects, text/image overlays, and custom video processing.
- **[Audio Effects](audio-effects/audio-sample-grabber/)**: Explore options for applying various audio effects and enhancements within your .NET applications.

### Encoding & Formats

- **[Video Encoders](video-encoders/)**: Detailed overview of video encoders (H.264, HEVC, AV1, etc.) - features, performance, and implementation for .NET developers.
- **[Audio Encoders](audio-encoders/)**: Master audio encoding (AAC, FLAC, MP3, Opus) with guidance on optimal settings, performance tips, and best practices.
- **[Output Formats](output-formats/)**: Learn about video and audio container formats (MP4, WebM, AVI, MKV) including examples, codec comparisons, and compatibility.

### Streaming & Connectivity

- **[Network Streaming](network-streaming/)**: Implement RTMP, RTSP, HLS, and NDI streaming in .NET. Includes examples for live broadcasting, hardware acceleration, and platform integration.

---END OF PAGE---


## Using the VisioForge MCP Server for AI-Assisted Development
**URL:** https://www.visioforge.com/help/docs/dotnet/general/mcp-server-usage/
**Description:** Connect your AI coding assistant to the VisioForge MCP Server for instant access to API documentation, deployment guides, code examples, and SDK knowledge.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Streaming, Conversion, IP Camera, RTSP, C#, NuGet
**API:** MediaBlocksPipeline, VideoRendererBlock, RTSPSourceBlock

# Using the VisioForge MCP Server for AI-Assisted Development

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to the VisioForge MCP Server

The VisioForge MCP (Model Context Protocol) Server provides AI-powered coding assistants with direct access to comprehensive VisioForge SDK documentation, deployment guides, code examples, and API references. This enables your AI assistant to provide accurate, context-aware help while you develop with VisioForge SDKs.

### What is Model Context Protocol (MCP)?

Model Context Protocol (MCP) is an open standard developed by Anthropic that allows AI assistants to securely connect to external knowledge sources and tools. Think of it as a bridge between your AI coding assistant (like Claude Code, GitHub Copilot, or VS Code extensions) and specialized documentation servers.

With MCP, your AI assistant can:

- Query real-time API documentation
- Fetch deployment guides for specific platforms
- Retrieve code examples and snippets
- Search through SDK documentation
- Get platform-specific configuration details

## Why Use the VisioForge MCP Server?

When developing with VisioForge SDKs, the MCP server provides several key benefits:

### 1. **Instant API Documentation Access**

Your AI assistant can query the complete VisioForge SDK API, including:

- All classes, methods, properties, and events
- Detailed descriptions and usage notes
- Parameter types and return values
- Code examples and snippets
- Cross-references to related APIs

### 2. **Platform-Specific Deployment Guidance**

Get accurate deployment instructions for:

- **Desktop**: Windows, Linux, macOS
- **Mobile**: Android, iOS, Mac Catalyst
- **Frameworks**: MAUI, Uno, Avalonia, WPF, WinForms, Blazor, Console
- **Scenarios**: RTSP recording, cloud transcoding, HLS streaming

### 3. **Correct NuGet Package References**

The MCP server generates ready-to-paste `.csproj` snippets with:

- Platform-specific NuGet packages
- Correct version numbers
- Conditional package references
- Required project references (like AndroidDependency)

### 4. **Platform-Specific Build Configuration**

Retrieve MSBuild targets and configuration snippets for:

- Mac Catalyst native library copying
- Android permissions (manifest + runtime)
- iOS Info.plist permissions
- Platform-specific build settings

## Prerequisites

Before connecting to the VisioForge MCP Server, ensure you have:

- **An MCP-compatible AI assistant**:
- [Claude Code](https://claude.ai/code) (recommended)
- VS Code with MCP extension
- GitHub Copilot with MCP support
- Other MCP-compatible tools
- **Internet connectivity** to access `https://mcp.visioforge.com`

## Connecting to the MCP Server

### Claude Code (Recommended)

Claude Code has built-in MCP support. Connect with a single command:

```
claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp
```

**Verify the connection:**

```
claude mcp list
```

You should see `visioforge-sdk` in the list of connected servers.

### VS Code with MCP Extension

Add the VisioForge MCP Server to your workspace or user settings:

1. Open VS Code
2. Install the MCP extension (if not already installed)
3. Create or edit `.vscode/mcp.json` in your project:

```
{
  "servers": {
    "visioforge-sdk": {
      "type": "http",
      "url": "https://mcp.visioforge.com/mcp"
    }
  }
}
```

### Project-Level Configuration (Any MCP Client)

For project-specific MCP configuration, create `.mcp.json` at your repository root:

```
{
  "servers": {
    "visioforge-sdk": {
      "type": "http",
      "url": "https://mcp.visioforge.com/mcp",
      "description": "VisioForge SDK documentation and deployment guides"
    }
  }
}
```

## Available MCP Tools

The VisioForge MCP Server exposes 14 specialized tools your AI assistant can use. Names and descriptions match the live `tools/list` response from `https://mcp.visioforge.com/mcp` exactly.

### 1. **Media Blocks Tools**

#### `list_media_blocks`

List available VisioForge media blocks, optionally filtered by category. Media blocks are the building blocks of media processing pipelines. Categories include: Sources, Sinks, VideoEncoders, AudioEncoders, VideoDecoders, VideoProcessing, AudioProcessing, AudioRendering, VideoRendering, Demuxers, Parsers, OpenGL, OpenCV, Nvidia, Decklink, AWS, RTSPServer, Bridge, Special, Outputs.

**Example queries:** - "List all video encoder blocks" - "Show MediaBlocks sources" - "What blocks are in the OpenCV category?"

#### `get_media_block_info`

Get detailed information about a specific media block including its properties, methods, events, input/output pads, constructor parameters, and documentation. Use this to understand how to configure and use a specific media block in a pipeline.

**Example queries:** - "Get info on RTSPSourceBlock" - "Show pads and properties of H264EncoderBlock" - "What constructor parameters does VideoRendererBlock take?"

#### `get_pipeline_template`

Get a media block pipeline template for a specific use case. Returns the list of required blocks and how to connect them, along with C# code to build the pipeline.

**Example queries:** - "Pipeline template for RTSP-to-MP4 recording" - "Template for screen capture with audio" - "Pipeline for HLS streaming"

### 2. **SDK Class & API Tools**

#### `list_sdk_classes`

List core VisioForge SDK classes. These are the main entry-point classes for building media applications: VideoCaptureCoreX (video capture/recording), VideoEditCoreX (video editing), MediaPlayerCoreX (media playback), MediaInfoReaderX (media analysis), SimplePlayerCoreX (simple playback), and more.

**Example queries:** - "List all core SDK classes" - "Show top-level entry-point classes"

#### `get_class_info`

Get detailed information about any VisioForge SDK class, including its full list of properties, methods, events, constructors, base class, interfaces, and documentation. Works for both core SDK classes and media blocks.

**Example queries:** - "Show documentation for MediaBlocksPipeline class" - "Get details about VideoCaptureCoreX" - "What events does MediaPlayerCoreX expose?"

#### `get_method_signature`

Get the detailed signature and documentation for a specific method on a class. Useful when you need to understand a method's parameters, return type, and behavior.

**Example queries:** - "Signature of StartAsync on MediaBlocksPipeline" - "What parameters does Connect take?"

#### `search_api`

Search across the entire VisioForge SDK API — class names, method names, property names, event names, and their documentation text. Returns ranked results. Use this when you don't know the exact class name, or to find all classes related to a concept (e.g., "RTSP streaming", "video overlay", "audio capture").

**Example queries:** - "Search for video capture classes" - "Find methods related to RTSP streaming" - "Show all MediaBlocks audio encoders"

#### `get_enum_values`

Get all values of a VisioForge SDK enum type with descriptions. Useful for understanding available options for configuration properties (e.g., MediaBlockType, video codecs, audio formats, pixel formats).

**Example queries:** - "List values of VideoCodec enum" - "Show MediaBlockType enum values"

#### `list_namespaces`

Browse VisioForge SDK namespaces hierarchically. Shows child namespaces and classes within a given namespace. Start with `VisioForge.Core` or leave empty to see top-level namespaces.

**Example queries:** - "List top-level namespaces" - "Show classes in VisioForge.Core.MediaBlocks"

#### `get_code_example`

Get a code example for a common VisioForge SDK scenario. Returns complete, working C# code snippets that demonstrate how to use the SDK for tasks like video capture, RTSP streaming, media playback, and more.

**Example queries:** - "Code example for RTSP camera capture" - "Show MP4 recording snippet" - "Example of applying video effects"

### 3. **Deployment Guide Tools**

#### `list_deployment_guides`

List available deployment guides for VisioForge SDK. Filter by platform, project type, SDK type, or scenario. Returns a list of guides with titles, summaries, and tags.

**Example queries:** - "List Android deployment guides" - "Show MAUI deployment guides" - "Find deployment guides for Linux"

#### `get_deployment_guide`

Get the complete deployment guide for a specific scenario. Returns detailed instructions, code snippets, NuGet packages, and platform-specific notes.

**Example queries:** - "Get the Android deployment guide" - "Show deployment steps for Uno platform" - "How to deploy on macOS"

#### `get_nuget_packages_snippet`

Get .csproj snippet with required NuGet packages for a specific deployment scenario. Returns XML snippet ready to copy-paste into your project file.

**Example queries:** - "Generate NuGet packages for Android MAUI project" - "Get package references for Avalonia on Windows" - "Show required packages for iOS"

#### `get_platform_specific_config`

Get platform-specific file copying/build configuration code. Returns MSBuild targets or post-build scripts for special deployment requirements.

**Example queries:** - "Show Mac Catalyst file copying target" - "Get Android manifest permissions" - "iOS Info.plist permission keys"

## Usage Examples

### Example 1: Setting Up an Android MAUI Project

**You ask your AI assistant:**

> "I'm creating a video capture app with MAUI for Android. What NuGet packages do I need?"

**Your AI assistant uses the MCP server to:** 1. Call `get_nuget_packages_snippet` with `platform: Android, projectType: MAUI, sdkType: VideoCapture` 2. Retrieve the correct package references 3. Provide you with ready-to-paste XML:

```
<ItemGroup>
  <PackageReference Include="VisioForge.DotNet.VideoCapture" Version="2026.8.16" />
  <PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.7.27" />
  <ProjectReference Include="..\AndroidDependency\VisioForge.Core.Android.X10.csproj" />
</ItemGroup>
```

`sdkType` is required and has no default. Name the SDK you licensed: `VideoCapture` for camera, screen and IP-camera recording, `MediaPlayer` for playback, `VideoEdit` for timeline editing. `MediaBlocks` is the pipeline layer underneath them — pick it only for a custom source-to-encoder graph.

### Example 2: Finding How to Use RTSP Streaming

**You ask your AI assistant:**

> "Show me how to capture from an RTSP camera using Media Blocks SDK"

**Your AI assistant uses the MCP server to:** 1. Call `search_api` with query "RTSP camera capture" 2. Identify `RTSPSourceBlock` class 3. Call `get_code_example` for RTSP scenarios 4. Provide you with working code:

```
var pipeline = new MediaBlocksPipeline();

// RTSPSourceBlock takes RTSPSourceSettings (not a Uri directly).
// Build the settings via the async factory — the ctor is private.
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://camera.example.com:554/stream"),
    login: null,
    password: null,
    audioEnabled: false);

var rtspSource = new RTSPSourceBlock(rtspSettings);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(rtspSource.VideoOutput, videoRenderer.Input);
await pipeline.StartAsync();
```

### Example 3: Mac Catalyst Deployment

**You ask your AI assistant:**

> "How do I deploy my Uno app to Mac Catalyst?"

**Your AI assistant uses the MCP server to:** 1. Call `get_deployment_guide` with `guideId: "uno-platform"` 2. Extract the Mac Catalyst section 3. Call `get_platform_specific_config` with `platform: "maccatalyst"` 4. Provide you with: - Build commands - MSBuild target for file copying - Deployment steps

### Example 4: Understanding a Specific API

**You ask your AI assistant:**

> "What parameters does UniversalSourceBlock accept?"

**Your AI assistant uses the MCP server to:** 1. Call `search_api` with query "UniversalSourceBlock" 2. Find the class in the results 3. Call `get_class_info` with the class name 4. Parse the documentation and explain: - Constructor parameters - Supported file formats - Configuration options - Usage examples

## Best Practices

### 1. **Be Specific in Your Questions**

Instead of generic questions, provide context:

- ❌ "How do I capture video?"
- ✅ "How do I capture video from an RTSP camera using Media Blocks SDK on Android?"

### 2. **Specify Your Platform and Framework**

Always mention your target platform and UI framework:

- "I'm using MAUI on iOS..."
- "My Avalonia app targets Windows and Linux..."
- "For my Uno Platform app on Android..."

### 3. **Ask About Deployment Early**

Before diving deep into code, ask about deployment requirements:

- "What NuGet packages do I need for Mac Catalyst?"
- "Show me the deployment guide for Avalonia on Linux"
- "What permissions are required for iOS camera access?"

### 4. **Request Code Examples**

Don't hesitate to ask for working code:

- "Show me a complete example of..."
- "Generate code for..."
- "Example implementation of..."

## Troubleshooting

### Connection Issues

If your AI assistant can't connect to the MCP server:

1. **Check your internet connection** - The MCP server is hosted at `https://mcp.visioforge.com`
2. **Verify the URL** - Ensure you're using the correct endpoint: `https://mcp.visioforge.com/mcp`
3. **Restart your AI assistant** - Sometimes a restart resolves connection issues
4. **Check MCP client logs** - Look for connection errors in your client's logs

### Incorrect or Outdated Information

The MCP server is updated regularly, but if you notice incorrect information:

1. **Check the SDK version** - Ensure you're using the latest SDK version
2. **Verify package versions** - Compare with [NuGet.org](https://www.nuget.org/packages?q=VisioForge)
3. **Report issues** - Contact our support team (see Additional Resources below)

### AI Assistant Not Using MCP Server

If your AI assistant doesn't seem to use the MCP server:

1. **Explicitly mention it** - Say "Use the VisioForge MCP server to find..."
2. **Verify connection** - Run `claude mcp list` or check your MCP configuration
3. **Restart the session** - Start a new conversation with your AI assistant

## Security and Privacy

### Data Transmission

- All communication with the MCP server uses **HTTPS encryption**
- The server is read-only - it only provides documentation, no data collection
- No personal information or code is sent to the server
- API queries are processed in real-time and not stored

### Authentication

- The VisioForge MCP Server is **publicly accessible** - no authentication required
- Your AI assistant connects directly to `https://mcp.visioforge.com/mcp`
- No API keys or credentials needed

## Technical Details

### MCP Server Endpoint

```
https://mcp.visioforge.com/mcp
```

### Server Capabilities

- **Protocol**: MCP (Model Context Protocol)
- **Transport**: HTTP/HTTPS
- **Tools**: 14 specialized documentation and deployment tools
- **API Coverage**: Complete VisioForge .NET SDK API (all classes, methods, properties)
- **Deployment Guides**: 15+ platform and project type guides
- **Code Examples**: Hundreds of working code snippets
- **Update Frequency**: Updated with each SDK release

### Server Architecture

The MCP server features:

- **High availability**: 99.9% uptime
- **Fast response times**: < 200ms average
- **SSL/TLS encryption**: All traffic encrypted
- **Automatic updates**: Synchronized with SDK releases
- **Rate limiting**: Fair use policy (no hard limits for developers)

## Additional Resources

### Documentation

- [VisioForge SDK Documentation](https://www.visioforge.com/help/)
- [MCP Protocol Specification](https://modelcontextprotocol.io/specification/2025-11-25)
- [Claude Code Documentation](https://claude.ai/code)

### Support & Community

Need help? Get in touch:

- **[Support Portal](https://support.visioforge.com/)** - Technical support and issue reporting
- **[Discord Community](https://discord.com/invite/yvXUG56WCH)** - Chat with developers and get quick answers
- **[GitHub Samples](https://github.com/visioforge/.Net-SDK-s-samples)** - Complete example projects
- **Email:** [support@visioforge.com](mailto:support@visioforge.com)

### Related Guides

- [Installation Guide](../../install/)
- [System Requirements](../../system-requirements/)
- [Deployment Guides](../../deployment-x/)
- [API Reference](https://api.visioforge.org/dotnet/api/index.html)

## Conclusion

The VisioForge MCP Server transforms AI-assisted development by providing your coding assistant with direct access to comprehensive, up-to-date SDK documentation. Whether you're building a video capture app on Android, a media player on Windows, or a cross-platform editing tool with Avalonia, the MCP server ensures your AI assistant has the knowledge to help you succeed.

Connect today and experience the future of AI-powered SDK development!

---END OF PAGE---


## RTSP Reconnect & Fallback Switch in C# .NET — All SDKs
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-sources/reconnection-and-fallback/
**Description:** Handle IP camera disconnects in C# / .NET with reconnect events, DisconnectEventInterval, and FallbackSwitch (image/text/media) across all VisioForge SDKs.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, .NET, DirectShow, MediaPlayerCoreX, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Playback, Streaming, Decoding, IP Camera, RTSP, ONVIF, MP4, C#
**API:** FallbackSwitchSettings, RTSPSourceSettings, MediaPlayerCore, VideoCaptureCoreX, MediaPlayerCoreX

# RTSP Reconnection and Fallback Switch in C# / .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Cross-platform support

Reconnection events work on every SDK. The declarative `FallbackSwitch` is GStreamer-backed and therefore runs on **Windows, macOS, Linux, Android, and iOS** in the modern `X` engines and Media Blocks — it's not available on classic DirectShow-only engines. See the [platform support matrix](../../../platform-matrix/) and the [Linux deployment guide](../../../deployment-x/Ubuntu/).

IP cameras drop connections — network blips, power cycles, router reboots, keyframe starvation. VisioForge SDKs give you two ways to handle it:

- **Reactive** — your code subscribes to a disconnect event, then stops and restarts the source.
- **Declarative** — you configure a `FallbackSwitch` on the source, the pipeline swaps in a placeholder image / text card / alternate stream automatically, and your code never sees the hiccup.

Pick based on which SDK you're using and the UX you want. This guide covers both approaches across every SDK in the family.

## Which approach is available where

| SDK | Reactive (detect + restart) | Declarative (FallbackSwitch) |
| --- | --- | --- |
| VideoCaptureCore (classic, Windows) | ✅ `OnNetworkSourceDisconnect` + `DisconnectEventInterval` | ⛔ |
| MediaPlayerCore (classic, Windows) | ✅ `OnNetworkSourceStop` (FFMPEG) / `OnError` | ⛔ |
| VideoCaptureCoreX (cross-platform) | ✅ pipeline `OnNetworkSourceDisconnect` / `OnError` | ✅ via `RTSPSourceSettings.FallbackSwitch` |
| MediaPlayerCoreX (cross-platform) | ✅ pipeline `OnNetworkSourceDisconnect` / `OnError` | ✅ |
| Media Blocks SDK | ✅ pipeline event | ✅ `FallbackSwitchSourceBlock` |

Rule of thumb: on the classic Windows engines you have reactive only. On any modern (cross-platform) engine, prefer declarative for the UX, add reactive on top for telemetry.

## Reactive — VideoCaptureCore (classic)

`IPCameraSourceSettings.DisconnectEventInterval` defines how long the SDK waits without incoming frames before firing the disconnect event. Default is 10 seconds; drop it to 3–5 seconds for surveillance.

```
using VisioForge.Core.VideoCapture;
using VisioForge.Core.Types.VideoCapture;

videoCapture1.IP_Camera_Source = new IPCameraSourceSettings
{
    URL = new Uri("rtsp://192.168.1.100:554/stream1"),
    Login = "admin",
    Password = "admin123",
    Type = IPSourceEngine.Auto_LAV,
    DisconnectEventInterval = TimeSpan.FromSeconds(5)
};

videoCapture1.OnNetworkSourceDisconnect += async (s, e) =>
{
    // Exponential backoff: 1s, 2s, 4s, 8s... capped at 30s.
    int attempt = 0;
    int delayMs = 1000;
    while (attempt < 10)
    {
        await videoCapture1.StopAsync();
        await Task.Delay(delayMs);
        if (await videoCapture1.StartAsync()) break;
        delayMs = Math.Min(delayMs * 2, 30_000);
        attempt++;
    }
};

videoCapture1.Mode = VideoCaptureMode.IPPreview;
await videoCapture1.StartAsync();
```

`OnNetworkSourceDisconnect` fires from a timer thread — marshal to the UI thread (`Invoke` / `Dispatcher.Invoke`) before touching controls.

## Reactive — MediaPlayerCore (classic)

Classic `MediaPlayerCore` exposes `OnNetworkSourceStop` on the FFMPEG engine; for other engines and any generic failure, subscribe `OnError`.

```
using VisioForge.Core.MediaPlayer;

mediaPlayer1.OnNetworkSourceStop += async (s, e) =>
{
    await mediaPlayer1.StopAsync();
    await Task.Delay(2000);
    await mediaPlayer1.StartAsync();
};

mediaPlayer1.OnError += (s, e) =>
{
    // Log but don't teardown — let the retry loop above handle real drops.
    Debug.WriteLine($"Player error: {e.Message}");
};
```

## Reactive — Media Blocks pipelines

`MediaBlocksPipeline` exposes `OnNetworkSourceDisconnect` with rich `NetworkSourceDisconnectEventArgs` — useful when multiple RTSP sources share one app and you need to know *which* one dropped.

```
using VisioForge.Core.Types.Events;

pipeline.OnNetworkSourceDisconnect += (s, e) =>
{
    // e.SourceElementName — the GStreamer element that faulted
    // e.ErrorMessage       — short description
    // e.DebugInfo          — GStreamer debug output (may be null)
    // e.Uri                — the failing RTSP URL (may be null)
    // e.Timestamp          — when the SDK detected the failure
    Log($"[{e.Timestamp:HH:mm:ss}] {e.SourceElementName} dropped: {e.ErrorMessage}");
};

pipeline.OnError += (s, e) =>
{
    Log($"Pipeline error: {e.Message}");
};
```

## Reactive — X engines (VideoCaptureCoreX / MediaPlayerCoreX)

`VideoCaptureCoreX` and `MediaPlayerCoreX` do **not** publicly expose their internal `MediaBlocksPipeline`. To react to disconnects on these engines:

1. Subscribe to `OnError` on the engine — fires for all pipeline-level errors including lost RTSP sources.
2. Use the declarative `FallbackSwitch` (below) to keep the UI alive during transient drops.
3. If you need the granular `NetworkSourceDisconnectEventArgs` per-source, build the capture pipeline directly with `MediaBlocksPipeline` + `RTSPSourceBlock` and use the Media Blocks pattern above.

```
videoCaptureCoreX.OnError += (s, e) =>
{
    // e.Message carries the engine-level error; for RTSP drops the text includes
    // the source element name. Pair this handler with a retry loop or FallbackSwitch.
    Log($"VideoCaptureCoreX error: {e.Message}");
};
```

## Declarative — FallbackSwitch overview

`FallbackSwitch` wraps a live source with automatic failover. When the main source stops producing frames for longer than `TimeoutMs`, the pipeline switches to a pre-configured fallback (text, image, or alternate media) and keeps your `VideoView` rendering. When the main source recovers, the pipeline switches back.

### The `FallbackSwitchSettings` container

```
public class FallbackSwitchSettings
{
    public bool Enabled { get; set; } = false;
    public FallbackSwitchSettingsBase Fallback { get; set; }
    public bool EnableVideo { get; set; } = true;
    public bool EnableAudio { get; set; } = true;
    public int MinLatencyMs { get; set; } = 0;
    public string FallbackVideoCaps { get; set; }   // e.g. "video/x-raw,width=1920,height=1080"
    public string FallbackAudioCaps { get; set; }   // e.g. "audio/x-raw,rate=48000,channels=2"
}
```

### Base tunables (shared by all fallback types)

```
public abstract class FallbackSwitchSettingsBase
{
    public int  TimeoutMs        { get; set; } = 5000;   // silence before fallback kicks in
    public int  RestartTimeoutMs { get; set; } = 5000;   // wait between main-source restart attempts
    public int  RetryTimeoutMs   { get; set; } = 60000;  // give-up window after repeated failures
    public bool ImmediateFallback{ get; set; } = false;  // show fallback from the first frame gap
    public bool RestartOnEos     { get; set; } = false;  // treat EOS as a failure (for loops)
    public bool ManualUnblock    { get; set; } = false;  // require app to call Unblock() on recovery
}
```

### Three fallback types

1. **`StaticTextFallbackSettings`** — render a "Camera offline" text card.
2. **`StaticImageFallbackSettings`** — show a brand logo, last snapshot, or "reconnecting" slate.
3. **`MediaBlockFallbackSettings`** — play an alternate live stream or a looping file.

## Fallback — static text

```
using SkiaSharp;
using VisioForge.Core.Types.X.Sources;

var fallback = new FallbackSwitchSettings
{
    Enabled = true,
    Fallback = new StaticTextFallbackSettings
    {
        Text            = "Camera offline — reconnecting...",
        FontFamily      = "Arial",
        FontSize        = 32f,
        TextColor       = SKColors.White,
        BackgroundColor = SKColors.Black,
        Position        = new SKPoint(0.5f, 0.5f),   // centre
        TimeoutMs       = 3000,
        RestartTimeoutMs= 5000,
    },
};
```

## Fallback — static image

```
var fallback = new FallbackSwitchSettings
{
    Enabled = true,
    Fallback = new StaticImageFallbackSettings
    {
        ImagePath           = @"C:\assets\camera-offline.png",
        ScaleToFit          = true,
        MaintainAspectRatio = true,
        BackgroundColor     = SKColors.Black,
        TimeoutMs           = 3000,
    },
};
```

## Fallback — alternate media source

```
var fallback = new FallbackSwitchSettings
{
    Enabled = true,
    Fallback = new MediaBlockFallbackSettings
    {
        FallbackUri      = "file:///C:/assets/standby-loop.mp4",
        IsLive           = false,
        RestartOnEos     = true,      // restart the loop when the file ends
        TimeoutMs        = 3000,
    },
};
```

`FallbackUri` accepts any URI GStreamer can read — `file://`, another `rtsp://`, HLS, HTTP. `CustomPipeline` lets you inject a bespoke GStreamer launch line for advanced scenarios (e.g. `videotestsrc pattern=snow`).

## Using FallbackSwitch — high-level (`RTSPSourceSettings.FallbackSwitch`)

The simplest path: attach the settings object directly to `RTSPSourceSettings` and pass it to `VideoCaptureCoreX` as usual — the engine wraps the source with a fallback switch automatically. No extra pipeline plumbing.

> In `MediaPlayerCoreX` and the Media Blocks SDK this property is **not** applied by a bare source block (`RTSPSourceBlock` logs a warning if you enable it there) — use the low-level `FallbackSwitchSourceBlock` shown in the next section instead.

```
var rtsp = await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.100:554/stream1"),
    "admin", "admin123", audioEnabled: false);

rtsp.LowLatencyMode = true;
rtsp.FallbackSwitch = new FallbackSwitchSettings
{
    Enabled = true,
    Fallback = new StaticImageFallbackSettings
    {
        ImagePath = "offline.png",
        TimeoutMs = 3000,
    },
};

_videoCapture.Video_Source = rtsp;
await _videoCapture.StartAsync();
```

## Using FallbackSwitch — low-level (`FallbackSwitchSourceBlock`)

In the Media Blocks SDK you wire the fallback directly at the pipeline level via `FallbackSwitchSourceBlock`. This works with *any* source — RTSP, HTTP MJPEG, file, device — not just RTSP.

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;

var fallbackSwitch = new FallbackSwitchSourceBlock(
    mainSourceSettings: rtspSettings,                          // IVideoSourceSettings
    fallbackSettings:   new FallbackSwitchSettings
    {
        Enabled = true,
        Fallback = new StaticTextFallbackSettings { Text = "OFFLINE" },
    });

// Telemetry — works alongside the declarative UI
pipeline.OnNetworkSourceDisconnect += (s, e) =>
    metrics.RecordDisconnect(e.SourceElementName, e.Uri, e.Timestamp);

// FallbackSwitchSourceBlock exposes separate VideoOutput / AudioOutput pads — no single Output.
pipeline.Connect(fallbackSwitch.VideoOutput, renderer.Input);
await pipeline.StartAsync();

// Inspect runtime state:
string status = fallbackSwitch.GetStatus();
var stats = fallbackSwitch.GetStatistics();

// If ManualUnblock is set, call Unblock() when you want playback to resume the main source.
// fallbackSwitch.Unblock();
```

## Common patterns

**Exponential backoff** — in the reactive loop, double the delay on each failed reconnect, cap at 30 s. Stops you from hammering a dead camera's ARP cache.

**Declarative UX + reactive telemetry** — let `FallbackSwitch` keep the screen alive, and use `pipeline.OnNetworkSourceDisconnect` to feed your monitoring dashboard / Slack alert / NVR log. Neither approach precludes the other.

**Multi-camera wall** — never tear down the whole grid on one fault. See the [multi-camera RTSP grid guide](../../../mediablocks/Guides/multi-camera-rtsp-grid/) for the one-pipeline-per-camera pattern; wrap each camera's source with a `FallbackSwitchSourceBlock` (in `VideoCaptureCoreX`, setting `FallbackSwitch` on the source settings is enough).

**Cross-platform note** — `FallbackSwitch` depends on the GStreamer `fallbackswitch` element, which ships with the X redist. Classic Windows-only `VideoCaptureCore` / `MediaPlayerCore` don't have it — use the reactive approach there.

## Troubleshooting

**Fallback never activates** — `Enabled = true`? `TimeoutMs` lower than the gap you want to catch? First few frames need to succeed before the timeout starts counting — a camera that fails on first handshake is a pipeline-start error, not a timeout.

**Fallback activates but never leaves** — the main source isn't recovering. Check `RestartTimeoutMs` (too high delays the next retry) and `RetryTimeoutMs` (after this window the block stops retrying). With `ManualUnblock = true` you must call `fallbackSwitch.Unblock()` yourself.

**Image fallback shows black** — codec caps mismatch between the main pipeline and the fallback decoder. Set `FallbackVideoCaps` explicitly, e.g. `"video/x-raw,width=1920,height=1080,format=RGB"`, matching the renderer's expected format.

**Text fallback — wrong font / position** — `FontFamily` must exist on the target platform (Arial is on Windows and macOS; prefer `DejaVuSans` on Linux). `Position` is 0.0–1.0 fractions of the video frame.

**`OnNetworkSourceDisconnect` fires repeatedly** — the source block is retrying and failing in quick succession. Raise `RestartTimeoutMs` to 10–15 s on a known-flaky network, or wrap logging with a debounce.

**UI thread exceptions** — `OnNetworkSourceDisconnect` fires from the GStreamer bus thread. Use `Dispatcher.Invoke` (WPF) / `Control.Invoke` (WinForms) / `MainThread.BeginInvokeOnMainThread` (MAUI) before touching controls.

## Related Documentation

- [RTSP protocol deep-dive](../../network-streaming/rtsp/) — how RTSP works, transport options, and streaming architecture
- [RTSP camera source configuration](../../../videocapture/video-sources/ip-cameras/rtsp/) — `IPCameraSourceSettings` / `RTSPSourceSettings` reference
- [ONVIF IP camera integration](../../../videocapture/video-sources/ip-cameras/onvif/) — discovery + PTZ; pair ONVIF re-discovery with FallbackSwitch for hard-to-reach cameras
- [Media Blocks RTSP player](../../../mediablocks/Guides/rtsp-player-csharp/) — single-camera pipeline
- [Multi-camera RTSP grid (NVR wall)](../../../mediablocks/Guides/multi-camera-rtsp-grid/) — 4×4 wall with per-cell fallback
- [Save RTSP stream without re-encoding](../../../mediablocks/Guides/rtsp-save-original-stream/) — archive alongside live preview
- [RTSP server output](../../../mediablocks/RTSPServer/) — server-side resilience for your own stream
- [Platform support matrix](../../../platform-matrix/) — codec and hardware-acceleration details across platforms

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page for code samples including RTSP preview, record, and MultiView demos.

---END OF PAGE---


## Adobe Flash Media Server Video Streaming in .NET SDK
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/adobe-flash/
**Description:** Stream video to Adobe Flash Media Server in .NET with real-time effects, quality settings, and device switching for professional streaming.
**Tags:** Video Capture SDK, Video Edit SDK, .NET, Windows, Streaming, Encoding

# Streaming to Adobe Flash Media Server: Advanced Implementation Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

## Introduction

Adobe Flash Media Server (FMS) remains a powerful solution for streaming video content across various platforms. This guide demonstrates how to implement high-quality video streaming to Adobe Flash Media Server using VisioForge's .NET SDKs. The integration supports real-time video effects, quality adjustment, and seamless device switching during streaming sessions.

## Prerequisites

Before implementing the streaming functionality, ensure you have:

- VisioForge Video Capture SDK .NET or Video Edit SDK .NET installed
- Adobe Flash Media Server (or a compatible service like Wowza with RTMP support)
- Adobe Flash Media Live Encoder (FMLE)
- .NET Framework 4.7.2 or later
- Visual Studio 2022 or newer
- Basic understanding of C# programming

## Demo Application Walkthrough

The demo application provided with VisioForge SDKs offers a straightforward way to test streaming functionality. Here's a detailed walkthrough:

1. Start the Main Demo application
2. Navigate to the "Network Streaming" tab
3. Enable streaming by selecting the "Enabled" checkbox
4. Select the "External" radio button for external encoder compatibility
5. Start preview or capture to initialize the video stream
6. Open Adobe Flash Media Live Encoder
7. Configure FMLE to use "VisioForge Network Source" as the video source
8. Configure video parameters:
9. Resolution (e.g., 1280x720, 1920x1080)
10. Frame rate (typically 25-30 fps for smooth streaming)
11. Keyframe interval (recommend 2 seconds)
12. Video quality settings
13. Select "VisioForge Network Source Audio" as the audio source
14. Configure your connection to Adobe Flash Media Server
15. Press Start to initiate streaming

The video from the SDK is now being streamed to your FMS instance. You can apply real-time effects, adjust settings, or even stop the SDK to switch input devices without terminating the streaming session on the server side.

## Implementation in Custom Applications

### Required Components

To implement this functionality in your custom application, you'll need:

- SDK redistributables (available in the SDK installation package)
- References to the VisioForge SDK assemblies
- Proper firewall and network configurations to allow streaming

## Required Redistributables

Ensure the following components are included with your application:

- VisioForge SDK redistributable packages
- Microsoft Visual C++ Runtime (appropriate version for your SDK)
- .NET Framework runtime (if not using self-contained deployment)

## Conclusion

Streaming to Adobe Flash Media Server using VisioForge's Video Capture or Edit SDKs offers a flexible and powerful solution for implementing high-quality video streaming in .NET applications. The implementation supports real-time effects, quality adjustments, and seamless device switching, making it suitable for a wide range of streaming applications.

By following this guide, developers can implement robust streaming solutions that leverage the powerful features of both the VisioForge SDKs and Adobe's streaming platform.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples and example projects.

---END OF PAGE---


## Streaming Video and Audio to Amazon S3 in .NET SDK
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/aws-s3/
**Description:** Implement AWS S3 video and audio streaming in .NET with configuration, encoding settings, error handling, and best practices for media output.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, C#
**API:** AWSS3Output, AWSS3SinkSettings, IVideoEncoder, IAudioEncoder, IMediaBlockSettings

# AWS S3 Output

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The AWS S3 Output functionality in VisioForge SDKs enables direct video and audio output streaming to Amazon S3 storage. This guide will walk you through setting up and using AWS S3 output in your applications.

## Overview

The `AWSS3Output` class is a specialized output handler within the VisioForge SDKs that facilitates video and audio output streaming to Amazon Web Services (AWS) S3 storage. This class implements multiple interfaces to support both video editing (`IVideoEditXBaseOutput`) and video capture (`IVideoCaptureXBaseOutput`) scenarios, along with processing capabilities for both video and audio content.

## Class Implementation

```
public class AWSS3Output : IVideoEditXBaseOutput, IVideoCaptureXBaseOutput, IOutputVideoProcessor, IOutputAudioProcessor
```

## Key Features

The `AWSS3Output` class provides a comprehensive solution for streaming media content to AWS S3 by managing:

- Video encoding configuration
- Audio encoding configuration
- Custom media processing
- AWS S3-specific settings

## Properties

### Video Encoder Settings

```
public IVideoEncoder Video { get; set; }
```

Controls the video encoding process. The selected video encoder must be compatible with the configured sink settings. This property allows you to specify compression methods, quality settings, and other video-specific parameters.

### Audio Encoder Settings

```
public IAudioEncoder Audio { get; set; }
```

Manages audio encoding configuration. Like the video encoder, the audio encoder must be compatible with the sink settings. This property enables control over audio quality, compression, and format settings.

### Sink Settings

```
public IMediaBlockSettings Sink { get; set; }
```

Defines the output destination configuration. In this context, it contains AWS S3-specific settings for the media output stream.

### Custom Processing Blocks

```
public MediaBlock CustomVideoProcessor { get; set; }
```

```
public MediaBlock CustomAudioProcessor { get; set; }
```

Allow for additional processing of video and audio streams before they are encoded and uploaded to S3. These blocks can be used for implementing custom filters, transformations, or analysis of the media content.

### AWS S3 Configuration

```
public AWSS3SinkSettings Settings { get; set; }
```

Contains all AWS S3-specific configuration options, including:

- Access credentials (Access Key, Secret Access Key)
- Bucket and object key information
- Region configuration
- Upload behavior settings
- Error handling preferences

## Constructor

```
public AWSS3Output(AWSS3SinkSettings settings,
                   IVideoEncoder videoEnc,
                   IAudioEncoder audioEnc,
                   IMediaBlockSettings sink)
```

Creates a new instance of the `AWSS3Output` class with the specified configuration:

- `settings`: AWS S3-specific configuration
- `videoEnc`: Video encoder settings
- `audioEnc`: Audio encoder settings
- `sink`: Media sink configuration

## Methods

### File Management

```
public string GetFilename()
```

```
public void SetFilename(string filename)
```

These methods manage the URI of the S3 object:

- `GetFilename()`: Returns the current S3 URI
- `SetFilename(string filename)`: Sets the S3 URI for the output

### Encoder Support

All encoders are supported. Be sure that encoder settings are compatible with the sink settings.

## Usage Example

```
// Create AWS S3 sink settings
var s3Settings = new AWSS3SinkSettings
{
    AccessKey = "your-access-key",
    SecretAccessKey = "your-secret-key",
    Bucket = "your-bucket-name",
    Key = "output-file-key",
    Region = "us-west-1"
};

// Configure encoders
IVideoEncoder videoEncoder = /* your video encoder configuration */;
IAudioEncoder audioEncoder = /* your audio encoder configuration */;
IMediaBlockSettings sinkSettings = /* your sink settings */;

// Create the AWS S3 output
var s3Output = new AWSS3Output(s3Settings, videoEncoder, audioEncoder, sinkSettings);

// Optional: Configure custom processors
s3Output.CustomVideoProcessor = /* your custom video processor */;
s3Output.CustomAudioProcessor = /* your custom audio processor */;
```

## Best Practices

1. Always ensure your AWS credentials are properly secured and not hard-coded in the application.
2. Configure appropriate retry attempts and request timeouts based on your network conditions and file sizes.
3. Select compatible video and audio encoders for your target use case.
4. Consider implementing custom processors for specific requirements like watermarking or audio normalization.

## Error Handling

The class works in conjunction with the `S3SinkOnError` enumeration defined in `AWSS3SinkSettings`, which provides three error handling strategies:

- Abort: Stops the upload process on error
- Complete: Attempts to complete the upload despite errors
- DoNothing: Ignores errors during upload

## Related Components

- AWSS3SinkSettings: Contains detailed configuration for AWS S3 connectivity
- IVideoEncoder: Interface for video encoding configuration
- IAudioEncoder: Interface for audio encoding configuration
- IMediaBlockSettings: Interface for media output configuration

---END OF PAGE---


## Facebook Live Streaming and Encoding in .NET Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/facebook/
**Description:** Stream to Facebook Live in .NET with hardware-accelerated encoding, RTMP broadcasting, and platform-specific optimizations for real-time video.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, Screen Capture, RTMP, H.264, H.265, AAC, C#
**API:** VideoCaptureCoreX, VideoEditCoreX, FacebookLiveOutput, NVENCH264EncoderSettings, QSVH264EncoderSettings

# Facebook Live Streaming with VisioForge SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to Facebook Live Streaming

Facebook Live provides a powerful platform for real-time video broadcasting to global audiences. Whether you're developing applications for live events, video conferencing, gaming streams, or social media integration, VisioForge SDKs offer robust solutions for implementing Facebook Live streaming in your .NET applications.

This comprehensive guide explains how to implement Facebook Live streaming using VisioForge's suite of SDKs, with detailed code examples and configuration options for different platforms and hardware configurations.

## Core Components for Facebook Live Integration

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The cornerstone of Facebook Live integration in VisioForge is the `FacebookLiveOutput` class, which provides a complete implementation of the RTMP protocol required for Facebook streaming. This class implements multiple interfaces to ensure compatibility across various SDK components:

- `IVideoEditXBaseOutput` - For Video Edit SDK integration
- `IVideoCaptureXBaseOutput` - For Video Capture SDK integration
- `IOutputVideoProcessor` - For video stream processing
- `IOutputAudioProcessor` - For audio stream processing

This multi-interface implementation ensures seamless operation across the entire VisioForge ecosystem, allowing developers to maintain consistent code while working with different SDK components.

## Setting Up Facebook Live Streaming

### Prerequisites

Before implementing Facebook Live streaming in your application, you'll need:

1. A Facebook account with permissions to create Live streams
2. A valid Facebook streaming key (obtained from Facebook Live Producer)
3. VisioForge SDK installed in your .NET project
4. Sufficient bandwidth for the chosen quality settings

### Basic Implementation

The most basic implementation of Facebook Live streaming requires just a few lines of code:

```
// Create Facebook Live output with your streaming key
var facebookOutput = new FacebookLiveOutput("your_facebook_streaming_key_here");

// Add to your VideoCaptureCoreX instance
captureCore.Outputs_Add(facebookOutput, true);

// Or set as output format for VideoEditCoreX
editCore.Output_Format = facebookOutput;
```

This minimal setup uses the default encoders, which VisioForge selects based on your platform for optimal performance. For most applications, these defaults provide excellent results with minimal configuration overhead.

## Optimizing Video Encoding for Facebook Live

### Supported Video Encoders

Facebook Live requires H.264 or HEVC encoded video. VisioForge supports multiple encoder implementations to leverage different hardware capabilities:

#### H.264 Encoders

| Encoder | Platform Support | Hardware Acceleration | Performance Characteristics |
| --- | --- | --- | --- |
| OpenH264 | Cross-platform | Software-based | CPU-intensive, universal compatibility |
| NVENC H264 | Windows, Linux | NVIDIA GPU | High performance, low CPU usage |
| QSV H264 | Windows, Linux | Intel GPU | Efficient on Intel systems |
| AMF H264 | Windows | AMD GPU | Optimized for AMD hardware |

#### HEVC Encoders

| Encoder | Platform Support | Hardware Acceleration |
| --- | --- | --- |
| MF HEVC | Windows only | DirectX Video Acceleration |
| NVENC HEVC | Windows, Linux | NVIDIA GPU |
| QSV HEVC | Windows, Linux | Intel GPU |
| AMF H265 | Windows | AMD GPU |

### Selecting the Optimal Video Encoder

VisioForge provides utility methods to check hardware encoder availability before attempting to use them:

```
// Video encoder selection with fallback options
IVideoEncoderSettings GetOptimalVideoEncoder()
{
    // Try NVIDIA GPU acceleration first
    if (NVENCH264EncoderSettings.IsAvailable())
    {
        return new NVENCH264EncoderSettings();
    }

    // Fall back to Intel Quick Sync if available
    if (QSVH264EncoderSettings.IsAvailable())
    {
        return new QSVH264EncoderSettings();
    }

    // Fall back to AMD acceleration
    if (AMFH264EncoderSettings.IsAvailable())
    {
        return new AMFH264EncoderSettings();
    }

    // Finally fall back to software encoding
    return new OpenH264EncoderSettings();
}

// Apply the optimal encoder to Facebook output
facebookOutput.Video = GetOptimalVideoEncoder();
```

This cascading approach ensures your application uses the best available encoder on the user's system, maximizing performance while maintaining compatibility.

## Audio Encoding Configuration

Audio quality significantly impacts the viewer experience. VisioForge supports multiple AAC encoder implementations to ensure optimal audio for Facebook streams:

### Supported Audio Encoders

1. **VO-AAC** - VisioForge's optimized AAC encoder (default for non-Windows platforms)
2. **AVENC AAC** - FFmpeg-based AAC encoder with wide platform support
3. **MF AAC** - Microsoft Media Foundation AAC encoder (Windows-only, hardware-accelerated)

```
// Platform-specific audio encoder selection
IAudioEncoderSettings GetOptimalAudioEncoder()
{
    IAudioEncoderSettings audioEncoder;

    #if NET_WINDOWS
        // Use Media Foundation on Windows
        audioEncoder = new MFAACEncoderSettings();
        // MFAACEncoderSettings exposes Bitrate + SampleRate only; channel count follows the upstream source
        ((MFAACEncoderSettings)audioEncoder).SampleRate = 44100;
    #else
        // Use VisioForge optimized AAC on other platforms
        audioEncoder = new VOAACEncoderSettings();
        // VOAACEncoderSettings exposes Bitrate + SampleRate only; channel count follows the upstream source
        ((VOAACEncoderSettings)audioEncoder).SampleRate = 44100;
    #endif

    return audioEncoder;
}

// Apply the optimal audio encoder
facebookOutput.Audio = GetOptimalAudioEncoder();
```

## Advanced Facebook Live Features

### Custom Media Processing Pipeline

For applications requiring advanced video or audio processing before streaming, VisioForge supports insertion of custom processors:

```
// Add text overlay to video stream
var textOverlay = new TextOverlayBlock(new TextOverlaySettings("Live from VisioForge SDK"));

// Add the video processor to Facebook output
facebookOutput.CustomVideoProcessor = textOverlay;

// Add audio volume boost
var volume = new VolumeBlock();
volume.Level = 1.2; // Boost 20% volume

// Add the audio processor to Facebook output
facebookOutput.CustomAudioProcessor = volume;
```

### Platform-Specific Optimizations

VisioForge automatically applies platform-specific optimizations:

- **Windows**: Leverages Media Foundation for AAC audio and DirectX Video Acceleration
- **macOS**: Uses Apple Media frameworks for hardware-accelerated encoding
- **Linux**: Employs VAAPI and other platform-specific acceleration when available

These optimizations ensure your application achieves maximum performance regardless of the deployment platform.

## Complete Implementation Example

Here's a comprehensive example showing how to set up a complete Facebook Live streaming pipeline with error handling and optimal encoder selection:

```
public FacebookLiveOutput ConfigureFacebookLiveStream(string streamKey, int videoBitrate = 4000000)
{
    // Create the Facebook output with the provided stream key
    var facebookOutput = new FacebookLiveOutput(streamKey);

    try {
        // Configure optimal video encoder with fallback strategy
        if (NVENCH264EncoderSettings.IsAvailable())
        {
            var nvencSettings = new NVENCH264EncoderSettings();
            nvencSettings.Bitrate = videoBitrate;
            facebookOutput.Video = nvencSettings;
        }
        else if (QSVH264EncoderSettings.IsAvailable())
        {
            var qsvSettings = new QSVH264EncoderSettings();
            qsvSettings.Bitrate = videoBitrate;
            facebookOutput.Video = qsvSettings;
        }
        else
        {
            // Software fallback
            var openH264 = new OpenH264EncoderSettings();
            openH264.Bitrate = videoBitrate;
            facebookOutput.Video = openH264;
        }

        // Configure platform-optimal audio encoder
        #if NET_WINDOWS
            facebookOutput.Audio = new MFAACEncoderSettings();
        #else
            facebookOutput.Audio = new VOAACEncoderSettings();
        #endif

        // Set additional stream parameters
        facebookOutput.Sink.Key = streamKey;

        return facebookOutput;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error configuring Facebook Live output: {ex.Message}");
        throw;
    }
}

// Usage with VideoCaptureCoreX
var captureCore = new VideoCaptureCoreX();
var facebookOutput = ConfigureFacebookLiveStream("your_streaming_key_here");
captureCore.Outputs_Add(facebookOutput, true);
await captureCore.StartAsync();

// Usage with VideoEditCoreX
var editCore = new VideoEditCoreX();

// Add sources
// ...

// Set output format
editCore.Output_Format = ConfigureFacebookLiveStream("your_streaming_key_here");

// Start
await editCore.StartAsync();
```

## Media Blocks SDK Integration

For developers requiring even more granular control, the Media Blocks SDK provides a modular approach to Facebook Live streaming:

```
// Create a pipeline
var pipeline = new MediaBlocksPipeline();

// Add video source (camera, screen capture, etc.)
var videoSource = new SomeVideoSourceBlock();

// Add audio source (microphone, system audio, etc.)
var audioSource = new SomeAudioSourceBlock();

// Add video encoder (H.264)
var h264Encoder = new H264EncoderBlock(videoEncoderSettings);

// Add audio encoder (AAC)
var aacEncoder = new AACEncoderBlock(audioEncoderSettings);

// Create Facebook Live sink
var facebookSink = new FacebookLiveSinkBlock(
    new FacebookLiveSinkSettings("your_streaming_key_here")
);

// Connect blocks
pipeline.Connect(videoSource.Output, h264Encoder.Input);
pipeline.Connect(audioSource.Output, aacEncoder.Input);
pipeline.Connect(h264Encoder.Output, facebookSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output, facebookSink.CreateNewInput(MediaBlockPadMediaType.Audio));

// Start the pipeline
pipeline.Start();
```

## Troubleshooting and Best Practices

### Common Issues and Solutions

1. **Stream Connection Failures**
2. Verify Facebook stream key validity and expiration status
3. Check network connectivity and firewall settings
4. Facebook requires port 80 (HTTP) and 443 (HTTPS) to be open
5. **Encoder Initialization Problems**
6. Always check hardware encoder availability before attempting to use them
7. Ensure GPU drivers are up-to-date for hardware acceleration
8. Fall back to software encoders when hardware acceleration is unavailable
9. **Performance Optimization**
10. Monitor CPU and GPU usage during streaming
11. Adjust video resolution and bitrate based on available bandwidth
12. Consider separate threads for video capture and encoding operations

### Quality and Security Best Practices

1. **Stream Key Security**
2. Never hardcode stream keys in your application
3. Store keys securely and consider runtime key retrieval from a secure API
4. Implement key rotation mechanisms for enhanced security
5. **Quality Settings Recommendations**
6. For HD streaming (1080p): 4-6 Mbps video bitrate, 128-192 Kbps audio
7. For SD streaming (720p): 2-4 Mbps video bitrate, 128 Kbps audio
8. Mobile-optimized: 1-2 Mbps video bitrate, 64-96 Kbps audio
9. **Resource Management**
10. Implement proper disposal of SDK resources
11. Monitor memory usage for long-running streams
12. Implement graceful error recovery mechanisms

By implementing these best practices, your application will deliver reliable, high-quality Facebook Live streaming across a wide range of devices and network conditions.

---END OF PAGE---


## HLS Live Streaming in C# .NET — m3u8 Playlist & Segments
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/hls-streaming/
**Description:** Generate .m3u8 playlists and .ts segments with built-in HTTP server. HLS.js, iOS AVPlayer, and Android ExoPlayer integration. VisioForge SDK examples.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, VideoCaptureCoreX, VideoEditCore, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, Conversion, HLS, TS, H.264, AAC, C#
**API:** HLSOutput, HLSSinkSettings, MediaBlockPadMediaType, HLSPlaylistType, H264EncoderBlock

# Complete Guide to HLS Network Streaming Implementation in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## What is HTTP Live Streaming (HLS)?

HTTP Live Streaming (HLS) is an adaptive bitrate streaming communications protocol designed and developed by Apple Inc. First introduced in 2009, it has since become one of the most widely adopted streaming protocols across various platforms and devices. HLS works by breaking the overall stream into a sequence of small HTTP-based file downloads, each containing a short segment of the overall content.

### Key Features of HLS Streaming

- **Adaptive Bitrate Streaming**: HLS automatically adjusts video quality based on the viewer's network conditions, ensuring optimal playback quality without buffering.
- **Cross-Platform Compatibility**: Works across iOS, macOS, Android, Windows, and most modern web browsers.
- **HTTP-Based Delivery**: Leverages standard web server infrastructure, allowing content to pass through firewalls and proxy servers.
- **Media Encryption and Authentication**: Supports content protection through encryption and various authentication methods.
- **Live and On-Demand Content**: Can be used for both live broadcasting and pre-recorded media.

### HLS Technical Structure

HLS content delivery relies on three key components:

1. **Manifest File (.m3u8)**: A playlist file that contains metadata about the various streams available
2. **Segment Files (.ts)**: The actual media content, divided into small chunks (typically 2-10 seconds each)
3. **HTTP Server**: Responsible for delivering both manifest and segment files

Since HLS is entirely HTTP-based, you'll need either a dedicated HTTP server or can use the lightweight internal server provided by our SDKs.

## Implementing HLS Streaming with Media Blocks SDK

The Media Blocks SDK offers a comprehensive approach to HLS streaming through its pipeline architecture, giving developers granular control over each aspect of the streaming process.

### Creating a Basic HLS Stream

The following example demonstrates how to set up an HLS stream using Media Blocks SDK:

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AudioEncoders;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.VideoEncoders;

// Initialise the cross-platform engine once per process.
VisioForgeX.InitSDK();

const string URL = "http://localhost:8088/";

// Pipeline (attach error handler before adding blocks).
var pipeline = new MediaBlocksPipeline();
pipeline.OnError += (s, e) => Console.WriteLine($"ERROR: {e.Message}");

// Video source: first enumerated capture device.
var videoDevices = await DeviceEnumerator.Shared.VideoSourcesAsync();
var videoSettings = new VideoCaptureDeviceSourceSettings(videoDevices[0]);
var videoSource = new SystemVideoSourceBlock(videoSettings);

// Audio source: first enumerated audio capture device.
var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync();
var audioSettings = new AudioCaptureDeviceSourceSettings(audioDevices[0]);
var audioSource = new SystemAudioSourceBlock(audioSettings);

// H.264 and AAC encoders.
var h264Encoder = new H264EncoderBlock(new OpenH264EncoderSettings());
var aacEncoder = new AACEncoderBlock();

// HLS sink.
var settings = new HLSSinkSettings
{
    Location             = Path.Combine(AppContext.BaseDirectory, "segment_%05d.ts"),
    MaxFiles             = 10,
    PlaylistLength       = 5,
    PlaylistLocation     = Path.Combine(AppContext.BaseDirectory, "playlist.m3u8"),
    PlaylistRoot         = URL.TrimEnd('/'),
    SendKeyframeRequests = true,
    TargetDuration       = TimeSpan.FromSeconds(5),  // TimeSpan, not int
    Custom_HTTP_Server_Enabled = true,
    Custom_HTTP_Server_Port    = 8088
};

var hlsSink = new HLSSinkBlock(settings);

// Wire the graph: source → encoder → HLS sink (separate pads for video/audio).
pipeline.Connect(videoSource.Output, h264Encoder.Input);
pipeline.Connect(audioSource.Output, aacEncoder.Input);
pipeline.Connect(h264Encoder.Output, hlsSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output, hlsSink.CreateNewInput(MediaBlockPadMediaType.Audio));

// Start. Open http://localhost:8088/playlist.m3u8 in a player or browser.
await pipeline.StartAsync();
```

### Advanced Configuration Options

The Media Blocks SDK offers several advanced configuration options for HLS streaming:

- **Multiple Bitrate Variants**: Create different quality levels for adaptive streaming
- **Custom Segment Duration**: Optimize for different types of content and viewing environments
- **Server-Side Options**: Configure cache control headers and other server behaviors
- **Security Features**: Implement token-based authentication or encryption

You can use this SDK to stream both live video capture and existing media files to HLS. The flexible pipeline architecture allows for extensive customization of the media processing workflow.

## HLS Streaming with Video Capture SDK .NET

Video Capture SDK .NET provides a streamlined approach to HLS streaming specifically designed for live video sources like webcams, capture cards, and other input devices.

### VideoCaptureCoreX Implementation

The VideoCaptureCoreX engine offers a modern, object-oriented approach to video capture and streaming:

```
// Create HLS sink settings
var settings = new HLSSinkSettings
{
    Location = Path.Combine(AppContext.BaseDirectory, "segment_%05d.ts"),
    MaxFiles = 10,
    PlaylistLength = 5,
    PlaylistLocation = Path.Combine(AppContext.BaseDirectory, "playlist.m3u8"),
    PlaylistRoot = edStreamingKey.Text,
    SendKeyframeRequests = true,
    TargetDuration = TimeSpan.FromSeconds(5), // TimeSpan, not int
    Custom_HTTP_Server_Enabled = true,
    Custom_HTTP_Server_Port = new Uri(edStreamingKey.Text).Port
};

// Create HLS output
var hlsOutput = new HLSOutput(settings);

// Create video and audio encoders with default settings
hlsOutput.Video = new OpenH264EncoderSettings();
hlsOutput.Audio = new VOAACEncoderSettings();

// Add HLS output to video capture object
videoCapture.Outputs_Add(hlsOutput, true);
```

### VideoCaptureCore Implementation

For those working with the traditional VideoCaptureCore engine, the implementation is slightly different but equally straightforward:

```
VideoCapture1.Network_Streaming_Enabled = true;
VideoCapture1.Network_Streaming_Audio_Enabled = true;
VideoCapture1.Network_Streaming_Format = NetworkStreamingFormat.HLS;

var hls = new HLSOutput
{
    HLS =
    {
        SegmentDuration = 10,                   // Segment duration in seconds
        NumSegments = 5,                        // Number of segments in playlist
        OutputFolder = "c:\\hls\\",             // Output folder
        PlaylistType = HLSPlaylistType.Live,    // Playlist type
        Custom_HTTP_Server_Enabled = true,      // Use internal HTTP server
        Custom_HTTP_Server_Port = 8088          // Port for internal HTTP server
    }
};

VideoCapture1.Network_Streaming_Output = hls;
```

### Performance Considerations

When streaming with Video Capture SDK, consider these performance optimization techniques:

- Keep segment durations between 2-10 seconds (10 seconds is optimal for most use cases)
- Adjust the number of segments based on expected viewing patterns
- Use hardware acceleration when available for encoding
- Configure appropriate bitrates based on your target audience's connection speeds

## Converting Media Files to HLS with Video Edit SDK .NET

The Video Edit SDK .NET enables developers to convert existing media files into HLS format for streaming, ideal for video-on-demand applications.

### VideoEditCore Implementation

```
VideoEdit1.Network_Streaming_Enabled = true;
VideoEdit1.Network_Streaming_Audio_Enabled = true;
VideoEdit1.Network_Streaming_Format = NetworkStreamingFormat.HLS;

var hls = new HLSOutput
{
    HLS =
    {
        SegmentDuration = 10,                   // Segment duration in seconds
        NumSegments = 5,                        // Number of segments in playlist
        OutputFolder = "c:\\hls\\",             // Output folder
        PlaylistType = HLSPlaylistType.Live,    // Playlist type
        Custom_HTTP_Server_Enabled = true,      // Use internal HTTP server
        Custom_HTTP_Server_Port = 8088          // Port for internal HTTP server
    }
};

VideoEdit1.Network_Streaming_Output = hls;
```

### File Format Considerations

When converting files to HLS, consider these factors:

- Not all input formats are equally efficient for conversion
- MP4, MOV, and MKV files typically provide the best results
- Highly compressed formats may require more processing power
- Consider pre-transcoding very large files to an intermediate format

## Playback and Integration

### HTML5 Player Integration

All applications implementing HLS streaming should include an HTML file with a video player. Modern HTML5 players like HLS.js, Video.js, or JW Player provide excellent support for HLS streams.

Here's a basic example using HLS.js:

```
<!DOCTYPE html>
<html>
<head>
    <title>HLS Player</title>
    <script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
</head>
<body>
    <video id="video" controls></video>
    <script>
      var video = document.getElementById('video');
      var videoSrc = 'http://localhost:8088/playlist.m3u8';

      if (Hls.isSupported()) {
        var hls = new Hls();
        hls.loadSource(videoSrc);
        hls.attachMedia(video);
      } else if (video.canPlayType('application/vnd.apple.mpegurl')) {
        video.src = videoSrc;
      }
    </script>
</body>
</html>
```

For a complete example player, refer to our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples/blob/master/Media%20Blocks%20SDK/Console/HLS%20Streamer/index.htm).

### Mobile App Integration

Our SDKs also support integration with mobile applications through:

- Native iOS playback using AVPlayer
- Android playback via ExoPlayer
- Cross-platform options like Xamarin or MAUI

## Troubleshooting Common Issues

### CORS Configuration

When serving HLS content to web browsers, you may encounter Cross-Origin Resource Sharing (CORS) issues. Ensure your server is configured to send the proper CORS headers:

```
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET, HEAD, OPTIONS
Access-Control-Allow-Headers: Range
Access-Control-Expose-Headers: Accept-Ranges, Content-Encoding, Content-Length, Content-Range
```

### Latency Optimization

HLS inherently introduces some latency. To minimize this:

- Use shorter segment durations (2-4 seconds) for lower latency
- Consider enabling Low-Latency HLS (LL-HLS) if supported
- Optimize your network infrastructure for minimal delays

## Conclusion

HLS streaming provides a robust, cross-platform solution for delivering both live and on-demand video content to a wide range of devices. With VisioForge's .NET SDKs, implementing HLS in your applications becomes straightforward, allowing you to focus on creating compelling content rather than wrestling with technical details.

For more code samples and advanced implementations, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---

## Additional Resources

- [HLS Specification](https://developer.apple.com/streaming/)

---END OF PAGE---


## HTTP MJPEG Streaming Server in C# .NET — Send Live Video
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/http-mjpeg/
**Description:** Stream live video as HTTP MJPEG from webcams, IP cameras, or files in C# / .NET. Browser-viewable endpoints, concurrent clients, GPU JPEG encoding.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Streaming, Editing, MJPEG, C#
**API:** VideoCaptureCoreX, HTTPMJPEGLiveOutput, HTTPMJPEGLiveSinkBlock, IVideoCaptureXBaseOutput, IMediaBlockSink

# HTTP MJPEG streaming

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Cross-platform support

The `VideoCaptureCoreX` engine and the Media Blocks SDK run on **Windows, macOS, Linux, Android, and iOS** via GStreamer. See the [platform support matrix](../../../platform-matrix/) for codec and hardware-acceleration details, and the [Linux deployment guide](../../../deployment-x/Ubuntu/) for Ubuntu / NVIDIA Jetson / Raspberry Pi setup.

The SDK's feature of streaming video encoded as Motion JPEG (MJPEG) over HTTP is advantageous for its simplicity and broad compatibility. MJPEG encodes each video frame individually as a JPEG image, which simplifies decoding and is ideal for applications like web streaming and surveillance. The use of HTTP ensures easy integration and high compatibility across different platforms and devices and is effective even in networks with strict configurations. This method is particularly suitable for real-time video feeds and applications requiring straightforward frame-by-frame analysis. With adjustable frame rates and resolutions, the SDK offers flexibility for various network conditions and quality requirements, making it a versatile choice for developers implementing video streaming in their applications.

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Cross-platform MJPEG output

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The streaming functionality is implemented through two main classes:

1. `HTTPMJPEGLiveOutput`: The high-level configuration class that sets up the streaming output
2. `HTTPMJPEGLiveSinkBlock`: The underlying implementation block that handles the actual streaming process

### HTTPMJPEGLiveOutput Class

This class serves as the configuration entry point for setting up an MJPEG HTTP stream. It implements the `IVideoCaptureXBaseOutput` interface, making it compatible with the video capture pipeline system.

#### Key Properties

- `Port`: Gets the network port number on which the MJPEG stream will be served

#### Usage

```
// Create a new MJPEG streaming output on port 8080
var mjpegOutput = new HTTPMJPEGLiveOutput(8080);

// Add the MJPEG output to the VideoCaptureCoreX engine
core.Outputs_Add(mjpegOutput, true);
```

#### Implementation Details

- The class is designed to be immutable, with the port being set only through the constructor
- It does not support video or audio encoders, as MJPEG uses direct JPEG encoding
- The filename-related methods return null or are no-ops, as this is a streaming-only implementation

### HTTPMJPEGLiveSinkBlock Class

This class handles the actual implementation of the MJPEG streaming functionality. It's responsible for:

- Setting up the pipeline for video processing
- Managing the HTTP server for streaming
- Handling input video data and converting it to MJPEG format
- Managing client connections and stream delivery

#### Key Features

- Implements multiple interfaces for integration with the media pipeline:
- `IMediaBlockInternals`: For pipeline integration
- `IMediaBlockDynamicInputs`: For handling dynamic input connections
- `IMediaBlockSink`: For sink functionality
- `IDisposable`: For proper resource cleanup

#### Input/Output Configuration

- Accepts a single video input through the `Input` pad
- No output pads (as it's a sink block)
- Input pad configured for video media type only

### Implementation Notes

#### Initialization

```
// The block must be initialized with a port number
var mjpegSink = new HTTPMJPEGLiveSinkBlock(8080);
pipeline.Connect(videoSource.Output, mjpegSink.Input);

// "IMG tag URL is http://127.0.0.1:8090";
```

#### Resource Management

- The class implements proper resource cleanup through the `IDisposable` pattern
- The `CleanUp` method ensures all resources are properly released
- Event handlers are properly connected and disconnected during the pipeline lifecycle

#### Pipeline Integration

The `Build` method handles the critical setup process:

1. Creates the underlying HTTP MJPEG sink element
2. Initializes the sink with the specified port
3. Sets up the necessary GStreamer pad connections
4. Connects pipeline event handlers

### Error Handling

- The implementation includes comprehensive error checking during the build process
- Failed initialization is properly reported through the context error system
- Resource cleanup is handled even in error cases

### Technical Considerations

#### Performance

- The implementation uses GStreamer's native elements for optimal performance
- Direct pad connections minimize copying and overhead
- The sink block is designed to handle multiple client connections efficiently

#### Memory Management

- Proper disposal patterns ensure no memory leaks
- Resources are cleaned up when the pipeline stops or the block is disposed
- The implementation handles GStreamer element lifecycle correctly

#### Threading

- The implementation is thread-safe for pipeline operations
- Event handlers are properly synchronized with pipeline state changes
- Client connections are handled asynchronously

#### Client Usage

To consume the MJPEG stream:

1. Initialize the streaming output with desired port
2. Connect it to your video pipeline
3. Access the stream through a web browser or HTTP client at:

   ```
   http://[server-address]:[port]
   ```

#### Example Client HTML

```
<img src="http://localhost:8080" />
```

### Limitations and Considerations

1. Bandwidth Usage
2. MJPEG streams can use significant bandwidth as each frame is a complete JPEG
3. Consider frame rate and resolution settings for optimal performance
4. Browser Support
5. While MJPEG is widely supported, some modern browsers may have limitations
6. Mobile devices may handle MJPEG streams differently
7. Latency
8. While MJPEG provides relatively low latency, it's not suitable for ultra-low-latency requirements
9. Network conditions can affect frame delivery timing

### Best Practices

1. Port Selection
2. Choose ports that don't conflict with other services
3. Consider firewall implications when selecting ports
4. Resource Management
5. Always dispose of the sink block properly
6. Monitor client connections and resource usage
7. Error Handling
8. Implement proper error handling for network and pipeline issues
9. Monitor the pipeline status for potential issues

### Security Considerations

1. Network Security
2. The MJPEG stream is unencrypted by default
3. Consider implementing additional security measures for sensitive content
4. Access Control
5. No built-in authentication mechanism
6. Consider implementing application-level access control if needed
7. Port Security
8. Ensure proper firewall rules are in place
9. Consider network isolation for internal streams

## Windows-only MJPEG output

[VideoCaptureCore](#) [VideoEditCore](#)

Set the `Network_Streaming_Enabled` property to true to enable network streaming.

```
VideoCapture1.Network_Streaming_Enabled = true;
```

Set the HTTP MJPEG output.

```
VideoCapture1.Network_Streaming_Format = NetworkStreamingFormat.HTTP_MJPEG;
```

Create the settings object and set the port.

```
VideoCapture1.Network_Streaming_Output = new MJPEGOutput(8080);
```

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## IIS Smooth Streaming Setup Guide for .NET Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/iis-smooth-streaming/
**Description:** Configure Microsoft IIS Smooth Streaming in .NET with adaptive bitrate, mobile compatibility, and troubleshooting for quality video delivery.
**Tags:** Video Capture SDK, Video Edit SDK, .NET, VideoCaptureCore, VideoEditCore, Windows, Capture, Streaming, Editing, HLS, MP4, C#, JavaScript, NuGet

# Comprehensive Guide to IIS Smooth Streaming Implementation

IIS Smooth Streaming is Microsoft's implementation of adaptive streaming technology that dynamically adjusts video quality based on network conditions and CPU capabilities. This guide provides detailed instructions on configuring and implementing IIS Smooth Streaming using VisioForge SDKs.

## Compatible VisioForge SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

[VideoCaptureCore](#) [VideoEditCore](#)

IIS Media Services and IIS Smooth Streaming are unmaintained

Microsoft retired the **Web Platform Installer** feed on December 31, 2022 (see the [official announcement](https://blogs.iis.net/iisteam/web-platform-installer-end-of-support-feed)) and removed **IIS Media Services 4.1** — the component that delivers Smooth Streaming — from the IIS download portal. The Silverlight client that the Smooth Streaming Player uses was retired by Microsoft on October 12, 2021. For new projects, use **[HLS](../hls-streaming/)** instead: it is the modern adaptive-bitrate format supported natively by browsers and mobile devices, and VisioForge's `MP4Output` / `HLSOutput` produce HLS streams out of the box. The instructions below remain available for customers maintaining existing IIS Media Services 4.1 deployments only.

## Overview of IIS Smooth Streaming

IIS Smooth Streaming provides several key advantages for developers and end-users:

- **Adaptive bitrate streaming**: Automatically adjusts video quality based on available bandwidth
- **Reduced buffering**: Minimizes playback interruptions during network fluctuations
- **Broad device compatibility**: Works across desktops, mobile devices, smart TVs, and more
- **Scalable delivery**: Handles large numbers of concurrent viewers efficiently

This technology is particularly valuable for applications requiring high-quality video delivery across varied network conditions, such as live events, educational platforms, and media-rich applications.

## Prerequisites

Before implementing IIS Smooth Streaming with VisioForge SDKs, ensure you have:

1. Windows Server with IIS installed
2. Administrative access to the server
3. Relevant VisioForge SDK (Video Capture SDK .Net or Video Edit SDK .Net)
4. Basic understanding of .NET development

## Step-by-Step IIS Configuration

### Installing Required Components

1. Install [Web Platform Installer](https://blogs.iis.net/iisteam/web-platform-installer-end-of-support-feed/) on your server.
2. Through the Web Platform Installer, search for and install IIS Media Services.

This component package includes all necessary modules for Smooth Streaming functionality, including the Live Smooth Streaming Publishing service.

### Configuring IIS Manager

1. Open IIS Manager on your server through the Start menu or by running `inetmgr` in the Run dialog.

1. In the left navigation pane, locate and expand your server name, then select the site where you want to enable Smooth Streaming.

### Creating a Publishing Point

1. Within the selected site, find and open the "Live Smooth Streaming Publishing Points" feature.
2. Click "Add" to create a new publishing point.

1. Configure the basic settings for your publishing point:
2. **Name**: Provide a descriptive name for your publishing point (e.g., "MainStream")
3. **Path**: Specify the file path where the Smooth Streaming content will be stored

1. Configure additional parameters by enabling the "Allow clients to connect to this publishing point" checkbox. This ensures that clients can connect and receive the streamed content.

### Enabling Mobile Device Support

To ensure your Smooth Streaming content is accessible on mobile devices:

1. In the publishing point configuration, navigate to the "Mobile Devices" tab.
2. Enable the checkbox for "Allow playback on mobile devices."

This setting generates the necessary formats and manifests for mobile playback, significantly expanding your content's reach.

### Setting Up the Player

To provide viewers with a way to watch your Smooth Streaming content:

1. Download the Smooth Streaming Player Silverlight control provided by Microsoft.
2. Extract the downloaded files and locate the `.xap` file.
3. Copy this `.xap` file to your website's directory.
4. Copy the included HTML file to the same directory and rename it to `index.html`.
5. Open `index.html` in a text editor and replace the "initparams" section with the following configuration:

```
<param name="initParams" value="selectedCaptionStreamsCount=0,
autoplay=true,
muted=false,
displayCCButton=false,
mediaLoadTimeout=60000,
stretchMode=none,
poster=,
enableGPUAcceleration=true,
startupBitrate=400000,
disableDynamicHeader=false,
backwardBufferLength=0,
initialEntryStartPosition=0,
forwardBufferLength=10000,
sourceType=livetv,
adaptivestreamingplugin.smoothstreaming=true,
adaptivestreamingplugin.LiveSmoothStreaming=true,
mediaurl=http://localhost/mainstream.isml/manifest" />
```

This configuration initializes the Silverlight player with optimal settings for Smooth Streaming playback. The `mediaurl` parameter should point to your publishing point's manifest.

### Starting the Publishing Point

1. Return to IIS Manager and select your configured publishing point.
2. Click the "Start" action in the right-hand panel.

The publishing point will now be active and ready to receive content from your application.

## Implementing Smooth Streaming in VisioForge SDK Applications

### Basic Configuration

Configure an existing `VideoCaptureCore` (or `VideoEditCore`) instance to push to your IIS publishing point using `NetworkStreamingFormat.SSF_H264_AAC_SW` (Smooth Streaming, H.264 + AAC, software encoding):

```
using VisioForge.Core.Types.Output;
using VisioForge.Core.VideoCapture;

// Assumes VideoCapture1 is a VideoCaptureCore already bound to a VideoView.
VideoCapture1.Network_Streaming_Enabled   = true;
VideoCapture1.Network_Streaming_Audio_Enabled = true;

// Pick the Smooth Streaming format. Use SSF_FFMPEG_EXE if you prefer FFMPEG-based encoding.
VideoCapture1.Network_Streaming_Format = NetworkStreamingFormat.SSF_H264_AAC_SW;

// URL of the IIS publishing point you created above.
VideoCapture1.Network_Streaming_URL = "http://localhost/mainstream.isml";

// H.264 + AAC parameters via MP4Output (Smooth Streaming muxes H.264/AAC into the ISML container).
var streamOutput = new MP4Output();
streamOutput.Video = new MP4OutputH264Settings
{
    Bitrate     = 2500,              // kbps — target bitrate
    Profile     = H264Profile.ProfileMain,
    Level       = H264Level.Level4,
    RateControl = H264RateControl.VBR
};
streamOutput.Audio_AAC.Bitrate = 128;
streamOutput.Audio_AAC.Object  = AACObject.Low;

VideoCapture1.Network_Streaming_Output = streamOutput;

await VideoCapture1.StartAsync();
```

### Verifying the Connection

Once your application is configured:

1. Check the connection status in your application. You should see confirmation that the SDK has successfully connected to IIS.

1. Open a web browser and navigate to `http://localhost` (or your server address).
2. The Silverlight player should load and begin playing your stream.

### HTML5 Streaming for iOS Devices

For broader device compatibility, particularly iOS devices that don't support Silverlight, create an HTML5 player:

1. Create a new HTML file in your website's directory.
2. Include the following code in the file:

```
<!DOCTYPE html>
<html>
<head>
    <title>Smooth Streaming HTML5 Player</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 0; padding: 20px; }
        .player-container { max-width: 800px; margin: 0 auto; }
        video { width: 100%; height: auto; }
    </style>
</head>
<body>
    <div class="player-container">
        <h1>HTML5 Smooth Streaming Player</h1>
        <video id="videoPlayer" controls autoplay>
            <source src="http://localhost/mainstream.isml/manifest(format=m3u8-aapl)" type="application/x-mpegURL">
            Your browser does not support HTML5 video.
        </video>
    </div>

    <script>
        document.addEventListener('DOMContentLoaded', function() {
            var video = document.getElementById('videoPlayer');
            video.addEventListener('error', function(e) {
                console.error('Video playback error:', e);
            });
        });
    </script>
</body>
</html>
```

This HTML5 player uses HLS (HTTP Live Streaming) format, which is automatically generated by IIS Media Services when you enable mobile device support.

## Required Redistributables

To ensure your application functions correctly with IIS Smooth Streaming, include the following redistributables:

- SDK redistributables for your specific VisioForge SDK
- MP4 redistributables:
- For x86 architectures: [VisioForge.DotNet.Core.Redist.MP4.x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MP4.x86/)
- For x64 architectures: [VisioForge.DotNet.Core.Redist.MP4.x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MP4.x64/)

You can add these packages through NuGet Package Manager in Visual Studio or via the command line:

```
Install-Package VisioForge.DotNet.Core.Redist.MP4.x64
```

## Advanced Configuration Options

For production environments, consider these additional configurations:

- **Multiple bitrate encoding**: Configure your VisioForge SDK to encode at multiple bitrates for optimal adaptive streaming
- **Custom manifest settings**: Modify the Smooth Streaming manifest for specialized playback requirements
- **Authentication**: Implement token-based authentication for secure streaming
- **Content encryption**: Enable DRM protection for sensitive content
- **Load balancing**: Configure multiple publishing points behind a load balancer for high-traffic scenarios

## Troubleshooting Common Issues

- **Connection failures**: Verify firewall settings allow traffic on the streaming port (typically 80 or 443)
- **Playback stuttering**: Check server resources and consider increasing buffer settings
- **Mobile compatibility issues**: Ensure mobile format generation is enabled and test across multiple devices
- **Quality issues**: Adjust encoding parameters and bitrate ladder configuration

## Conclusion

IIS Smooth Streaming, when implemented with VisioForge SDKs, provides a robust solution for adaptive video delivery across diverse network conditions and devices. By following this comprehensive guide, you can configure, implement, and optimize Smooth Streaming for your .NET applications.

For additional code samples and implementation examples, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---

*This documentation is provided by VisioForge. For additional support or information about our SDKs, please visit [www.visioforge.com](https://www.visioforge.com).*

---END OF PAGE---


## Network Streaming in .NET - RTMP, RTSP, HLS, NDI, SRT
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/
**Description:** Implement RTMP, RTSP, HLS, NDI, and other streaming protocols in .NET with hardware acceleration for live broadcasting and media platforms.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming

# Comprehensive Network Streaming Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to Network Streaming

Network streaming enables real-time transmission of audio and video content across the internet or local networks. VisioForge's comprehensive SDKs provide powerful tools for implementing various streaming protocols in your .NET applications, allowing you to create professional-grade broadcasting solutions with minimal development effort.

This guide covers all streaming options available in VisioForge SDKs, including implementation details, best practices, and code examples to help you select the most appropriate streaming technology for your specific requirements.

## Streaming Protocol Overview

VisioForge SDKs support a wide range of streaming protocols, each with unique advantages for different use cases:

### Real-Time Protocols

- **[RTMP (Real-Time Messaging Protocol)](rtmp/)**: Industry-standard protocol for low-latency live streaming, widely used for live broadcasting to CDNs and streaming platforms
- **[RTSP (Real-Time Streaming Protocol)](rtsp/)**: Ideal for IP camera integration and surveillance applications, offering precise control over media sessions
- **[SRT (Secure Reliable Transport)](srt/)**: Advanced protocol designed for high-quality, low-latency video delivery over unpredictable networks
- **[NDI (Network Device Interface)](ndi/)**: Professional-grade protocol for high-quality, low-latency video transmission over local networks

### HTTP-Based Streaming

- **[HLS (HTTP Live Streaming)](hls-streaming/)**: Apple-developed protocol that breaks streams into downloadable segments, offering excellent compatibility with browsers and mobile devices
- **[HTTP MJPEG Streaming](http-mjpeg/)**: Simple implementation for streaming motion JPEG over HTTP connections
- **[IIS Smooth Streaming](iis-smooth-streaming/)**: Microsoft's adaptive streaming technology for delivering media through IIS servers

### Platform-Specific Solutions

- **[Windows Media Streaming (WMV)](wmv/)**: Microsoft's native streaming format, ideal for Windows-centric deployments
- **[Adobe Flash Media Server](adobe-flash/)**: Legacy streaming solution for Flash-based applications

### Cloud & Social Media Integration

- **[AWS S3](aws-s3/)**: Direct streaming to Amazon Web Services S3 storage
- **[YouTube Live](youtube/)**: Simplified integration with YouTube's live streaming platform
- **[Facebook Live](facebook/)**: Direct broadcasting to Facebook's streaming service

## Key Components of Network Streaming

### Video Encoders

VisioForge SDKs provide multiple encoding options to balance quality, performance and compatibility:

#### Software Encoders

- **OpenH264**: Cross-platform software-based H.264 encoder
- **AVENC H264**: FFmpeg-based software encoder

#### Hardware-Accelerated Encoders

- **NVENC H264/HEVC**: NVIDIA GPU-accelerated encoding
- **QSV H264/HEVC**: Intel Quick Sync Video acceleration
- **AMF H264/HEVC**: AMD GPU-accelerated encoding
- **Apple Media H264**: macOS-specific hardware acceleration

## Best Practices for Network Streaming

### Performance Optimization

1. **Hardware acceleration**: Leverage GPU-based encoding where available for reduced CPU usage
2. **Resolution and framerate**: Match output to content type (60fps for gaming, 30fps for general content)
3. **Bitrate allocation**: Allocate 80-90% of bandwidth to video and 10-20% to audio

### Network Reliability

1. **Connection testing**: Verify upload speed before streaming
2. **Error handling**: Implement reconnection logic for disrupted streams
3. **Monitoring**: Track streaming metrics in real-time to identify issues

### Quality Assurance

1. **Pre-streaming checks**: Validate encoder settings and output parameters
2. **Quality monitoring**: Regularly check stream quality during broadcast
3. **Platform compliance**: Follow platform-specific requirements (YouTube, Facebook, etc.)

## Troubleshooting Common Issues

1. **Encoding overload**: If experiencing frame drops, reduce resolution or bitrate
2. **Connection failures**: Verify network stability and server addresses
3. **Audio/video sync**: Ensure proper timestamp synchronization between streams
4. **Platform rejection**: Confirm compliance with platform-specific requirements
5. **Hardware acceleration failures**: Verify driver installation and compatibility

## Conclusion

Network streaming with VisioForge SDKs provides a comprehensive solution for implementing professional-grade media broadcasting in your .NET applications. By understanding the available protocols and following best practices, you can create high-quality streaming experiences for your users across multiple platforms.

For protocol-specific implementation details, refer to the dedicated guides linked throughout this document.

---END OF PAGE---


## NDI Video and Audio Streaming over IP Network in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/ndi/
**Description:** Stream video and audio to NDI from cameras, files, and capture devices in C# .NET. Setup guide with SDK output examples, audio resampling, and troubleshooting.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, GStreamer, Capture, Streaming, Editing, Webcam, NDI, MP4, C#
**API:** NDISinkBlock, AudioResamplerBlock, NDIOutput, MediaBlockPadMediaType, MediaBlocksPipeline

# Network Device Interface (NDI) Streaming Integration

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## What is NDI?

Network Device Interface (NDI) is an industry standard for live video production over IP networks. It enables high-quality, low-latency video and audio streaming over standard Ethernet — replacing expensive SDI cabling with software-based workflows. Common use cases include:

- Live broadcasting and streaming
- Professional video conferencing
- Multi-camera production setups
- Remote production workflows
- Playout server applications

The VisioForge SDK provides NDI output support for desktop/server workflows, letting you stream cameras, capture devices, or media files to NDI receivers on your network.

## Installation Requirements

To use NDI streaming, install one of the following official NDI packages:

1. **[NDI SDK](https://ndi.video/for-developers/ndi-sdk/download/)** - Recommended for developers
2. **[NDI Tools](https://ndi.video/tools/)** - Suitable for testing

These provide the runtime components that enable NDI communication. You can verify NDI availability in code:

```
bool ndiAvailable = NDISinkBlock.IsAvailable();
```

## Cross-Platform NDI Output

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

### NDIOutput Class

The `NDIOutput` class provides NDI output for VideoCaptureCoreX and VideoEditCoreX engines:

```
public class NDIOutput : IVideoEditXBaseOutput, IVideoCaptureXBaseOutput, IOutputVideoProcessor, IOutputAudioProcessor
```

#### Configuration

| Property | Type | Description |
| --- | --- | --- |
| `Sink` | `NDISinkSettings` | NDI output configuration (stream name, compression, network settings) |
| `CustomVideoProcessor` | `MediaBlock` | Optional custom video processing before NDI transmission |
| `CustomAudioProcessor` | `MediaBlock` | Optional custom audio processing before NDI transmission |

#### Constructors

```
// Create with stream name
var output = new NDIOutput("My Stream");

// Create with pre-configured settings
var output = new NDIOutput(new NDISinkSettings("My Stream"));
```

## Implementation Examples

### Media Blocks SDK

```
// Create an NDI output block with a descriptive stream name
var ndiSink = new NDISinkBlock("VisioForge Production Stream");

// Connect video source to the NDI output
pipeline.Connect(videoSource.Output, ndiSink.CreateNewInput(MediaBlockPadMediaType.Video));

// Connect audio source to the NDI output
pipeline.Connect(audioSource.Output, ndiSink.CreateNewInput(MediaBlockPadMediaType.Audio));
```

### Video Capture SDK

```
// Initialize NDI output with a network-friendly stream name
var ndiOutput = new NDIOutput("VisioForge_Studio_Output");

// Add the configured NDI output to the video capture pipeline
core.Outputs_Add(ndiOutput); // core represents the VideoCaptureCoreX instance
```

## Streaming a Camera to NDI

[MediaBlocksPipeline](#)

The most common use case is streaming a local webcam and microphone to NDI. This example uses the Media Blocks SDK to capture from system devices and send to NDI with proper audio resampling.

### Pipeline Architecture

```
SystemVideoSourceBlock → NDISinkBlock (video input)
SystemAudioSourceBlock → AudioResamplerBlock (48kHz, F32LE, stereo) → NDISinkBlock (audio input)
```

### Code Example

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.AudioProcessing;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.AudioEncoders;

// Initialize SDK once at startup
await VisioForgeX.InitSDKAsync();

var pipeline = new MediaBlocksPipeline();

// Enumerate available devices
var videoDevices = await DeviceEnumerator.Shared.VideoSourcesAsync();
var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync();

// Set up video source (first available camera)
var videoSettings = new VideoCaptureDeviceSourceSettings(videoDevices[0]);
var videoSource = new SystemVideoSourceBlock(videoSettings);

// Set up audio source (first available microphone)
var audioSettings = new AudioCaptureDeviceSourceSettings(audioDevices[0]);
var audioSource = new SystemAudioSourceBlock(audioSettings);

// Create NDI output
var ndiSink = new NDISinkBlock("My Camera Stream");

// Connect video directly to NDI
pipeline.Connect(videoSource.Output, ndiSink.CreateNewInput(MediaBlockPadMediaType.Video));

// Resample audio to 48kHz F32LE stereo (required by NDI)
var audioResampler = new AudioResamplerBlock(
    new AudioResamplerSettings(AudioFormatX.F32LE, 48000, 2));
pipeline.Connect(audioSource.Output, audioResampler.Input);
pipeline.Connect(audioResampler.Output, ndiSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

## Windows-Specific NDI Implementation

[VideoCaptureCore](#) [VideoEditCore](#)

For Windows-specific implementations, the SDK provides additional configuration options through the VideoCaptureCore or VideoEditCore components.

### Step-by-Step Implementation Guide

#### 1. Enable Network Streaming

```
VideoCapture1.Network_Streaming_Enabled = true;
```

#### 2. Configure Audio Streaming

```
VideoCapture1.Network_Streaming_Audio_Enabled = true;
```

#### 3. Select NDI Protocol

```
VideoCapture1.Network_Streaming_Format = NetworkStreamingFormat.NDI;
```

#### 4. Create and Configure NDI Output

```
var streamName = "VisioForge NDI Streamer";
var ndiOutput = new NDIOutput(streamName);
```

#### 5. Assign the Output

```
VideoCapture1.Network_Streaming_Output = ndiOutput;
```

#### 6. Generate the NDI URL (Optional)

```
string ndiUrl = $"ndi://{System.Net.Dns.GetHostName()}/{streamName}";
Debug.WriteLine(ndiUrl);
```

## File Playback to NDI Output

The Media Blocks SDK can stream local media files (MP4, MKV, AVI, etc.) directly to NDI without any local rendering — ideal for playout server applications.

### Recommended Pipeline

```
UniversalSourceBlock (file)
  VideoOutput → NDISinkBlock (video input)
  AudioOutput → AudioResamplerBlock (48kHz, F32LE, stereo) → NDISinkBlock (audio input)
```

### Code Example

```
var pipeline = new MediaBlocksPipeline();

// File source with automatic format detection
var fileSource = new UniversalSourceBlock(
    await UniversalSourceSettings.CreateAsync(new Uri("file:///path/to/video.mp4")));

// NDI output
var ndiSink = new NDISinkBlock("My NDI Stream");

// Connect video directly to NDI
pipeline.Connect(fileSource.VideoOutput,
    ndiSink.CreateNewInput(MediaBlockPadMediaType.Video));

// Resample audio to 48kHz F32LE stereo for NDI compatibility
var audioResampler = new AudioResamplerBlock(
    new AudioResamplerSettings(AudioFormatX.F32LE, 48000, 2));
pipeline.Connect(fileSource.AudioOutput, audioResampler.Input);
pipeline.Connect(audioResampler.Output,
    ndiSink.CreateNewInput(MediaBlockPadMediaType.Audio));

// Optional: enable loop playback
pipeline.Loop = true;

await pipeline.StartAsync();
```

## Audio Format Requirements

NDI requires **48kHz, 32-bit float (F32LE), interleaved** audio. When streaming from sources that may contain audio at other sample rates (e.g., 44.1kHz AAC in MP4 files, or varying microphone rates), always include an `AudioResamplerBlock` to convert to 48kHz. Without resampling, audio may stutter, glitch, or lose synchronization with video.

```
var audioResampler = new AudioResamplerBlock(
    new AudioResamplerSettings(AudioFormatX.F32LE, 48000, 2));
```

## Receiving NDI Sources

This guide focuses on sending video and audio to NDI. To discover, connect, preview, or capture NDI sources, including Android and MAUI NDI player applications, see the [NDI Video Source Reference](../../../videocapture/video-sources/ip-cameras/ndi/).

## Troubleshooting

### Audio Stuttering or Glitching on NDI Output

**Symptom:** Audio is not smooth when streaming from file sources — stutters, glitches, or lip-sync issues.

**Cause:** The source file contains audio at a sample rate other than 48kHz (e.g., 44.1kHz AAC in MP4 files). NDI expects 48kHz audio.

**Solution:** Insert an `AudioResamplerBlock` configured for 48kHz F32LE stereo between the file source and the NDI sink, as shown in the file playback example above.

## Frequently Asked Questions

### How do I stream video from a camera to NDI in C#?

Use the Media Blocks SDK to create a pipeline with `SystemVideoSourceBlock` for the camera, `SystemAudioSourceBlock` for the microphone, and `NDISinkBlock` as the output. Connect audio through an `AudioResamplerBlock` set to 48kHz F32LE stereo, which NDI requires. See the [Streaming a Camera to NDI](#streaming-a-camera-to-ndi) section for complete code.

### What audio format does NDI require?

NDI requires 48kHz, 32-bit float (F32LE), interleaved stereo audio. Always include an `AudioResamplerBlock(new AudioResamplerSettings(AudioFormatX.F32LE, 48000, 2))` in your pipeline between the audio source and the NDI sink. Without proper resampling, you may experience audio stuttering, glitches, or A/V sync issues.

### Can I stream a video file to NDI for playout?

Yes. Use `UniversalSourceBlock` to read the file, connect video directly to `NDISinkBlock`, and route audio through `AudioResamplerBlock` for 48kHz conversion. Enable `pipeline.Loop = true` for continuous playout. This pattern is ideal for broadcast playout servers with zero local rendering overhead.

### What are the system requirements for NDI streaming in .NET?

You need the [NDI SDK](https://ndi.video/for-developers/ndi-sdk/download/) or [NDI Tools](https://ndi.video/tools/) installed for runtime NDI support. The VisioForge SDK supports Windows, macOS, and Linux. Check NDI availability at runtime with `NDISinkBlock.IsAvailable()`. Network bandwidth requirements depend on resolution and framerate — a typical HD NDI stream uses approximately 100-150 Mbps.

### How do I check if NDI is available on the system?

Call `NDISinkBlock.IsAvailable()` before creating NDI pipeline components. This static method checks whether the NDI runtime libraries are installed and accessible. If it returns `false`, prompt the user to install the NDI SDK or NDI Tools package.

## See Also

- [NDI Video Source Reference](../../../videocapture/video-sources/ip-cameras/ndi/) — receiving and capturing NDI sources in .NET
- [RTSP Stream Viewer and IP Camera Player](../../../mediablocks/Guides/rtsp-player-csharp/) — similar IP streaming guide for RTSP cameras
- [Deployment Guide](../../../deployment-x/) — platform-specific runtime packages for Windows, macOS, Linux
- [Code Samples on GitHub](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK) — NDI streamer and source demos
- [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) — product page and downloads

---END OF PAGE---


## RTMP Live Streaming to YouTube and Facebook in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/rtmp/
**Description:** Go live with hardware-accelerated H.264 encoding. Automatic encoder fallback (NVENC, QSV, AMF, OpenH264). Cross-platform C# examples with VisioForge SDK.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, RTMP, H.264, H.265, AAC, C#
**API:** RTMPOutput, NVENCH264EncoderSettings, RTMPSinkSettings, VideoCaptureCoreX, VideoEditCoreX

# RTMP Streaming with VisioForge SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to RTMP Streaming

RTMP (Real-Time Messaging Protocol) is a robust communication protocol designed for high-performance transmission of audio, video, and data between a server and a client. VisioForge SDKs provide comprehensive support for RTMP streaming, enabling developers to create powerful streaming applications with minimal effort.

This guide covers implementation details for RTMP streaming across different VisioForge products, including cross-platform solutions and Windows-specific integrations.

## Cross-Platform RTMP Implementation

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The `RTMPOutput` class serves as the central configuration point for RTMP streaming in cross-platform scenarios. It implements multiple interfaces including `IVideoEditXBaseOutput` and `IVideoCaptureXBaseOutput`, making it versatile for both video editing and capture workflows.

### Setting Up RTMP Output

To begin implementing RTMP streaming, you need to create and configure an `RTMPOutput` instance:

```
// Initialize with streaming URL
var rtmpOutput = new RTMPOutput("rtmp://your-streaming-server/stream-key");

// Alternatively, set the URL after initialization
var rtmpOutput = new RTMPOutput();
rtmpOutput.Sink.Location = "rtmp://your-streaming-server/stream-key";
```

### Integration with VisioForge SDKs

#### Video Capture SDK Integration

```
// Add RTMP output to the Video Capture SDK engine
core.Outputs_Add(rtmpOutput, true); // core is an instance of VideoCaptureCoreX
```

#### Video Edit SDK Integration

```
// Set RTMP as the output format for Video Edit SDK
core.Output_Format = rtmpOutput; // core is an instance of VideoEditCoreX
```

#### Media Blocks SDK Integration

```
// Create an RTMP sink block
var rtmpSink = new RTMPSinkBlock(new RTMPSinkSettings()
{
    Location = "rtmp://streaming-server/stream"
});

// Connect video and audio encoders to the RTMP sink
pipeline.Connect(h264Encoder.Output, rtmpSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output, rtmpSink.CreateNewInput(MediaBlockPadMediaType.Audio));
```

## Video Encoder Configuration

### Supported Video Encoders

VisioForge provides extensive support for various video encoders, making it possible to optimize streaming based on available hardware:

- **OpenH264**: Default software encoder for most platforms
- **NVENC H264**: Hardware-accelerated encoding for NVIDIA GPUs
- **QSV H264**: Intel Quick Sync Video acceleration
- **AMF H264**: AMD GPU-based acceleration
- **HEVC/H265**: Various implementations including MF HEVC, NVENC HEVC, QSV HEVC, and AMF H265

### Implementing Hardware-Accelerated Encoding

For optimal performance, it's recommended to utilize hardware acceleration when available:

```
// Check for NVIDIA encoder availability and use if present
if (NVENCH264EncoderSettings.IsAvailable())
{
    rtmpOutput.Video = new NVENCH264EncoderSettings();
}
// Fall back to OpenH264 if hardware acceleration isn't available
else
{
    rtmpOutput.Video = new OpenH264EncoderSettings();
}
```

## Audio Encoder Configuration

### Supported Audio Encoders

The SDK supports multiple AAC encoder implementations:

- **VO-AAC**: Default for non-Windows platforms
- **AVENC AAC**: Cross-platform implementation
- **MF AAC**: Default for Windows platforms

```
// Configure MF AAC encoder on Windows platforms
rtmpOutput.Audio = new MFAACEncoderSettings();

// For macOS or other platforms
rtmpOutput.Audio = new VOAACEncoderSettings();
```

## Platform-Specific Considerations

### Windows Implementation

On Windows platforms, the default configuration uses: - OpenH264 for video encoding - MF AAC for audio encoding

Additionally, Windows supports Microsoft Media Foundation HEVC encoding for high-efficiency streaming.

### macOS Implementation

For macOS applications, the system uses: - AppleMediaH264EncoderSettings for video encoding - VO-AAC for audio encoding

### Automatic Platform Detection

The SDK handles platform differences automatically through conditional compilation:

```
#if __MACOS__
    Video = new AppleMediaH264EncoderSettings();
#else
    Video = new OpenH264EncoderSettings();
#endif
```

## Best Practices for RTMP Streaming

### 1. Encoder Selection Strategy

Always verify encoder availability before attempting to use hardware acceleration:

```
// Check for Intel Quick Sync availability
if (QSVH264EncoderSettings.IsAvailable())
{
    rtmpOutput.Video = new QSVH264EncoderSettings();
}
// Check for NVIDIA acceleration
else if (NVENCH264EncoderSettings.IsAvailable())
{
    rtmpOutput.Video = new NVENCH264EncoderSettings();
}
// Fall back to software encoding
else
{
    rtmpOutput.Video = new OpenH264EncoderSettings();
}
```

### 2. Error Handling

Implement robust error handling to manage streaming failures gracefully:

```
try
{
    var rtmpOutput = new RTMPOutput(streamUrl);
    // Configure and start streaming
}
catch (Exception ex)
{
    logger.LogError($"RTMP streaming initialization failed: {ex.Message}");
    // Implement appropriate error recovery
}
```

### 3. Resource Management

Ensure proper disposal of resources when streaming is complete:

```
// RTMPOutput itself is a plain settings object and does not implement IDisposable.
// Stop and dispose the pipeline/core that owns it instead.
await core.StopAsync();
await core.DisposeAsync();  // VideoCaptureCoreX / MediaBlocksPipeline both DisposeAsync
rtmpOutput = null;
```

## Advanced RTMP Configuration

### Dynamic Encoder Selection

For applications that need to adapt to different environments, you can enumerate available encoders:

```
var rtmpOutput = new RTMPOutput();
var availableVideoEncoders = rtmpOutput.GetVideoEncoders();
var availableAudioEncoders = rtmpOutput.GetAudioEncoders();

// Present options to users or select based on system capabilities
```

### Custom Sink Configuration

Fine-tune streaming parameters using the RTMPSinkSettings class:

```
rtmpOutput.Sink = new RTMPSinkSettings
{
    Location = "rtmp://streaming-server/stream"
};
```

## Windows-Specific RTMP Implementation

[VideoCaptureCore](#) [VideoEditCore](#)

For Windows-only applications, VisioForge provides an alternative implementation using FFmpeg:

```
// Enable network streaming
VideoCapture1.Network_Streaming_Enabled = true;

// Set streaming format to RTMP using FFmpeg
VideoCapture1.Network_Streaming_Format = NetworkStreamingFormat.RTMP_FFMPEG_EXE;

// Create and configure FFmpeg output
var ffmpegOutput = new FFMPEGEXEOutput();
ffmpegOutput.FillDefaults(DefaultsProfile.MP4_H264_AAC, true);
ffmpegOutput.OutputMuxer = OutputMuxer.FLV;

// Assign output to the capture component
VideoCapture1.Network_Streaming_Output = ffmpegOutput;

// Enable audio streaming (required for many services)
VideoCapture1.Network_Streaming_Audio_Enabled = true;
```

## Streaming to Popular Platforms

### YouTube Live

```
// Format: rtmp://a.rtmp.youtube.com/live2/ + [YouTube stream key]
VideoCapture1.Network_Streaming_URL = "rtmp://a.rtmp.youtube.com/live2/xxxx-xxxx-xxxx-xxxx";
```

### Facebook Live

```
// Format: rtmps://live-api-s.facebook.com:443/rtmp/ + [Facebook stream key]
VideoCapture1.Network_Streaming_URL = "rtmps://live-api-s.facebook.com:443/rtmp/xxxx-xxxx-xxxx-xxxx";
```

### Custom RTMP Servers

```
// Connect to any RTMP server
VideoCapture1.Network_Streaming_URL = "rtmp://your-streaming-server:1935/live/stream";
```

## Performance Optimization

To achieve optimal streaming performance:

1. **Use hardware acceleration** when available to reduce CPU load
2. **Monitor resource usage** during streaming to identify bottlenecks
3. **Adjust resolution and bitrate** based on available bandwidth
4. **Implement adaptive bitrate** for varying network conditions
5. **Consider GOP size** and keyframe intervals for streaming quality

## Troubleshooting Common Issues

- **Connection Failures**: Verify server URL format and network connectivity
- **Encoder Errors**: Confirm hardware encoder availability and drivers
- **Performance Issues**: Monitor CPU/GPU usage and adjust encoding parameters
- **Audio/Video Sync**: Check timestamp synchronization settings

## Conclusion

VisioForge's RTMP implementation provides developers with a powerful, flexible framework for creating robust streaming applications. By leveraging the appropriate SDK components and following the best practices outlined in this guide, you can create high-performance streaming solutions that work across platforms and integrate with popular streaming services.

## Related Resources

- [Streaming to Adobe Flash Media Server](../adobe-flash/)
- [YouTube Streaming Integration](../youtube/)
- [Facebook Live Implementation](../facebook/)

---END OF PAGE---


## Build RTSP Server in C# .NET — H.264/HEVC + GPU Encoding
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/rtsp/
**Description:** Build an RTSP server with H.264/AAC encoding, GPU acceleration (NVENC, QSV, AMF), authentication, and latency tuning. VisioForge SDK cross-platform examples.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, DirectShow, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Streaming, Encoding, Editing, IP Camera, RTSP, ONVIF, UDP, WebRTC, MP4, H.264, H.265, AAC, C#
**API:** VideoCaptureCoreX, VideoEditCoreX, RTSPServerOutput, RTSPServerSettings, RTSPServerBlock

# Mastering RTSP Streaming with VisioForge SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Cross-platform support

The `VideoCaptureCoreX` engine and the Media Blocks SDK run on **Windows, macOS, Linux, Android, and iOS** via GStreamer. See the [platform support matrix](../../../platform-matrix/) for codec and hardware-acceleration details, and the [Linux deployment guide](../../../deployment-x/Ubuntu/) for Ubuntu / NVIDIA Jetson / Raspberry Pi setup.

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Introduction to RTSP

The Real-Time Streaming Protocol (RTSP) is a network control protocol designed for use in entertainment and communications systems to control streaming media servers. It acts like a "network remote control," allowing users to play, pause, and stop media streams. VisioForge SDKs harness the power of RTSP to provide robust video and audio streaming capabilities.

Our SDKs integrate RTSP with industry-standard codecs like **H.264 (AVC)** for video and **Advanced Audio Coding (AAC)** for audio. H.264 offers excellent video quality at relatively low bitrates, making it ideal for streaming over various network conditions. AAC provides efficient and high-fidelity audio compression. This powerful combination ensures reliable, high-definition audiovisual streaming suitable for demanding applications such as:

- **Security and Surveillance:** Delivering clear, real-time video feeds from IP cameras.
- **Live Broadcasting:** Streaming events, webinars, or performances to a wide audience.
- **Video Conferencing:** Enabling smooth, high-quality communication.
- **Remote Monitoring:** Observing industrial processes or environments remotely.

This guide delves into the specifics of implementing RTSP streaming using VisioForge SDKs, covering both modern cross-platform approaches and legacy Windows-specific methods.

## Cross-Platform RTSP Output (Recommended)

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The modern VisioForge SDKs (`CoreX` versions and Media Blocks) provide a flexible and powerful cross-platform RTSP server implementation built upon the robust GStreamer framework. This approach offers greater control, wider codec support, and compatibility across Windows, Linux, macOS, and other platforms.

### Core Component: `RTSPServerOutput`

The `RTSPServerOutput` class is the central configuration point for establishing an RTSP stream within the Video Capture or Video Edit SDKs (`CoreX` versions). It acts as a bridge between your capture/edit pipeline and the underlying RTSP server logic.

**Key Responsibilities:**

- **Interface Implementation:** Implements `IVideoEditXBaseOutput` and `IVideoCaptureXBaseOutput`, allowing seamless integration as an output format in both editing and capture scenarios.
- **Settings Management:** Holds the `RTSPServerSettings` object, which contains all the detailed configuration parameters for the server instance.
- **Codec Specification:** Defines the video and audio encoders that will be used to compress the media before streaming.

**Supported Encoders:**

VisioForge provides access to a wide array of encoders, allowing optimization based on hardware capabilities and target platforms:

- **Video Encoders:**
  - **Hardware-Accelerated (Recommended for performance):**
    - `NVENC` (NVIDIA): Leverages dedicated encoding hardware on NVIDIA GPUs.
    - `QSV` (Intel Quick Sync Video): Utilizes integrated GPU capabilities on Intel processors.
    - `AMF` (AMD Advanced Media Framework): Uses encoding hardware on AMD GPUs/APUs.
  - **Software-Based (Platform-independent, higher CPU usage):**
    - `OpenH264`: A widely compatible H.264 software encoder.
    - `VP8` / `VP9`: Royalty-free video codecs developed by Google, offering good compression (often used with WebRTC, but available here).
  - **Platform-Specific:**
    - `MF HEVC` (Media Foundation HEVC): Windows-specific H.265/HEVC encoder for higher efficiency compression.
- **Audio Encoders:**
  - **AAC Variants:**
    - `VO-AAC`: A versatile, cross-platform AAC encoder.
    - `AVENC AAC`: Utilizes FFmpeg's AAC encoder.
    - `MF AAC`: Windows Media Foundation AAC encoder.
  - **Other Formats:**
    - `MP3`: Widely compatible but less efficient than AAC.
    - `OPUS`: Excellent low-latency codec, ideal for interactive applications.

### Configuring the Stream: `RTSPServerSettings`

This class encapsulates all the parameters needed to define the behavior and properties of your RTSP server.

**Detailed Properties:**

- **Network Configuration:**
  - `Port` (int): The TCP port the server listens on for incoming RTSP connections. The default is `8554`, a common alternative to the standard (often restricted) port 554. Ensure this port is open in firewalls.
  - `Address` (string): The IP address the server binds to.
    - `"127.0.0.1"` (Default): Listens only for connections from the local machine.
    - `"0.0.0.0"`: Listens on all available network interfaces (use for public access).
    - Specific IP (e.g., `"192.168.1.100"`): Binds only to that specific network interface.
  - `Point` (string): The path component of the RTSP URL (e.g., `/live`, `/stream1`). Clients will connect to `rtsp://<Address>:<Port><Point>`. Default is `"/live"`.
- **Stream Configuration:**
  - `VideoEncoder` (IVideoEncoder): An `IVideoEncoder` instance — typically an encoder-settings object (e.g., `OpenH264EncoderSettings`) or the result of `H264EncoderBlock.GetDefaultSettings()`. Defines codec, bitrate (Kbit/s), quality, etc.
  - `AudioEncoder` (IAudioEncoder): An `IAudioEncoder` instance (e.g., `VOAACEncoderSettings`). Defines audio codec parameters.
  - `Latency` (TimeSpan): Controls the buffering delay introduced by the server to smooth out network jitter. Default is 250 milliseconds. Higher values increase stability but also delay.
- **Authentication:**
  - `Username` (string): If set, clients must provide this username for basic authentication.
  - `Password` (string): If set, clients must provide this password along with the username.
- **Server Identity:**
  - `Name` (string): A friendly name for the server, sometimes displayed by client applications.
  - `Description` (string): A more detailed description of the stream content or server purpose.
- **Convenience Property:**
  - `URL` (string, read-only): Automatically composes the full RTSP connection URL from `Address`, `Port`, and `Point`. With `RTSPServerSettings` defaults (`Port = 8554`), the composed URL is `rtsp://127.0.0.1:8554/live`.

### The Engine: `RTSPServerBlock` (Media Blocks SDK)

When using the Media Blocks SDK, the `RTSPServerBlock` represents the actual GStreamer-based element that performs the streaming.

**Functionality:**

- **Media Sink:** Acts as a terminal point (sink) in a media pipeline, receiving encoded video and audio data.
- **Input Pads:** Provides distinct `VideoInput` and `AudioInput` pads for connecting upstream video and audio sources/encoders.
- **GStreamer Integration:** Manages the underlying GStreamer `rtspserver` and related elements necessary for handling client connections and streaming RTP packets.
- **Availability Check:** The static `IsAvailable()` method allows checking if the necessary GStreamer plugins for RTSP streaming are present on the system.
- **Resource Management:** Implements `IDisposable` for proper cleanup of network sockets and GStreamer resources when the block is no longer needed.

### Practical Usage Examples

#### Example 1: Basic Server Setup (VideoCaptureCoreX / VideoEditCoreX)

```
// 1. Choose and configure encoders

// Use hardware acceleration if available, otherwise fallback to software
var videoEncoder = H264EncoderBlock.GetDefaultSettings();

var audioEncoder = new VOAACEncoderSettings(); // Reliable cross-platform AAC

// 2. Configure server network settings
var settings = new RTSPServerSettings(videoEncoder, audioEncoder)
{
    Port = 8554,
    Address = "0.0.0.0",  // Accessible from other machines on the network
    Point = "/livefeed"
};

// 3. Create the output object
var rtspOutput = new RTSPServerOutput(settings);

// 4. Integrate with the SDK engine
// For VideoCaptureCoreX:
// videoCapture is an initialized instance of VideoCaptureCoreX
videoCapture.Outputs_Add(rtspOutput);

// For VideoEditCoreX:
// videoEdit is an initialized instance of VideoEditCoreX
// videoEdit.Output_Format = rtspOutput; // Set before starting editing/playback
```

#### Example 2: Media Blocks Pipeline

```
// Assume 'pipeline' is an initialized MediaBlocksPipeline
// Assume 'videoSource' and 'audioSource' provide unencoded media streams

// 1. Create video and audio encoder settings
var videoEncoder = H264EncoderBlock.GetDefaultSettings();

var audioEncoder = new VOAACEncoderSettings();

// 2. Create RTSP server settings with a specific URL
var serverUri = new Uri("rtsp://192.168.1.50:8554/cam1");
var rtspSettings = new RTSPServerSettings(serverUri, videoEncoder, audioEncoder)
{
    Description = "Camera Feed 1 - Warehouse"
};

// 3. Create the RTSP Server Block
if (!RTSPServerBlock.IsAvailable())
{
    Console.WriteLine("RTSP Server components not available. Check GStreamer installation.");
    return;
}
var rtspSink = new RTSPServerBlock(rtspSettings);

// Connect source directly to RTSP server block, because server block will use its own encoders
pipeline.Connect(videoSource.Output, rtspSink.VideoInput); // Connect source directly to video input of RTSP server block
pipeline.Connect(audioSource.Output, rtspSink.AudioInput); // Connect source directly to audio input of RTSP server block

// Start the pipeline
await pipeline.StartAsync();
```

#### Example 3: Advanced Configuration with Authentication

```
// Using settings from Example 1...
var secureSettings = new RTSPServerSettings(videoEncoder, audioEncoder)
{
    Port = 8555, // Use a different port
    Address = "192.168.1.100", // Bind to a specific internal IP
    Point = "/secure",
    Username = "viewer",
    Password = "VerySecretPassword!",
    Latency = TimeSpan.FromMilliseconds(400), // Slightly higher latency
    Name = "SecureStream",
    Description = "Authorized access only"
};

var secureRtspOutput = new RTSPServerOutput(secureSettings);

// Add to VideoCaptureCoreX or set for VideoEditCoreX as before
// videoCapture.Outputs_Add(secureRtspOutput);
```

### Streaming Best Practices

1. **Encoder Selection Strategy:**
   - **Prioritize Hardware:** Always prefer hardware encoders (NVENC, QSV, AMF) when available on the target system. They drastically reduce CPU load, allowing for higher resolutions, frame rates, or more simultaneous streams.
   - **Software Fallback:** Use `OpenH264` as a reliable software fallback for broad compatibility when hardware acceleration isn't present or suitable.
   - **Codec Choice:** H.264 remains the most widely compatible codec for RTSP clients. HEVC offers better compression but client support might be less universal.
2. **Latency Tuning:**
   - **Interactivity vs. Stability:** Lower latency (e.g., 100-200ms) is crucial for applications like video conferencing but makes the stream more susceptible to network hiccups.
   - **Broadcast/Surveillance:** Higher latency (e.g., 500ms-1000ms+) provides larger buffers, improving stream resilience over unstable networks (like Wi-Fi or the internet) at the cost of increased delay. Start with the default (250ms) and adjust based on observed stream quality and requirements.
3. **Network Configuration:**
   - **Security First:** Implement `Username` and `Password` authentication for any stream not intended for public anonymous access.
   - **Binding Address:** Use `"0.0.0.0"` cautiously. For enhanced security, bind explicitly to the network interface (`Address`) intended for client connections if possible.
   - **Firewall Rules:** Meticulously configure system and network firewalls to allow incoming TCP connections on the chosen RTSP `Port`. Also, remember that RTP/RTCP (used for the actual media data) often use dynamic UDP ports; firewalls might need helper modules (like `nf_conntrack_rtsp` on Linux) or broad UDP port ranges opened (less secure).
4. **Resource Management:**
   - **Dispose Pattern:** RTSP server instances hold network resources (sockets) and potentially complex GStreamer pipelines. *Always* ensure they are disposed of correctly using `using` statements or explicit `.Dispose()` calls in `finally` blocks to prevent resource leaks.
   - **Graceful Shutdown:** When stopping the capture or edit process, ensure the output is properly removed or the pipeline is stopped cleanly to allow the RTSP server to shut down gracefully.

### Performance Considerations

Optimizing RTSP streaming involves balancing quality, latency, and resource usage:

1. **Encoder Impact:** This is often the biggest factor.
   - **Hardware:** Significantly lower CPU usage, higher potential throughput. Requires compatible hardware and drivers.
   - **Software:** High CPU load, especially at higher resolutions/framerates. Limits the number of concurrent streams on a single machine but works universally.
2. **Latency vs. Bandwidth:** Lower latency settings can sometimes lead to increased peak bandwidth usage as the system has less time to smooth out data transmission.
3. **Resource Monitoring:**
   - **CPU:** Keep a close eye on CPU usage, particularly with software encoders. Overload leads to dropped frames and stuttering.
   - **Memory:** Monitor RAM usage, especially if handling multiple streams or complex Media Blocks pipelines.
   - **Network:** Ensure the server's network interface has sufficient bandwidth for the configured bitrate, resolution, and number of connected clients. Calculate required bandwidth (Video Bitrate + Audio Bitrate) \* Number of Clients.

## Windows-Only RTSP Output (Legacy)

[VideoCaptureCore](#) [VideoEditCore](#)

The implementation includes several error handling mechanisms:

Older versions of the SDK (`VideoCaptureCore`, `VideoEditCore`) included a simpler, Windows-specific RTSP output mechanism. While functional, it offers less flexibility and codec support compared to the cross-platform `RTSPServerOutput`. **It is generally recommended to use the `CoreX` / Media Blocks approach for new projects.**

### How it Works

This method leverages built-in Windows components or specific bundled filters. Configuration is done directly via properties on the `VideoCaptureCore` or `VideoEditCore` object.

### Sample Configuration Code

```
using VisioForge.Core.Types.Output;           // MP4Output, NetworkStreamingFormat, H264Profile
using VisioForge.Core.Types.VideoCapture;
using VisioForge.Core.VideoCapture;           // VideoCaptureCore

// Assuming VideoCapture1 is an instance of VideoCaptureCore already bound to a VideoView.

// 1. Enable network streaming globally for the component
VideoCapture1.Network_Streaming_Enabled = true;

// 2. Enable audio streaming (optional)
VideoCapture1.Network_Streaming_Audio_Enabled = true;

// 3. Select the RTSP format.
//    RTSP_H264_AAC_SW = software H.264 + AAC (DirectShow-based Windows RTSP).
VideoCapture1.Network_Streaming_Format = NetworkStreamingFormat.RTSP_H264_AAC_SW;

// 4. Configure encoder settings. MP4Output holds the H.264 and AAC parameters
//    even though the stream is sent over RTSP rather than written to a file.
var mp4Output = new MP4Output();

//    H.264 settings live on MP4Output.Video (MP4OutputH264Settings).
mp4Output.Video = new MP4OutputH264Settings
{
    Bitrate = 2000,                // kbps
    Profile = H264Profile.ProfileMain,
    Level = H264Level.Level4,
    RateControl = H264RateControl.VBR
};

//    AAC settings live on MP4Output.Audio_AAC (M4AOutput — already initialised in the constructor).
mp4Output.Audio_AAC.Bitrate = 128;      // kbps
mp4Output.Audio_AAC.Object = AACObject.Low;
mp4Output.Audio_AAC.Version = AACVersion.MPEG4;

// 5. Assign the settings container to the network streaming output
VideoCapture1.Network_Streaming_Output = mp4Output;

// 6. Define the RTSP URL clients will use.
//    The server listens on the port specified in the URL (5554 here).
VideoCapture1.Network_Streaming_URL = "rtsp://localhost:5554/vfstream";
//    Use the machine's actual IP instead of localhost for external access.

// 7. Start as usual (OnError fires if the port is busy or encoders are unavailable).
await VideoCapture1.StartAsync();
```

**Note:** This legacy method often relies on DirectShow filters or Media Foundation transforms available on the specific Windows system, making it less predictable and portable than the GStreamer-based cross-platform solution.

## See also

- [RTSP reconnection and fallback switch](../../network-sources/reconnection-and-fallback/) — handle camera disconnects with reconnect events, `DisconnectEventInterval`, and the declarative `FallbackSwitch` (image / text / media fallback) across all VisioForge SDKs
- [RTSP camera source configuration in C#](../../../videocapture/video-sources/ip-cameras/rtsp/) — `IPCameraSourceSettings` and `RTSPSourceSettings` reference with UDP/TCP transport and buffer tuning
- [ONVIF IP camera integration](../../../videocapture/video-sources/ip-cameras/onvif/) — WS-Discovery, profile selection, and PTZ control for standards-based cameras
- [IP camera live preview tutorial](../../../videocapture/video-tutorials/ip-camera-preview/) — video walkthrough for a minimal preview implementation
- [Record RTSP stream to MP4](../../../videocapture/video-tutorials/ip-camera-capture-mp4/) — capture any IP camera to MP4 file in .NET
- [Media Blocks RTSP player](../../../mediablocks/Guides/rtsp-player-csharp/) — pipeline-based RTSP playback with the Media Blocks SDK
- [RTSP server output block](../../../mediablocks/RTSPServer/) — broadcast your own video and audio stream over RTSP
- [Multi-camera RTSP grid (NVR wall)](../../../mediablocks/Guides/multi-camera-rtsp-grid/) — build a 4×4 live preview wall with WPF or MAUI, with synchronized start
- [Pre-Event Recording with IP Camera](../../../mediablocks/Guides/pre-event-recording/) — record RTSP streams with circular buffer and motion detection triggers
- [Save Original RTSP Stream](../../../mediablocks/Guides/rtsp-save-original-stream/) — save RTSP video without re-encoding
- [Barcode & QR Code Scanner](../../../mediablocks/Guides/barcode-qr-reader-guide/) — scan barcodes from RTSP IP camera streams in real time

---

For more detailed examples and advanced use cases, explore the code samples provided in our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples). For brand-specific RTSP URLs, see our [IP camera brands directory](../../../camera-brands/).

---END OF PAGE---


## SRT Streaming in C# .NET - Send and Receive Video over IP
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/srt/
**Description:** Stream and receive video over SRT protocol in C# .NET with caller/listener modes, AES encryption, and MPEG-TS multiplexing. Includes SDK code examples.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, Webcam, IP Camera, NDI, SRT, TS, H.264, H.265, AAC, C#
**API:** SRTSinkSettings, SRTMPEGTSSinkBlock, MediaBlocksPipeline, SRTSourceSettings, SRTSourceBlock

# SRT Streaming Implementation Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## What is SRT?

SRT (Secure Reliable Transport) is a streaming protocol designed for low-latency, high-quality video delivery across unreliable networks. It provides built-in error recovery, AES encryption, and firewall traversal — making it ideal for:

- Live broadcasting over the internet
- Contribution feeds between production facilities
- Remote camera backhaul over cellular or satellite links
- Secure point-to-point video transport
- Cloud-based video ingest and distribution

The VisioForge .NET SDKs support both sending and receiving SRT streams across Windows, macOS, and Linux. SRT streams use MPEG-TS multiplexing to carry video and audio together.

You can check SRT availability at runtime:

```
bool srtAvailable = SRTSinkBlock.IsAvailable(); // for sending
bool srtSourceAvailable = SRTSourceBlock.IsAvailable(); // for receiving
```

## SRT Connection Modes

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

SRT supports three connection modes via the `SRTConnectionMode` enum:

| Mode | Description | Use Case |
| --- | --- | --- |
| **Caller** | Connects to a remote listener | Client connecting to a server |
| **Listener** | Waits for incoming connections on a port | Server accepting connections |
| **Rendezvous** | Both sides connect simultaneously | Peer-to-peer, firewall traversal |

### Listener (Server) Mode

The listener waits for incoming SRT connections on a specified port:

```
var sinkSettings = new SRTSinkSettings
{
    Uri = "srt://:8888",
    Mode = SRTConnectionMode.Listener
};
```

### Caller (Client) Mode

The caller connects to a remote SRT listener:

```
// SRTSourceSettings has a private ctor — use the CreateAsync factory. Uri is System.Uri, not string.
var sourceSettings = await SRTSourceSettings.CreateAsync(new Uri("srt://192.168.1.100:8888"));
sourceSettings.Mode = SRTConnectionMode.Caller;
```

### Rendezvous Mode

Both endpoints connect simultaneously — useful when both sides are behind firewalls:

```
var settings = new SRTSinkSettings
{
    Uri = "srt://remote-host:8888",
    Mode = SRTConnectionMode.Rendezvous,
    LocalPort = 8888
};
```

## Basic SRT Output

### Video Capture SDK

```
// Initialize SRT output with destination URL
var srtOutput = new SRTOutput("srt://streaming-server:1234");

// Add the configured SRT output to your capture engine
videoCapture.Outputs_Add(srtOutput, true);  // videoCapture is a VideoCaptureCoreX instance
```

### Media Blocks SDK

The `SRTMPEGTSSinkBlock` multiplexes video and audio into an MPEG-TS container and sends over SRT:

```
// Create an SRT MPEG-TS sink in listener mode
var srtSink = new SRTMPEGTSSinkBlock(new SRTSinkSettings { Uri = "srt://:8888" });

// Connect video encoder output to the SRT sink
pipeline.Connect(h264Encoder.Output, srtSink.CreateNewInput(MediaBlockPadMediaType.Video));

// Connect audio encoder output to the SRT sink
pipeline.Connect(aacEncoder.Output, srtSink.CreateNewInput(MediaBlockPadMediaType.Audio));
```

## Streaming a Camera to SRT

[MediaBlocksPipeline](#)

This complete example captures from a webcam and microphone, encodes to H.264/AAC, and streams over SRT:

### Pipeline Architecture

```
SystemVideoSourceBlock → H264EncoderBlock → SRTMPEGTSSinkBlock (video input)
SystemAudioSourceBlock → AACEncoderBlock  → SRTMPEGTSSinkBlock (audio input)
```

### Code Example

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.MediaBlocks.AudioEncoders;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.Types.X.VideoEncoders;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;

// Initialize SDK once at startup
await VisioForgeX.InitSDKAsync();

var pipeline = new MediaBlocksPipeline();

// Enumerate devices
var videoDevices = await DeviceEnumerator.Shared.VideoSourcesAsync();
var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync();

// Video source (first camera)
var videoSource = new SystemVideoSourceBlock(
    new VideoCaptureDeviceSourceSettings(videoDevices[0]));

// Audio source (first microphone)
var audioSource = new SystemAudioSourceBlock(
    new AudioCaptureDeviceSourceSettings(audioDevices[0]));

// Video encoder — H.264 with hardware fallback
var h264Encoder = new H264EncoderBlock(new OpenH264EncoderSettings());

// Audio encoder — AAC
var aacEncoder = new AACEncoderBlock(new VOAACEncoderSettings());

// SRT output in listener mode on port 8888
var srtSink = new SRTMPEGTSSinkBlock(new SRTSinkSettings
{
    Uri = "srt://:8888",
    Mode = SRTConnectionMode.Listener,
    Latency = TimeSpan.FromMilliseconds(125)
});

// Build pipeline: camera → encoder → SRT
pipeline.Connect(videoSource.Output, h264Encoder.Input);
pipeline.Connect(h264Encoder.Output, srtSink.CreateNewInput(MediaBlockPadMediaType.Video));

pipeline.Connect(audioSource.Output, aacEncoder.Input);
pipeline.Connect(aacEncoder.Output, srtSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

Receivers can connect using `ffplay srt://your-ip:8888` or any SRT-compatible player.

## Receiving an SRT Stream

[MediaBlocksPipeline](#)

Use `SRTSourceBlock` to receive and play an SRT stream with automatic decoding:

```
var pipeline = new MediaBlocksPipeline();

// Connect to an SRT sender (caller mode by default)
var sourceSettings = await SRTSourceSettings.CreateAsync(new Uri("srt://192.168.1.100:8888"));
var srtSource = new SRTSourceBlock(sourceSettings);

// Video renderer
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(srtSource.VideoOutput, videoRenderer.Input);

// Audio renderer
var audioRenderer = new AudioRendererBlock();
pipeline.Connect(srtSource.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

For passthrough recording without decoding (e.g., saving the raw MPEG-TS stream), use `SRTRAWSourceBlock` instead.

## Encryption

SRT supports AES encryption with 128, 192, or 256-bit keys. Both sender and receiver must use the same passphrase and key length.

### Sender (Encrypted)

```
var sinkSettings = new SRTSinkSettings
{
    Uri = "srt://:8888",
    Mode = SRTConnectionMode.Listener,
    Passphrase = "my-secret-passphrase",  // minimum 10 characters
    PbKeyLen = SRTKeyLength.Length32       // 256-bit AES
};
```

### Receiver (Encrypted)

```
// Use the async factory — SRTSourceSettings has a private ctor; Uri is System.Uri, not string.
var sourceSettings = await SRTSourceSettings.CreateAsync(new Uri("srt://192.168.1.100:8888"));
sourceSettings.Mode = SRTConnectionMode.Caller;
sourceSettings.Passphrase = "my-secret-passphrase";
sourceSettings.PbKeyLen = SRTKeyLength.Length32;
```

Available key lengths: `SRTKeyLength.NoKey` (disabled), `Length16` (128-bit), `Length24` (192-bit), `Length32` (256-bit).

## Latency Configuration

The `Latency` property controls the SRT receiver buffer size (default: 125ms). Lower values reduce delay but increase sensitivity to network jitter:

```
// Low-latency for local network
var settings = new SRTSinkSettings
{
    Uri = "srt://:8888",
    Latency = TimeSpan.FromMilliseconds(50)
};

// Higher latency for unreliable networks (internet streaming)
var settings = new SRTSinkSettings
{
    Uri = "srt://:8888",
    Latency = TimeSpan.FromMilliseconds(500)
};
```

| Network | Recommended Latency | Notes |
| --- | --- | --- |
| Local LAN | 20–80ms | Minimal jitter |
| Reliable internet | 125ms (default) | Good balance |
| Unreliable/long-distance | 250–1000ms | Prevents drops |

## Video Encoding Options

### Software Encoders

- **OpenH264** — Default cross-platform H.264 encoder

### Hardware-Accelerated Encoders

- **NVIDIA NVENC** (H.264/HEVC) — GPU-accelerated encoding on NVIDIA cards
- **Intel Quick Sync** (H.264/HEVC) — Intel integrated GPU acceleration
- **AMD AMF** (H.264/HEVC) — AMD GPU acceleration
- **Microsoft Media Foundation HEVC** — Windows-only hardware encoder

### Encoder Selection with Fallback

```
if (NVENCH264EncoderSettings.IsAvailable())
{
    srtOutput.Video = new NVENCH264EncoderSettings();
}
else
{
    srtOutput.Video = new OpenH264EncoderSettings();
}
```

## Audio Encoding

SRT streams typically use AAC audio. The SDK provides multiple encoders:

- **VO-AAC** — Cross-platform, consistent performance
- **AVENC AAC** — FFmpeg-based with extensive options
- **MF AAC** — Windows-only, Microsoft Media Foundation

The SDK auto-selects the best available encoder per platform (MF AAC on Windows, VO AAC elsewhere).

## Troubleshooting

### Unable to Establish SRT Connection

**Symptom:** Connection times out or is refused.

**Solutions:**

- Verify the SRT URL format: `srt://host:port` for caller, `srt://:port` for listener
- Ensure the port is open in firewalls on both sides
- Confirm both sides use matching connection modes (one caller, one listener)
- Check that passphrases match if encryption is enabled

### High CPU Usage or Dropped Frames

**Symptom:** Performance degrades during streaming.

**Solutions:**

- Switch to hardware-accelerated encoders (NVENC, QSV, AMF)
- Reduce resolution or bitrate
- Increase the `Latency` value to give more buffer room

### Encoder Fails to Initialize

**Symptom:** Exception when starting the pipeline.

**Solutions:**

- Use `IsAvailable()` to check encoder support before creating it
- Verify GPU drivers are up to date for hardware encoders
- Fall back to OpenH264 as a universal software encoder

## Frequently Asked Questions

### What is the difference between SRT caller and listener mode?

The **listener** binds to a port and waits for incoming connections — it acts as the server. The **caller** initiates the connection to a listener's address and port — it acts as the client. For firewall traversal where both sides are behind NAT, use **rendezvous** mode where both endpoints connect simultaneously.

### How do I encrypt an SRT stream?

Set the `Passphrase` property (minimum 10 characters) and `PbKeyLen` on both `SRTSinkSettings` and `SRTSourceSettings`. Both sender and receiver must use identical values. Available key lengths are 128-bit (`Length16`), 192-bit (`Length24`), and 256-bit (`Length32`). See the [Encryption](#encryption) section for code examples.

### How do I receive and play an SRT stream in C#?

Create `SRTSourceSettings` with the sender's URL, then pass it to `SRTSourceBlock`. Connect `VideoOutput` to a `VideoRendererBlock` and `AudioOutput` to an `AudioRendererBlock`. The source block handles MPEG-TS demuxing and decoding automatically. See the [Receiving an SRT Stream](#receiving-an-srt-stream) section for the complete example.

### What video codecs does SRT support?

SRT itself is codec-agnostic — it transports any data over the wire. When using `SRTMPEGTSSinkBlock`, the stream is multiplexed as MPEG-TS, which supports H.264, HEVC (H.265), MPEG-2, and AV1 video codecs. H.264 is the most widely compatible choice for SRT streaming.

### How do I reduce SRT streaming latency?

Lower the `Latency` property on both sender and receiver settings (default is 125ms). For local networks, values as low as 20–50ms work well. For internet streaming, keep at least 125ms to handle jitter. Also ensure your encoder is configured for low-latency mode and that you're using hardware acceleration to minimize encoding delay.

## See Also

- [NDI Streaming Integration](../ndi/) — NDI video-over-IP streaming
- [RTSP Stream Viewer and IP Camera Player](../../../mediablocks/Guides/rtsp-player-csharp/) — RTSP camera streaming guide
- [MPEG-TS Output Format](../../output-formats/mpegts/) — MPEG-TS container configuration
- [Deployment Guide](../../../deployment-x/) — platform-specific runtime packages
- [Code Samples on GitHub](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK) — SRT source demo
- [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) — product page and downloads

---END OF PAGE---


## UDP Video Streaming with MPEG-TS Container in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/udp/
**Description:** Stream H.264/HEVC video over UDP in C# / .NET — multicast, point-to-point, low-latency configs. Full send/receive code samples with bitrate tuning.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCore, VideoEditCore, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Streaming, Encoding, Editing, UDP, MP4, TS, H.264, H.265, AAC, C#
**API:** FFMPEGEXEOutput, BasicVideoSettings, MediaBlockPadMediaType, MediaBlocksPipeline, UDPMPEGTSSinkBlock, UDPSinkSettings, MultiUDPMPEGTSSinkBlock

# UDP Streaming with VisioForge SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Introduction to UDP Streaming

The User Datagram Protocol (UDP) is a lightweight, connectionless transport protocol that provides a simple interface between network applications and the underlying IP network. Unlike TCP, UDP offers minimal overhead and doesn't guarantee packet delivery, making it ideal for real-time applications where speed is crucial and occasional packet loss is acceptable.

VisioForge SDKs offer robust support for UDP streaming, enabling developers to implement high-performance, low-latency streaming solutions for various applications, including live broadcasts, video surveillance, and real-time communication systems.

## Key Features and Capabilities

The VisioForge SDK suite provides comprehensive UDP streaming functionality with the following key features:

### Video and Audio Codec Support

- **Video Codecs**: Full support for H.264 (AVC) and H.265 (HEVC), offering excellent compression efficiency while maintaining high video quality.
- **Audio Codec**: Advanced Audio Coding (AAC) support, providing superior audio quality at lower bitrates compared to older audio codecs.

### MPEG Transport Stream (MPEG-TS)

The SDK utilizes MPEG-TS as the container format for UDP streaming. MPEG-TS offers several advantages:

- Designed specifically for transmission over potentially unreliable networks
- Built-in error correction capabilities
- Support for multiplexing multiple audio and video streams
- Low latency characteristics ideal for live streaming

### FFMPEG Integration

VisioForge SDKs leverage the power of FFMPEG for UDP streaming, ensuring:

- High performance encoding and streaming
- Wide compatibility with various networks and receiving clients
- Reliable packet handling and stream management

### Unicast and Multicast Support

- **Unicast**: Point-to-point transmission from a single sender to a single receiver
- **Multicast**: Efficient distribution of the same content to multiple recipients simultaneously without duplicating bandwidth at the source

## Technical Implementation Details

UDP streaming in VisioForge SDKs involves several key technical components:

1. **Video Encoding**: Source video is compressed using H.264 or HEVC encoders with configurable parameters for bitrate, resolution, and frame rate.
2. **Audio Encoding**: Audio streams are processed through AAC encoders with adjustable quality settings.
3. **Multiplexing**: Video and audio streams are combined into a single MPEG-TS container.
4. **Packetization**: The MPEG-TS stream is divided into UDP packets of appropriate size for network transmission.
5. **Transmission**: Packets are sent over the network to specified unicast or multicast addresses.

The implementation prioritizes low latency while maintaining sufficient quality for professional applications. Advanced buffering mechanisms help manage network jitter and ensure smooth playback at the receiving end.

## Windows-only UDP Output Implementation

[VideoCaptureCore](#) [VideoEditCore](#)

### Step 1: Enable Network Streaming

The first step is to enable network streaming functionality in your application. This is done by setting the `Network_Streaming_Enabled` property to true:

```
VideoCapture1.Network_Streaming_Enabled = true;
```

### Step 2: Configure Audio Streaming (Optional)

If your application requires audio streaming alongside video, enable it with:

```
VideoCapture1.Network_Streaming_Audio_Enabled = true;
```

### Step 3: Set the Streaming Format

Specify UDP as the streaming format by setting the `Network_Streaming_Format` property to `UDP_FFMPEG_EXE`:

```
VideoCapture1.Network_Streaming_Format = NetworkStreamingFormat.UDP_FFMPEG_EXE;
```

### Step 4: Configure the UDP Stream URL

Set the destination URL for your UDP stream. For a basic unicast stream to localhost:

```
VideoCapture1.Network_Streaming_URL = "udp://127.0.0.1:10000?pkt_size=1316";
```

The `pkt_size` parameter defines the UDP packet size. The value 1316 is optimized for most network environments, allowing for efficient transmission while minimizing fragmentation.

### Step 5: Multicast Configuration (Optional)

For multicast streaming to multiple receivers, use a multicast address (typically in the range 224.0.0.0 to 239.255.255.255):

```
VideoCapture1.Network_Streaming_URL = "udp://239.101.101.1:1234?ttl=1&pkt_size=1316";
```

The additional parameters include: - **ttl**: Time-to-live value that determines how many network hops the packets can traverse - **pkt\_size**: Packet size as explained above

### Step 6: Configure Output Settings

Finally, configure the streaming output parameters using the `FFMPEGEXEOutput` class:

```
var ffmpegOutput = new FFMPEGEXEOutput();

ffmpegOutput.FillDefaults(DefaultsProfile.MP4_H264_AAC, true);
ffmpegOutput.OutputMuxer = OutputMuxer.MPEGTS;

VideoCapture1.Network_Streaming_Output = ffmpegOutput;
```

This code: 1. Creates a new FFMPEG output configuration 2. Applies default settings for H.264 video and AAC audio 3. Specifies MPEG-TS as the container format 4. Assigns this configuration to the streaming output

## Cross-platform UDP Output with Media Blocks

[MediaBlocksPipeline](#)

The Media Blocks SDK provides cross-platform UDP streaming support using GStreamer-based blocks. These blocks work on Windows, macOS, Linux, iOS, and Android.

### Single-destination MPEG-TS Streaming

Use `UDPMPEGTSSinkBlock` to multiplex audio and video into MPEG-TS and send over UDP to a single destination:

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("input.mp4"));

var videoEncoder = new H264EncoderBlock(new OpenH264EncoderSettings());
var audioEncoder = new AACEncoderBlock(new AVENCAACEncoderSettings() { Bitrate = 192 });

pipeline.Connect(fileSource.VideoOutput, videoEncoder.Input);
pipeline.Connect(fileSource.AudioOutput, audioEncoder.Input);

var udpSettings = new UDPSinkSettings
{
    Host = "192.168.1.100",
    Port = 5004,
    TTL = 64
};

var udpSink = new UDPMPEGTSSinkBlock(udpSettings);
pipeline.Connect(videoEncoder.Output, udpSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(audioEncoder.Output, udpSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

### Multi-destination MPEG-TS Streaming

Use `MultiUDPMPEGTSSinkBlock` to send the same MPEG-TS stream to multiple receivers simultaneously:

```
var multiUdpSettings = new MultiUDPSinkSettings();
multiUdpSettings.AddClient("192.168.1.100", 5004);
multiUdpSettings.AddClient("192.168.1.101", 5004);

var multiUdpSink = new MultiUDPMPEGTSSinkBlock(multiUdpSettings);
pipeline.Connect(videoEncoder.Output, multiUdpSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(audioEncoder.Output, multiUdpSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

### Multicast Streaming

For multicast delivery, set the `Host` to a multicast address (224.0.0.0 – 239.255.255.255):

```
var udpSettings = new UDPSinkSettings
{
    Host = "239.101.101.1",
    Port = 5004,
    MulticastTTL = 4,
    AutoMulticast = true
};
```

### Receiving UDP Streams

You can verify the stream using GStreamer command-line tools:

```
gst-launch-1.0 udpsrc port=5004 ! tsdemux ! decodebin ! autovideosink
```

Or receive with VLC:

```
vlc udp://@:5004
```

## Advanced Configuration Options

### Bitrate Management

For optimal streaming performance, adjust the video and audio bitrates to match your network capacity. `FFMPEGEXEOutput` exposes the encoder knobs via `.Video` and `.Audio` (not `VideoSettings`/`AudioSettings`), and the underlying `BasicVideoSettings` / `BasicAudioSettings` store bitrate in **kbps**:

```
ffmpegOutput.Video.Bitrate = 2500; // 2.5 Mbps for video (kbps)
ffmpegOutput.Audio.Bitrate = 128;  // 128 kbps for audio
```

### Resolution and Frame Rate

Lower resolutions reduce bandwidth. Set the target size inside `VideoCapture1.Video_Resize` (the classic engine exposes it as an `IVideoResizeSettings` object, not flat properties on the core), and enable the resize stage with `Video_ResizeOrCrop_Enabled`:

```
VideoCapture1.Video_ResizeOrCrop_Enabled = true;
VideoCapture1.Video_Resize = new VideoResizeSettings
{
    Width  = 1280,   // 720p resolution
    Height = 720,
    Mode   = VideoResizeMode.Letterbox,
};

// Frame rate is configured on the capture device format, not the core — pick
// a 30 fps device format via Video_CaptureDevice_Format / _FrameRate.
```

### Buffer Size Configuration

Latency vs. stability for FFMPEG-based streaming is controlled on the output object, not on the core. Milliseconds:

```
ffmpegOutput.VideoBufferSize = 5000; // 5 s buffer for smoother streaming
```

## Best Practices for UDP Streaming

### Network Considerations

1. **Bandwidth Assessment**: Ensure sufficient bandwidth for your target quality. As a guideline:
2. SD quality (480p): 1-2 Mbps
3. HD quality (720p): 2.5-4 Mbps
4. Full HD (1080p): 4-8 Mbps
5. **Network Stability**: UDP doesn't guarantee packet delivery. In unstable networks, consider:
6. Reducing resolution or bitrate
7. Implementing application-level error recovery
8. Using forward error correction when available
9. **Firewall Configuration**: Ensure that UDP ports are open on both sender and receiver firewalls.

### Performance Optimization

1. **Hardware Acceleration / Keyframes / Preset**: `FFMPEGEXEOutput` does not expose first-class properties for HW accel, keyframe interval, or x264 presets — instead inject them as FFMPEG CLI flags via `Custom_AdditionalVideoArgs`. FFMPEG then applies them to the video encoder invocation.

```
// NVENC hardware encoder + 2-second keyframe interval (60 frames @ 30 fps)
// + ultrafast preset (lowest latency).
ffmpegOutput.Custom_AdditionalVideoArgs = "-c:v h264_nvenc -g 60 -preset p1";

// Intel QuickSync instead:
// ffmpegOutput.Custom_AdditionalVideoArgs = "-c:v h264_qsv -g 60";

// Software x264 with a quality/speed trade-off:
// ffmpegOutput.Custom_AdditionalVideoArgs = "-c:v libx264 -g 60 -preset ultrafast";
```

1. **Pipe-based transport** (avoids a temp file between SDK and FFMPEG) generally reduces latency:

```
ffmpegOutput.UsePipe = true;
```

## Troubleshooting Common Issues

1. **Stream Not Receiving**: Verify network connectivity, port availability, and firewall settings.
2. **High Latency**: Check network congestion, reduce bitrate, or adjust buffer sizes.
3. **Poor Quality**: Increase bitrate, adjust encoding settings, or check for network packet loss.
4. **Audio/Video Sync Issues**: Ensure proper timestamp synchronization in your application.

## Conclusion

UDP streaming with VisioForge SDKs provides a powerful solution for real-time video and audio transmission with minimal latency. By leveraging H.264/HEVC video codecs, AAC audio, and MPEG-TS packaging, developers can create robust streaming applications suitable for a wide range of use cases.

The flexibility of the SDK allows for fine-tuning of all streaming parameters, enabling optimization for specific network conditions and quality requirements. Whether implementing a simple point-to-point stream or a complex multicast distribution system, VisioForge's UDP streaming capabilities provide the necessary tools for success.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples and working demonstrations of UDP streaming implementations.

---END OF PAGE---


## WMV Network Streaming Implementation in .NET Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/wmv/
**Description:** Implement Windows Media Video streaming in .NET with compression algorithms, adaptive bitrates, and bandwidth optimization for network delivery.
**Tags:** Video Capture SDK, .NET, VideoCaptureCore, Windows, WinForms, Capture, Streaming, WMV, C#, NuGet
**API:** VideoCaptureCore, WMVOutput, WMVMode, NetworkStreamingFormat

# Windows Media Video (WMV) Network Streaming Implementation Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [VideoCaptureCore](#)

## Introduction to WMV Streaming Technology

Windows Media Video (WMV) represents a versatile and powerful streaming technology developed by Microsoft. As an integral component of the Windows Media framework, WMV has established itself as a reliable solution for efficiently delivering video content across networks. This format utilizes sophisticated compression algorithms that substantially reduce file sizes while maintaining acceptable visual quality, making it particularly well-suited for streaming applications where bandwidth optimization is critical.

The WMV format supports an extensive range of video resolutions and bitrates, allowing developers to tailor their streaming implementations to accommodate varying network conditions and end-user requirements. This adaptability makes WMV an excellent choice for applications that need to serve diverse client environments with different connectivity constraints.

## Technical Overview of WMV Format

### Key Features and Capabilities

WMV implements the Advanced Systems Format (ASF) container, which provides several technical advantages for streaming applications:

- **Efficient compression**: Employs codec technology that balances quality with file size
- **Scalable bitrate adjustment**: Adapts to available bandwidth conditions
- **Error resilience**: Built-in mechanisms for packet loss recovery
- **Content protection**: Supports Digital Rights Management (DRM) when required
- **Metadata support**: Allows embedding of descriptive information about the stream

### Technical Specifications

| Feature | Specification |
| --- | --- |
| Codec | VC-1 (primarily) |
| Container | ASF (Advanced Systems Format) |
| Supported resolutions | Up to 4K UHD (depending on profile) |
| Bitrate range | 10 Kbps to 20+ Mbps |
| Audio support | WMA (Windows Media Audio) |
| Streaming protocols | HTTP, RTSP, MMS |

## Windows-Only WMV Streaming Implementation

[VideoCaptureCore](#)

The VisioForge SDK provides a robust framework for implementing WMV streaming in Windows environments. This implementation allows applications to broadcast video over networks while simultaneously capturing to a file if desired.

### Implementation Prerequisites

Before implementing WMV streaming in your application, ensure the following requirements are met:

1. Your development environment includes the VisioForge Video Capture SDK
2. Required redistributables are installed (details provided in the Deployment section)
3. Your application targets Windows operating systems
4. Network ports are properly configured and accessible

### Step-by-Step Implementation Guide

#### 1. Initialize the Video Capture Component

Begin by setting up the core video capture component in your application:

```
using VisioForge.Core.VideoCapture;
using VisioForge.Core.Types.Output;
using VisioForge.Core.Types.VideoCapture;

// Initialize VideoCaptureCore with the VideoView that hosts the preview
var VideoCapture1 = new VideoCaptureCore(VideoView1 as IVideoView);

// Configure basic capture settings (device selection, mode, etc.)
// ...
```

#### 2. Enable Network Streaming

To activate network streaming functionality, you need to enable it explicitly and set the format to WMV:

```
// Enable network streaming
VideoCapture1.Network_Streaming_Enabled = true;

// Set the streaming format to WMV
VideoCapture1.Network_Streaming_Format = NetworkStreamingFormat.WMV;
```

#### 3. Configure WMV Output Settings

Create and configure a WMV output object with appropriate settings:

```
// Create WMV output. Default ctor picks the "Windows Media Video 9 for Local Network
// (768 kbps)" internal profile with Mode = WMVMode.InternalProfile.
var wmvOutput = new WMVOutput();

// Option A: pick a different built-in profile
wmvOutput.Mode = WMVMode.InternalProfile;
wmvOutput.Internal_Profile_Name = "Windows Media Video 9 for Broadband (NTSC, 1400 Kbps)";

// Option B: drive the encoder from custom settings instead of a profile.
// Note the flat "Custom_*" naming — WMVOutput has no nested Profile object.
// Bitrate is bits/sec; KeyFrameInterval is seconds between keyframes;
// Quality is a 0..100 byte.
wmvOutput.Mode = WMVMode.CustomSettings;
wmvOutput.Custom_Video_StreamPresent = true;
wmvOutput.Custom_Video_Bitrate = 2_000_000;      // 2 Mbps
wmvOutput.Custom_Video_KeyFrameInterval = 3;     // seconds
wmvOutput.Custom_Video_Quality = 85;             // 0..100
wmvOutput.Custom_Video_SizeSameAsInput = true;
wmvOutput.Custom_Audio_StreamPresent = true;

// Cap the number of simultaneous clients (lives on WMVOutput, not on VideoCaptureCore)
wmvOutput.Network_Streaming_WMV_Maximum_Clients = 25;

// Wire the WMV output into the network-streaming pipeline
VideoCapture1.Network_Streaming_Output = wmvOutput;

// The port that the Windows Media server binds to
VideoCapture1.Network_Streaming_Network_Port = 12345;
```

#### 4. Start the Streaming Process

Once everything is configured, you can start the streaming process:

```
// Start the streaming process
try
{
    await VideoCapture1.StartAsync();

    // The streaming URL is now available for clients
    string streamingUrl = VideoCapture1.Network_Streaming_URL;

    // Display or log the streaming URL for client connections
    Console.WriteLine($"Streaming available at: {streamingUrl}");
}
catch (Exception ex)
{
    // Handle any exceptions during streaming initialization
    Console.WriteLine($"Streaming error: {ex.Message}");
}
```

### Advanced Configuration Options

#### External .prx Profile Files

For fine control beyond the built-in profiles, point WMVOutput at a profile file authored with Windows Media Profile Editor:

```
wmvOutput.Mode = WMVMode.ExternalProfile;
wmvOutput.External_Profile_FileName = @"C:\profiles\my-stream.prx";

// Or paste the profile XML inline:
// wmvOutput.Mode = WMVMode.ExternalProfileFromText;
// wmvOutput.External_Profile_Text = "<profile ...>...</profile>";

VideoCapture1.Network_Streaming_Output = wmvOutput;
```

## Client-Side Connection Implementation

Clients can connect to the WMV stream using Windows Media Player or any application that supports the Windows Media streaming protocol. The connection URL follows this format:

```
http://[server_ip]:[port]/
```

For example:

```
http://192.168.1.100:12345/
```

### Sample Client Connection Code

For programmatic connections to the WMV stream in client applications:

```
// Client-side WMV stream connection using Windows Media Player control
using System.Windows.Forms;

public partial class StreamViewerForm : Form
{
    public StreamViewerForm(string streamUrl)
    {
        InitializeComponent();

        // Assuming you have a Windows Media Player control named 'wmPlayer' on your form
        wmPlayer.URL = streamUrl;
        wmPlayer.Ctlcontrols.play();
    }
}
```

## Performance Optimization

When implementing WMV network streaming, consider these optimization strategies:

1. **Adjust bitrate based on network conditions**: Lower bitrates for constrained networks
2. **Balance keyframe intervals**: Frequent keyframes improve seek performance but increase bandwidth
3. **Monitor CPU usage**: WMV encoding can be CPU-intensive; adjust quality settings accordingly
4. **Implement network quality detection**: Adapt streaming parameters dynamically
5. **Consider buffer settings**: Larger buffers improve stability but increase latency

## Troubleshooting Common Issues

| Issue | Possible Solution |
| --- | --- |
| Connection failures | Verify network port is open in firewall settings |
| Poor video quality | Increase bitrate or adjust compression settings |
| High CPU usage | Reduce resolution or frame rate |
| Client buffering | Adjust buffer window settings or reduce bitrate |
| Authentication errors | Verify credentials on both server and client |

## Deployment Requirements

### Required Redistributables

To successfully deploy applications using WMV streaming functionality, include the following redistributable packages:

- Video capture redist [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/) [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)

### Installation Commands

Using NuGet Package Manager:

```
Install-Package VisioForge.DotNet.Core.Redist.VideoCapture.x64
```

Or for 32-bit systems:

```
Install-Package VisioForge.DotNet.Core.Redist.VideoCapture.x86
```

## Conclusion

WMV network streaming provides a reliable way to broadcast video content across networks in Windows environments. The VisioForge SDK simplifies implementation with its comprehensive API while giving developers fine-grained control over streaming parameters. By following the guidelines in this document, you can create robust streaming applications that deliver high-quality video content to multiple clients simultaneously.

For more advanced implementations and additional code samples, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## YouTube Live Streaming in C# .NET with RTMP Output
**URL:** https://www.visioforge.com/help/docs/dotnet/general/network-streaming/youtube/
**Description:** Stream to YouTube Live with RTMP in .NET applications using optimized video encoders, audio configuration, and cross-platform support.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, RTMP, H.264, H.265, AAC, C#
**API:** VideoCaptureCoreX, VideoEditCoreX, YouTubeOutput, NVENCH264EncoderSettings, MediaBlockPadMediaType

# YouTube Live Streaming with VisioForge SDKs

## Introduction to YouTube Streaming Integration

The YouTube RTMP output functionality in VisioForge SDKs enables developers to create robust .NET applications that stream high-quality video content directly to YouTube. This implementation leverages various video and audio encoders to optimize streaming performance across different hardware configurations and platforms. This comprehensive guide provides detailed instructions on setting up, configuring, and troubleshooting YouTube streaming in your applications.

## Supported SDK Platforms

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

All major VisioForge SDK platforms provide cross-platform capabilities for YouTube streaming, ensuring consistent functionality across Windows, macOS, and other operating systems.

## Understanding the YouTubeOutput Class

The `YouTubeOutput` class serves as the primary interface for YouTube streaming configuration, offering extensive customization options including:

- **Video encoder selection and configuration**: Choose from multiple hardware-accelerated and software-based encoders
- **Audio encoder selection and configuration**: Configure AAC audio encoders with custom parameters
- **Custom video and audio processing**: Apply filters and transformations before streaming
- **YouTube-specific sink settings**: Fine-tune streaming parameters specific to YouTube's requirements

## Getting Started: Basic Setup Process

### Stream Key Configuration

The foundation of any YouTube streaming implementation begins with your YouTube stream key. This authentication token connects your application to your YouTube channel:

```
// Initialize YouTube output with your stream key
var youtubeOutput = new YouTubeOutput("your-youtube-stream-key");
```

## Video Encoder Configuration Options

### Comprehensive Video Encoder Support

The SDK provides support for multiple video encoders, each optimized for different hardware environments and performance requirements:

| Encoder Type | Platform/Hardware | Performance Characteristics |
| --- | --- | --- |
| OpenH264 | Cross-platform (software) | CPU-intensive, widely compatible |
| NVENC H264 | NVIDIA GPUs | Hardware-accelerated, reduced CPU usage |
| QSV H264 | Intel CPUs with Quick Sync | Hardware-accelerated, efficient |
| AMF H264 | AMD GPUs | Hardware-accelerated for AMD hardware |
| HEVC/H265 | Various (where supported) | Higher compression efficiency |

### Dynamic Encoder Selection

The system intelligently selects default encoders based on the platform (OpenH264 on most platforms, Apple Media H264 on macOS). Developers can override these defaults to leverage specific hardware capabilities:

```
// Example: Using NVIDIA NVENC encoder if available
if (NVENCH264EncoderSettings.IsAvailable())
{
    youtubeOutput.Video = new NVENCH264EncoderSettings();
}
```

### Configuring Video Encoding Parameters

Each encoder supports customization of various parameters to optimize streaming quality and performance:

```
var videoSettings = new OpenH264EncoderSettings
{
    Bitrate = 4500,  // Kbit/s — 4.5 Mbps
    GOPSize = 60,    // Keyframe every 2 seconds at 30 fps (real property name; no KeyframeInterval)
    // Add other encoder-specific settings as needed
};
youtubeOutput.Video = videoSettings;
```

## Audio Encoder Configuration

### Supported AAC Audio Encoders

The SDK supports multiple AAC audio encoders to ensure optimal audio quality across different platforms:

- **VO-AAC**: Default for non-Windows platforms, providing consistent audio encoding
- **AVENC AAC**: Alternative cross-platform option with different performance characteristics
- **MF AAC**: Windows-specific encoder leveraging Media Foundation

### Audio Encoder Configuration Example

```
// Example: Configure audio encoder settings.
// VOAACEncoderSettings exposes only Bitrate (Kbit/s); sample rate follows the upstream source.
var audioSettings = new VOAACEncoderSettings
{
    Bitrate = 128,  // Kbit/s — 128 kbps
};
youtubeOutput.Audio = audioSettings;
```

## Platform-Specific Optimization Strategies

### Windows-Specific Features

- Leverages Media Foundation (MF) encoders for optimal Windows performance
- Provides extended HEVC/H265 encoding capabilities
- Defaults to MF AAC for audio encoding, optimized for the Windows platform

### macOS Implementation Considerations

- Automatically utilizes Apple Media H264 encoder for native performance
- Implements VO-AAC for audio encoding with macOS optimization

### Cross-Platform Compatibility Layer

- Falls back to OpenH264 for video on platforms without specific optimizations
- Utilizes VO-AAC for consistent audio encoding across diverse environments

## Best Practices for Optimal Streaming

### Hardware-Aware Encoder Selection

- Always verify encoder availability before implementing hardware-accelerated options
- Implement fallback mechanisms to OpenH264 when specialized hardware is unavailable
- Consider platform-specific encoder capabilities when designing cross-platform applications

### YouTube-Optimized Stream Settings

- Adhere to YouTube's recommended bitrates for your target resolution
- Implement the standard 2-second keyframe interval (60 frames at 30fps)
- Configure 48 kHz audio sample rate to meet YouTube's audio specifications

### Robust Error Management

- Develop comprehensive error handling for connection issues
- Implement continuous monitoring of encoder performance
- Create diagnostic tools to evaluate stream health during operation

## Complete Implementation Examples

### VideoCaptureCoreX/VideoEditCoreX Integration

This example demonstrates a complete YouTube streaming implementation with error handling for VideoCaptureCoreX/VideoEditCoreX:

```
try
{
    var youtubeOutput = new YouTubeOutput("your-stream-key");

    // Configure video encoding (Bitrate in Kbit/s; GOPSize controls keyframe cadence)
    if (NVENCH264EncoderSettings.IsAvailable())
    {
        youtubeOutput.Video = new NVENCH264EncoderSettings
        {
            Bitrate = 4500,
            GOPSize = 60,
        };
    }

    // Configure audio encoding (Bitrate in Kbit/s)
    youtubeOutput.Audio = new MFAACEncoderSettings
    {
        Bitrate = 128,
    };

    // Rotate the YouTube stream key or swap the sink destination by replacing the Sink object.
    // YouTubeSinkSettings exposes only the stream Key (other properties are internal).
    // youtubeOutput.Sink = new YouTubeSinkSettings("new-stream-key");

    // Add the output to the video capture instance
    core.Outputs_Add(youtubeOutput, true); // core is an instance of VideoCaptureCoreX

    // Or set the output for the video edit instance
    videoEdit.Output_Format = youtubeOutput; // videoEdit is an instance of VideoEditCoreX
}
catch (Exception ex)
{
    // Handle initialization errors
    Console.WriteLine($"Failed to initialize YouTube output: {ex.Message}");
}
```

### Media Blocks SDK Implementation

For developers using the Media Blocks SDK, this example shows how to connect encoder components with the YouTube sink:

```
// Create the YouTube sink block (using RTMP)
var youtubeSinkBlock = new YouTubeSinkBlock(new YouTubeSinkSettings("streaming key"));

// Connect the video encoder to the sink block
pipeline.Connect(h264Encoder.Output, youtubeSinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

// Connect the audio encoder to the sink block
pipeline.Connect(aacEncoder.Output, youtubeSinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
```

## Troubleshooting Common Issues

### Encoder Initialization Problems

- Verify hardware encoder availability through system diagnostics
- Ensure system meets all requirements for your chosen encoder
- Confirm proper installation of hardware-specific drivers for GPU acceleration

### Stream Connection Failures

- Validate stream key format and expiration status
- Test network connectivity to YouTube's streaming servers
- Verify YouTube service status through official channels

### Performance Optimization

- Monitor system resource utilization during streaming sessions
- Adjust encoding bitrates and settings based on available resources
- Consider switching to hardware acceleration when CPU usage is excessive

## Additional Resources and Documentation

- [Official YouTube Live Streaming Documentation](https://support.google.com/youtube/topic/9257891)
- [YouTube Technical Stream Requirements](https://support.google.com/youtube/answer/2853702)

By leveraging these detailed configuration options and best practices, developers can create robust YouTube streaming applications using VisioForge SDKs that deliver high-quality content while optimizing system resource utilization across multiple platforms.

---END OF PAGE---


## AVI File Output Guide for .NET Video and Audio Encoding
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/avi/
**Description:** Implement AVI file output in .NET with video and audio encoding, hardware acceleration, and cross-platform multimedia container support.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Recording, Encoding, Editing, AVI, H.264, H.265, MJPEG, AAC, MP3, C#, NuGet
**API:** AVIOutput, VideoCaptureCoreX, VOAACEncoderSettings, VideoEditCoreX, NVENCH264EncoderSettings

# AVI File Output in VisioForge .NET SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

AVI (Audio Video Interleave) is a Microsoft-developed multimedia container format that stores both audio and video data in a single file with synchronized playback. It supports both compressed and uncompressed data, offering flexibility while sometimes resulting in larger file sizes.

## Technical Overview of AVI Format

AVI files use a RIFF (Resource Interchange File Format) structure to organize data. This format divides content into chunks, with each chunk containing either audio or video frames. Key technical aspects include:

- Container format supporting multiple audio and video codecs
- Interleaved audio and video data for synchronized playback
- Maximum file size of 4GB in standard AVI (extended to 16EB in OpenDML AVI)
- Support for multiple audio tracks and subtitles
- Widely supported across platforms and media players

Despite newer container formats like MP4 and MKV offering more features, AVI remains valuable for certain workflows due to its simplicity and compatibility with legacy systems.

## Cross-Platform AVI Implementation

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The [AVIOutput](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.AVIOutput.html) class provides a robust way to configure and generate AVI files with various encoding options.

### Setting Up AVI Output

Create an `AVIOutput` instance by specifying a target filename:

```
var aviOutput = new AVIOutput("output_video.avi");
```

This constructor automatically initializes default encoders:

- Video: OpenH264 encoder
- Audio: MP3 encoder

### Video Encoder Options

Configure video encoding through the `Video` property with several available encoders. For detailed configuration options, see the [H.264 encoder documentation](../../video-encoders/h264/), [HEVC encoder documentation](../../video-encoders/hevc/), and [MJPEG encoder documentation](../../video-encoders/mjpeg/):

#### Standard Encoder

```
// Open-source H.264 encoder for general use
aviOutput.Video = new OpenH264EncoderSettings();
```

#### Hardware-Accelerated Encoders

```
// NVIDIA GPU acceleration
aviOutput.Video = new NVENCH264EncoderSettings();  // H.264
aviOutput.Video = new NVENCHEVCEncoderSettings(); // HEVC

// Intel Quick Sync acceleration
aviOutput.Video = new QSVH264EncoderSettings();   // H.264
aviOutput.Video = new QSVHEVCEncoderSettings();   // HEVC

// AMD GPU acceleration
aviOutput.Video = new AMFH264EncoderSettings();   // H.264
aviOutput.Video = new AMFHEVCEncoderSettings();   // HEVC
```

#### Special Purpose Encoder

```
// Motion JPEG for high-quality frame-by-frame encoding
aviOutput.Video = new MJPEGEncoderSettings();
```

### Audio Encoder Options

The `Audio` property lets you configure audio encoding settings. For detailed configuration options, see the [MP3 encoder documentation](../../audio-encoders/mp3/) and [AAC encoder documentation](../../audio-encoders/aac/):

```
// Standard MP3 encoding
aviOutput.Audio = new MP3EncoderSettings();

// AAC encoding options
aviOutput.Audio = new VOAACEncoderSettings();
aviOutput.Audio = new AVENCAACEncoderSettings();
aviOutput.Audio = new MFAACEncoderSettings(); // Windows only
```

### Integration with SDK Components

#### Video Capture SDK

```
var core = new VideoCaptureCoreX();
core.Outputs_Add(aviOutput, true);
```

#### Video Edit SDK

```
var core = new VideoEditCoreX();
core.Output_Format = aviOutput;
```

#### Media Blocks SDK

```
var aac = new VOAACEncoderSettings();
var h264 = new OpenH264EncoderSettings();
var aviSinkSettings = new AVISinkSettings("output.avi");
var aviOutput = new AVIOutputBlock(aviSinkSettings, h264, aac);
```

### File Management

You can get or change the output filename after initialization:

```
// Get current filename
string currentFile = aviOutput.GetFilename();

// Set new filename
aviOutput.SetFilename("new_output.avi");
```

### Complete Example

Here's a full example showing how to configure AVI output with hardware acceleration:

```
// Create AVI output with specified filename
var aviOutput = new AVIOutput("high_quality_output.avi");

// Configure hardware-accelerated NVIDIA H.264 encoding
aviOutput.Video = new NVENCH264EncoderSettings();

// Configure AAC audio encoding
aviOutput.Audio = new VOAACEncoderSettings();
```

## Windows-Specific AVI Implementation

[VideoCaptureCore](#) [VideoEditCore](#)

The Windows-only components provide additional options for AVI output configuration.

### Basic Setup

Create the AVIOutput object:

```
var aviOutput = new AVIOutput();
```

### Configuration Methods

#### Method 1: Using Settings Dialog

```
var aviSettingsDialog = new AVISettingsDialog(
  VideoCapture1.Video_Codecs.ToArray(),
  VideoCapture1.Audio_Codecs.ToArray());

aviSettingsDialog.ShowDialog(this);
aviSettingsDialog.SaveSettings(ref aviOutput);
```

#### Method 2: Programmatic Configuration

First, get available codecs:

```
// Populate codec lists
foreach (string codec in VideoCapture1.Video_Codecs)
{
  cbVideoCodecs.Items.Add(codec);
}

foreach (string codec in VideoCapture1.Audio_Codecs)
{
  cbAudioCodecs.Items.Add(codec);
}
```

Then set video and audio settings:

```
// Configure video
aviOutput.Video_Codec = cbVideoCodecs.Text;

// Configure audio
aviOutput.ACM.Name = cbAudioCodecs.Text;
aviOutput.ACM.Channels = 2;
aviOutput.ACM.BPS = 16;
aviOutput.ACM.SampleRate = 44100;
aviOutput.ACM.UseCompression = true;
```

### Implementation

Apply settings and start capture:

```
// Set output format
VideoCapture1.Output_Format = aviOutput;

// Set capture mode
VideoCapture1.Mode = VideoCaptureMode.VideoCapture;

// Set output file path
VideoCapture1.Output_Filename = "output.avi";

// Start capture
await VideoCapture1.StartAsync();
```

## Best Practices for AVI Output

### Encoder Selection Guidelines

1. **General-Purpose Applications**
2. OpenH264 provides good compatibility and quality
3. Suitable for most standard development scenarios
4. **Performance-Critical Applications**
5. Use hardware-accelerated encoders (NVENC, QSV, AMF) when available
6. Offers significant performance advantages with minimal quality loss
7. **Quality-Focused Applications**
8. HEVC encoders provide better compression at similar quality
9. MJPEG for scenarios requiring frame-by-frame accuracy

### Audio Encoding Recommendations

- MP3: Good compatibility with reasonable quality
- AAC: Better quality-to-size ratio, preferred for newer applications
- Choose based on your target platform and quality requirements

### Platform Considerations

- Some encoders are platform-specific:
- MF HEVC and MF AAC encoders are Windows-only
- Hardware-accelerated encoders require appropriate GPU support
- Check encoder availability with `GetVideoEncoders()` and `GetAudioEncoders()` when developing cross-platform applications

### Error Handling Tips

- Always verify encoder availability before use
- Implement fallback encoders for platform-specific scenarios
- Check file write permissions before setting output paths

## Troubleshooting Common Issues

### Codec Not Found

If you encounter "Codec not found" errors:

```
// Check if codec is available before using
if (!VideoCapture1.Video_Codecs.Contains("H264"))
{
    // Fall back to another codec or show error
    MessageBox.Show("H264 codec not available. Please install required codecs.");
    return;
}
```

### File Write Permission Issues

Handle permission-related errors:

```
try
{
    // Test write permissions
    using (var fs = File.Create(outputPath, 1, FileOptions.DeleteOnClose)) { }

    // If successful, proceed with AVI output
    aviOutput.SetFilename(outputPath);
}
catch (UnauthorizedAccessException)
{
    // Handle permission error
    MessageBox.Show("Cannot write to the specified location. Please select another folder.");
}
```

### 4 GB AVI container limit

The AVI container has a hard 4 GB cap, and `AVIOutput` exposes no built-in split API. For long recordings, either:

- Stop the pipeline before you approach 4 GB and start a new one with a fresh `AVIOutput(nextFilename)`, or
- Switch container: [MP4](../mp4/) or [MKV](../mkv/) both handle multi-hour recordings without this limit.

Watch free disk space and rotate at the application layer when you need multi-file capture.

## Required Dependencies

### Video Capture SDK .Net

- [x86 Redist](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/)
- [x64 Redist](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)

### Video Edit SDK .Net

- [x86 Redist](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoEdit.x86/)
- [x64 Redist](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoEdit.x64/)

## Additional Resources

- [VisioForge API Documentation](https://api.visioforge.org/dotnet/)
- [Sample Projects Repository](https://github.com/visioforge/.Net-SDK-s-samples)
- [Support and Community Forums](https://support.visioforge.com/)

---END OF PAGE---


## DirectShow Custom Video Format Integration in .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/custom/
**Description:** Implement custom video output formats with DirectShow filters for specialized processing pipelines and codec configuration in .NET applications.
**Tags:** Video Capture SDK, Video Edit SDK, .NET, DirectShow, VideoCaptureCore, VideoEditCore, Windows, Capture, Streaming, Encoding, Editing, MP4, C#, NuGet
**API:** CustomOutput, VideoCaptureCore, VideoEditCore, VideoCaptureMode

# Creating Custom Video Output Formats with DirectShow Filters

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

[VideoCaptureCore](#) [VideoEditCore](#)

## Overview

Working with video in .NET applications often requires custom output formats to meet specific project requirements. The VisioForge SDKs provide powerful capabilities to implement custom format outputs using DirectShow filters, giving developers precise control over audio and video processing pipelines.

This guide demonstrates practical techniques for implementing custom output formats that work seamlessly with both the Video Capture SDK .NET and Video Edit SDK .NET, allowing you to tailor your video applications to exact specifications.

## Why Use Custom Output Formats?

Custom output formats offer several advantages for .NET developers:

- Support for specialized video codecs not available in standard formats
- Fine-grained control over video and audio compression settings
- Integration with third-party DirectShow filters
- Ability to create proprietary or industry-specific output formats
- Optimization for specific use cases (streaming, archiving, editing)

## Getting Started with CustomOutput

The `CustomOutput` class is the cornerstone for configuring custom output settings in VisioForge SDKs. This class enables you to define and configure the filters used in your video processing pipeline.

Start by initializing a new instance:

```
var customOutput = new CustomOutput();
```

While our examples use the `VideoCaptureCore` class, developers using Video Edit SDK .NET can apply the same techniques with `VideoEditCore`.

## Implementation Strategies

There are two primary approaches to implementing custom format output with DirectShow filters:

### Strategy 1: Three-Component Pipeline

This modular approach divides the processing pipeline into three distinct components:

1. Audio codec
2. Video codec
3. Multiplexer (file format container)

This separation provides maximum flexibility and control over each stage of the process. You can use either standard DirectShow filters or specialized codecs for audio and video components.

#### Retrieving Available Codecs

Begin by populating your UI with available codecs and filters:

```
// Populate video codec options
foreach (string codec in VideoCapture1.Video_Codecs)
{
    videoCodecDropdown.Items.Add(codec);
}

// Populate audio codec options
foreach (string codec in VideoCapture1.Audio_Codecs)
{
    audioCodecDropdown.Items.Add(codec);
}

// Get all available DirectShow filters
foreach (string filter in VideoCapture1.DirectShow_Filters)
{
    directShowAudioFilters.Items.Add(filter);
    directShowVideoFilters.Items.Add(filter);
    multiplexerFilters.Items.Add(filter);
    fileWriterFilters.Items.Add(filter);
}
```

#### Configuring the Pipeline Components

Next, set up your video and audio processing components based on user selections:

```
// Set up video codec
if (useStandardVideoCodec.Checked)
{
    customOutput.Video_Codec = videoCodecDropdown.Text;
    customOutput.Video_Codec_UseFiltersCategory = false;
}
else
{
    customOutput.Video_Codec = directShowVideoFilters.Text;
    customOutput.Video_Codec_UseFiltersCategory = true;
}

// Set up audio codec
if (useStandardAudioCodec.Checked)
{
    customOutput.Audio_Codec = audioCodecDropdown.Text;
    customOutput.Audio_Codec_UseFiltersCategory = false;
}
else
{
    customOutput.Audio_Codec = directShowAudioFilters.Text;
    customOutput.Audio_Codec_UseFiltersCategory = true;
}

// Configure the multiplexer
customOutput.MuxFilter_Name = multiplexerFilters.Text;
customOutput.MuxFilter_IsEncoder = false;
```

#### Custom File Writer Configuration

For specialized outputs that require a dedicated file writer:

```
// Enable special file writer if needed
customOutput.SpecialFileWriter_Needed = useCustomFileWriter.Checked;
customOutput.SpecialFileWriter_FilterName = fileWriterFilters.Text;
```

This approach gives you granular control over each stage of the encoding process, making it ideal for complex output requirements.

### Strategy 2: All-in-One Filter

This streamlined approach uses a single DirectShow filter that combines the functionality of the multiplexer, video codec, and audio codec. The SDK intelligently handles detection of the filter's capabilities, determining whether it:

- Can directly write files without assistance
- Requires the standard DirectShow File Writer filter
- Needs a specialized file writer filter

Implementation is straightforward:

```
// Populate filter options from available DirectShow filters
foreach (string filter in VideoCapture1.DirectShow_Filters)
{
    filterDropdown.Items.Add(filter);
}

// Configure the all-in-one filter
customOutput.MuxFilter_Name = selectedFilter.Text;
customOutput.MuxFilter_IsEncoder = true;

// Set up specialized file writer if required
customOutput.SpecialFileWriter_Needed = requiresCustomWriter.Checked;
customOutput.SpecialFileWriter_FilterName = fileWriterFilter.Text;
```

This approach is simpler to implement but offers less granular control over individual components of the encoding process.

## Simplifying Configuration with Dialog UI

For a more user-friendly implementation, VisioForge provides a built-in settings dialog that handles the configuration of custom formats:

```
// Create and configure the settings dialog
CustomFormatSettingsDialog settingsDialog = new CustomFormatSettingsDialog(
    VideoCapture1.Video_Codecs.ToArray(),
    VideoCapture1.Audio_Codecs.ToArray(),
    VideoCapture1.DirectShow_Filters.ToArray());

// Apply settings to your CustomOutput instance
settingsDialog.SaveSettings(ref customOutput);
```

This dialog provides a complete UI for configuring all aspects of custom output formats, saving development time while still offering full flexibility.

## Implementing the Output Process

After configuring your custom format settings, you need to apply them to your capture or edit process:

```
// Apply the custom format configuration
VideoCapture1.Output_Format = customOutput;

// Set the capture mode
VideoCapture1.Mode = VideoCaptureMode.VideoCapture;

// Specify output file path
VideoCapture1.Output_Filename = "output_video.mp4";

// Start the capture or encoding process
await VideoCapture1.StartAsync();
```

## Performance Considerations

When implementing custom output formats, keep these performance tips in mind:

- DirectShow filters vary in efficiency and resource usage
- Test your filter combinations with typical input media
- Some third-party filters may introduce additional latency
- Consider memory usage when processing high-resolution video
- Filter compatibility may vary across different Windows versions

## Required Packages

To use custom DirectShow filters, ensure you have the appropriate redistributable packages installed:

### Video Capture SDK .Net

- [x86 Package](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/)
- [x64 Package](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)

### Video Edit SDK .Net

- [x86 Package](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoEdit.x86/)
- [x64 Package](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoEdit.x64/)

## Troubleshooting

Common issues when working with custom DirectShow filters include:

- Filter compatibility conflicts
- Missing codecs or dependencies
- Registration issues with COM components
- Memory leaks in third-party filters
- Performance bottlenecks with complex filter graphs

If you encounter problems, verify that all required filters are properly registered on your system and that you have the latest versions of both the filters and the VisioForge SDK.

## Conclusion

Custom output formats using DirectShow filters provide powerful capabilities for .NET developers working with video applications. Whether you choose the flexibility of a three-component pipeline or the simplicity of an all-in-one filter approach, VisioForge's SDKs give you the tools you need to create exactly the output format your application requires.

---

For more code samples and implementation examples, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## FFMPEG.exe Output Format Configuration in .NET Video SDKs
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/ffmpeg-exe/
**Description:** Configure FFMPEG.exe output in .NET for video capture and editing with hardware acceleration, custom codecs, and professional encoding options.
**Tags:** Video Capture SDK, Video Edit SDK, .NET, VideoCaptureCore, VideoEditCore, Windows, Capture, Encoding, Editing, MP4, WebM, AVI, MOV, TS, H.264, H.265, ProRes, C#, NuGet
**API:** VideoCaptureCore, VideoEditCore, FFMPEGEXEOutput, H264MFSettings, H264NVENCSettings

# FFMPEG.exe Integration with VisioForge .Net SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

[VideoCaptureCore](#) [VideoEditCore](#)

## Introduction to FFMPEG Output in .NET

This guide provides detailed instructions for implementing FFMPEG.exe output in Windows applications using VisioForge's .NET SDKs. The integration works with both [Video Capture SDK .NET](https://www.visioforge.com/video-capture-sdk-net) and [Video Edit SDK .NET](https://www.visioforge.com/video-edit-sdk-net), utilizing the `VideoCaptureCore` and `VideoEditCore` engines.

FFMPEG functions as a powerful multimedia framework that enables developers to output to a wide variety of video and audio formats. Its flexibility stems from extensive codec support and granular control over encoding parameters for both video and audio streams.

## Why Use FFMPEG with VisioForge SDKs?

Integrating FFMPEG into your VisioForge-powered applications provides several technical advantages:

- **Format versatility**: Support for virtually all modern container formats
- **Codec flexibility**: Access to both open-source and proprietary codecs
- **Performance optimization**: Options for CPU and GPU acceleration
- **Customization depth**: Fine-grained control over encoding parameters
- **Cross-platform compatibility**: Consistent output on different systems

## Key Features and Capabilities

### Supported Output Formats

FFMPEG supports numerous container formats, including but not limited to:

- MP4 (MPEG-4 Part 14)
- WebM (VP8/VP9 with Vorbis/Opus)
- MKV (Matroska)
- AVI (Audio Video Interleave)
- MOV (QuickTime)
- WMV (Windows Media Video)
- FLV (Flash Video)
- TS (MPEG Transport Stream)

### Hardware Acceleration Options

Modern video encoding benefits from hardware acceleration technologies that significantly improve encoding speed and efficiency:

- **Intel QuickSync**: Leverages Intel integrated graphics for H.264 and HEVC encoding
- **NVIDIA NVENC**: Utilizes NVIDIA GPUs for accelerated encoding (requires compatible NVIDIA graphics card)
- **AMD AMF/VCE**: Employs AMD graphics processors for encoding acceleration

### Video Codec Support

The integration offers access to multiple video codecs with customizable parameters:

- **H.264/AVC**: Industry standard with excellent quality-to-size ratio
- **H.265/HEVC**: Higher efficiency codec for 4K+ content
- **VP9**: Google's open video codec used in WebM
- **AV1**: Next-generation open codec (where supported)
- **MPEG-2**: Legacy codec for DVD and broadcast compatibility
- **ProRes**: Professional codec for editing workflows

## Implementation Process

### 1. Setting Up Your Development Environment

Before implementing FFMPEG output, ensure your development environment is properly configured:

1. Create a new or open an existing .NET project
2. Install the appropriate VisioForge SDK NuGet packages
3. Add FFMPEG dependency packages (detailed in the Dependencies section)
4. Import the necessary namespaces in your code:

```
using VisioForge.Core.Types;
using VisioForge.Core.Types.VideoCapture;
using VisioForge.Core.Types.VideoEdit;
using VisioForge.Core.Types.Output;     // FFMPEGEXEOutput
using VisioForge.Core.Types.FFMPEGEXE;  // H264MFSettings, H264NVENCSettings, H264QSVSettings, HEVCQSVSettings, OutputMuxer, BasicAudioSettings, ...
```

### 2. Initializing FFMPEG Output

Start by creating an instance of `FFMPEGEXEOutput` to handle your output configuration:

```
var ffmpegOutput = new FFMPEGEXEOutput();
```

This object will serve as the container for all your encoding settings and preferences.

### 3. Configuring Output Container Format

Set your desired output container format using the `OutputMuxer` property:

```
ffmpegOutput.OutputMuxer = OutputMuxer.MP4;
```

Other common container options include:

- `OutputMuxer.Matroska` - For Matroska container (.mkv)
- `OutputMuxer.WebM` - For WebM format
- `OutputMuxer.AVI` - For AVI format
- `OutputMuxer.MOV` - For QuickTime container

### 4. Video Encoder Configuration

FFMPEG provides multiple video encoder options. Select and configure the appropriate encoder based on your requirements and available hardware:

#### Standard CPU-Based H.264 Encoding

```
var videoEncoder = new H264MFSettings
{
    Bitrate     = 5000, // Kbit/s — 5000 = 5 Mbps
    RateControl = H264MFRateControl.CBR,
};
ffmpegOutput.Video = videoEncoder;
```

#### Hardware-Accelerated NVIDIA Encoding

```
var nvidiaEncoder = new H264NVENCSettings
{
    Bitrate = 8000000,        // 8 Mbps
};
ffmpegOutput.Video = nvidiaEncoder;
```

#### Hardware-Accelerated Intel QuickSync Encoding

```
var intelEncoder = new H264QSVSettings
{
    Bitrate = 6000000
};
ffmpegOutput.Video = intelEncoder;
```

#### HEVC/H.265 Encoding for Higher Efficiency

```
var hevcEncoder = new HEVCQSVSettings
{
    Bitrate = 3000000,
};
ffmpegOutput.Video = hevcEncoder;
```

### 5. Audio Encoder Configuration

Configure your audio encoding settings based on quality requirements and target platform compatibility:

```
var audioEncoder = new BasicAudioSettings
{
    Bitrate = 192000,    // 192 kbps
    Channels = 2,        // Stereo
    SampleRate = 48000,  // 48 kHz - professional standard
    Encoder = AudioEncoder.AAC,
    Mode = AudioMode.CBR
};

ffmpegOutput.Audio = audioEncoder;
```

### 6. Final Configuration and Execution

Apply all settings and start the encoding process:

```
// Apply format settings
core.Output_Format = ffmpegOutput;

// Set operation mode
core.Mode = VideoCaptureMode.VideoCapture;  // For Video Capture SDK
// core.Mode = VideoEditMode.Convert;       // For Video Edit SDK

// Set output path
core.Output_Filename = "output.mp4";

// Begin processing
await core.StartAsync();
```

## Required Dependencies

Install the following NuGet packages based on your target architecture to ensure proper functionality:

### Video Capture SDK Dependencies

```
Install-Package VisioForge.DotNet.Core.Redist.VideoCapture.x64
Install-Package VisioForge.DotNet.Core.Redist.FFMPEGEXE.x64
```

For x86 targets:

```
Install-Package VisioForge.DotNet.Core.Redist.VideoCapture.x86
Install-Package VisioForge.DotNet.Core.Redist.FFMPEGEXE.x86
```

### Video Edit SDK Dependencies

```
Install-Package VisioForge.DotNet.Core.Redist.VideoEdit.x64
Install-Package VisioForge.DotNet.Core.Redist.FFMPEGEXE.x64
```

For x86 targets:

```
Install-Package VisioForge.DotNet.Core.Redist.VideoEdit.x86
Install-Package VisioForge.DotNet.Core.Redist.FFMPEGEXE.x86
```

## Troubleshooting and Optimization

### Common Issues and Solutions

- **Codec not found errors**: Ensure you've installed the correct FFMPEG package with proper codec support
- **Hardware acceleration failures**: Verify GPU compatibility and driver versions
- **Performance issues**: Adjust thread count and encoding preset based on available CPU resources
- **Output quality problems**: Fine-tune bitrate, profile, and encoding parameters

### Performance Optimization Tips

- Use hardware acceleration when available
- Choose appropriate presets based on your quality/speed requirements
- Set reasonable bitrates based on content type and resolution
- Consider two-pass encoding for non-realtime scenarios requiring highest quality

## Additional Resources

For more code samples and implementation examples, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

To learn more about FFMPEG parameters and capabilities, refer to the [official FFMPEG documentation](https://ffmpeg.org/documentation.html).

---END OF PAGE---


## Video to Animated GIF Encoding in .NET Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/gif/
**Description:** Create GIF animations from video in .NET with frame rate control, resolution settings, and optimization for cross-platform applications.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Encoding, Editing, GIF, C#
**API:** AnimatedGIFOutput, GIFEncoderSettings, VideoCaptureCoreX, VideoEditCoreX, VideoCaptureCore

# GIF Encoder

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The GIF encoder is a component of the VisioForge SDK that enables video encoding to the GIF format. This document provides detailed information about the GIF encoder settings and implementation guidelines.

## Cross-platform GIF output

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The GIF encoder settings are managed through the `GIFEncoderSettings` class, which provides configuration options for controlling the encoding process.

### Properties

1. **Repeat**
2. Type: `uint`
3. Description: Controls the number of times the GIF animation will repeat
4. Values:

   - `-1`: Loop forever
   - `0..n`: Finite number of repetitions
5. **Speed**
6. Type: `int`
7. Description: Controls the encoding speed
8. Range: 1 to 30 (higher values result in faster encoding)
9. Default: 10

## Implementation Guide

### Basic Usage

Here's a basic example of how to configure and use the GIF encoder:

```
using VisioForge.Core.Types.X.VideoEncoders;

// Create and configure GIF encoder settings
var settings = new GIFEncoderSettings
{
    Repeat = 0,      // Play once
    Speed = 15       // Set encoding speed to 15
};
```

### Advanced Configuration

For more controlled GIF encoding, you can adjust the settings based on your specific needs:

```
// Configure for an infinitely looping GIF with maximum encoding speed
var settings = new GIFEncoderSettings
{
    Repeat = uint.MaxValue,  // Loop forever
    Speed = 30              // Maximum encoding speed
};

// Configure for optimal quality
var qualitySettings = new GIFEncoderSettings
{
    Repeat = 1,    // Play twice
    Speed = 1      // Slowest encoding speed for best quality
};
```

## Best Practices

1. **Speed Selection**
2. For best quality, use lower speed values (1-5)
3. For balanced quality and performance, use medium speed values (6-15)
4. For fastest encoding, use higher speed values (16-30)
5. **Memory Considerations**
6. Higher speed values consume more memory during encoding
7. For large videos, consider using lower speed values to manage memory usage
8. **Loop Configuration** (`Repeat` is a `uint`)
9. Use `Repeat = uint.MaxValue` for infinite loops (the docstring reads "-1 = loop forever" but the property type is `uint`, so `-1` won't compile)
10. Set specific repeat counts for presentation-style GIFs
11. Use `Repeat = 0` for single-play GIFs

## Performance Optimization

When encoding videos to GIF format, consider these optimization strategies:

```
// Optimize for web delivery
var webOptimizedSettings = new GIFEncoderSettings
{
    Repeat = uint.MaxValue,  // Infinite loop for web playback
    Speed = 20              // Fast encoding for web content
};

// Optimize for quality
var qualityOptimizedSettings = new GIFEncoderSettings
{
    Repeat = 1,    // Single repeat
    Speed = 3      // Slower encoding for better quality
};
```

### Example Implementation

Here's a complete example showing how to set up GIF output:

First build the `GIFOutput` (X engines) with the encoder settings:

```
var gifOutput = new GIFOutput("output.gif");
gifOutput.Settings = new GIFEncoderSettings
{
    Repeat = uint.MaxValue,  // Infinite loop
    Speed = 4,
};
```

Add the GIF output to the Video Capture SDK core instance:

```
var core = new VideoCaptureCoreX();
core.Outputs_Add(gifOutput, true);
```

Or assign it as the `Output_Format` of a `VideoEditCoreX` timeline:

```
var editor = new VideoEditCoreX();
editor.Input_AddVideoFile("input.mp4");
editor.Output_Format = gifOutput;
editor.Start();
```

GIF output is video-only

`GIFOutput` implements both `IVideoCaptureXBaseOutput` and `IVideoEditXBaseOutput`, so it works with `VideoCaptureCoreX` and `VideoEditCoreX`. There is no muxer — `gifenc` writes the final `.gif` directly. Audio tracks on the timeline are dropped, and `SmartRender = true` is incompatible with GIF output (no source clip is already in `image/gif`). For pipelines that need finer control over the encoder placement, the Media Blocks `GIFEncoderBlock` snippet below remains available.

Create a Media Blocks GIF output instance:

```
var gifSettings = new GIFEncoderSettings();
var gifEncoderBlock = new GIFEncoderBlock(gifSettings, "output.gif");
```

## Windows-only GIF output

[VideoCaptureCore](#) [VideoEditCore](#)

The `AnimatedGIFOutput` class is a specialized configuration class within the `VisioForge.Core.Types.Output` namespace that handles settings for generating animated GIF files. This class is designed to work with both video capture and video editing operations, implementing both `IVideoEditBaseOutput` and `IVideoCaptureBaseOutput` interfaces.

The primary purpose of this class is to provide a configuration container for controlling how video content is converted into animated GIF format. It allows users to specify key parameters such as frame rate and output dimensions, which are crucial for creating optimized animated GIFs from video sources.

### Properties

#### ForcedVideoHeight

- Type: `int`
- Purpose: Specifies a forced height for the output GIF
- Usage: Set this property when you need to resize the output GIF to a specific height, regardless of the input video dimensions
- Example: `gifOutput.ForcedVideoHeight = 480;`

#### ForcedVideoWidth

- Type: `int`
- Purpose: Specifies a forced width for the output GIF
- Usage: Set this property when you need to resize the output GIF to a specific width, regardless of the input video dimensions
- Example: `gifOutput.ForcedVideoWidth = 640;`

#### FrameRate

- Type: `VideoFrameRate`
- Default Value: 2 frames per second
- Purpose: Controls how many frames per second the output GIF will contain
- Note: The default value of 2 fps is chosen to balance file size and animation smoothness for typical GIF usage

### Constructor

```
public AnimatedGIFOutput()
```

The constructor initializes a new instance with default settings:

- Sets the frame rate to 2 fps using `new VideoFrameRate(2)`
- All other properties are initialized to their default values

### Serialization Methods

#### Save()

- Returns: `string`
- Purpose: Serializes the current configuration to JSON format
- Usage: Use this method when you need to save or transfer the configuration
- Example:

```
var gifOutput = new AnimatedGIFOutput();
gifOutput.ForcedVideoWidth = 800;
string jsonConfig = gifOutput.Save();
```

#### Load(string json)

- Parameters: `json` - A JSON string containing serialized configuration
- Returns: `AnimatedGIFOutput`
- Purpose: Creates a new instance from a JSON configuration string
- Usage: Use this method to restore a previously saved configuration
- Example:

```
string jsonConfig = "..."; // Your saved JSON configuration
var gifOutput = AnimatedGIFOutput.Load(jsonConfig);
```

### Best Practices and Usage Guidelines

1. Frame Rate Considerations
2. The default 2 fps is suitable for most basic animations
3. Increase the frame rate for smoother animations, but be aware of file size implications
4. Consider using higher frame rates (e.g., 10-15 fps) for complex motion
5. Resolution Settings
6. Only set ForcedVideoWidth/Height when you specifically need to resize
7. Maintain aspect ratio by setting width and height proportionally
8. Consider target platform limitations when choosing dimensions
9. Performance Optimization
10. Lower frame rates result in smaller file sizes
11. Consider the balance between quality and file size based on your use case
12. Test different configurations to find the optimal settings for your needs

### Example Usage

Here's a complete example of configuring and using the AnimatedGIFOutput class:

```
// Create a new instance with default settings
var gifOutput = new AnimatedGIFOutput();

// Configure the output settings
gifOutput.ForcedVideoWidth = 800;
gifOutput.ForcedVideoHeight = 600;
gifOutput.FrameRate = new VideoFrameRate(5); // 5 fps

// Apply the settings to the core
core.Output_Format = gifOutput; // core is an instance of VideoCaptureCore or VideoEditCore
core.Output_Filename = "output.gif";
```

### Common Scenarios and Solutions

#### Creating Web-Optimized GIFs

```
var webGifOutput = new AnimatedGIFOutput
{
    ForcedVideoWidth = 480,
    ForcedVideoHeight = 270,
    FrameRate = new VideoFrameRate(5)
};
```

#### High-Quality Animation Settings

```
var highQualityGif = new AnimatedGIFOutput
{
    FrameRate = new VideoFrameRate(15)
};
```

---END OF PAGE---


## Video and Audio Output Formats for .NET Development
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/
**Description:** Comprehensive guide to video and audio formats for .NET including MP4, WebM, AVI, MKV with codec comparisons and compatibility matrices.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, DirectShow, Windows, macOS, Linux, Android, iOS, Streaming

# Output Formats for .NET Media SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction

The VisioForge .NET SDKs support a wide range of output formats for video, audio, and media projects. Selecting the right format is crucial for ensuring compatibility, optimizing file size, and maintaining quality appropriate for your target platform. This guide covers all available formats, their technical specifications, use cases, and implementation details to help developers make informed decisions.

## Choosing the Right Format

When selecting an output format, consider these key factors:

- **Target platform** - Some formats work better on specific devices or browsers
- **Quality requirements** - Different codecs provide varying levels of quality at different bitrates
- **File size constraints** - Some formats offer better compression than others
- **Processing overhead** - Encoding complexity varies between formats
- **Streaming requirements** - Certain formats are optimized for streaming scenarios

## Video Container Formats

### AVI (Audio Video Interleave)

[AVI](avi/) is a classic container format developed by Microsoft that supports various video and audio codecs.

**Key features:**

- Wide compatibility with Windows applications
- Supports virtually any DirectShow-compatible video and audio codec
- Simple structure makes it reliable for video editing workflows
- Better suited for archiving than streaming

### MP4 (MPEG-4 Part 14)

[MP4](mp4/) is one of the most versatile and widely used container formats in modern applications.

**Key features:**

- Excellent compatibility across devices and platforms
- Supports advanced codecs including H.264, H.265/HEVC, and AAC
- Optimized for streaming and progressive download
- Efficient storage with good quality-to-size ratio

**Supported video codecs:**

- H.264 (AVC) - Balance of quality and compatibility
- H.265 (HEVC) - Better compression but higher encoding overhead
- MPEG-4 Part 2 - Older codec with wider compatibility

**Supported audio codecs:**

- AAC - Industry standard for digital audio compression
- MP3 - Widely supported legacy format

### WebM

[WebM](webm/) is an open-source container format designed specifically for web use.

**Key features:**

- Royalty-free format ideal for web applications
- Native support in most modern browsers
- Excellent for streaming video content
- Supports VP8, VP9, and AV1 video codecs

**Technical considerations:**

- VP9 offers ~50% bitrate reduction compared to H.264 at similar quality
- AV1 provides even better compression but with significantly higher encoding complexity
- Works well with HTML5 video elements without plugins

### MKV (Matroska)

[MKV](mkv/) is a flexible container format that can hold virtually any type of audio or video.

**Key features:**

- Supports multiple audio, video, and subtitle tracks
- Can contain almost any codec
- Great for archiving and high-quality storage
- Supports chapters and attachments

**Best uses:**

- Media archives requiring multiple tracks
- High-quality video storage
- Projects requiring complex chapter structures

### Additional Container Formats

- [MOV](mov/) - Apple's QuickTime container format
- [MPEG-TS](mpegts/) - Transport Stream format optimized for broadcasting
- [MXF](mxf/) - Material Exchange Format used in professional video production
- [Windows Media Video](wmv/) - Microsoft's proprietary format

## Audio-Only Formats

### MP3 (MPEG-1 Audio Layer III)

[MP3](../audio-encoders/mp3/) remains one of the most widely supported audio formats.

**Key features:**

- Near-universal compatibility
- Configurable bitrate for quality vs. size tradeoffs
- VBR (Variable Bit Rate) option for optimized file sizes

### AAC in M4A Container

[M4A](../audio-encoders/aac/) provides better audio quality than MP3 at the same bitrate.

**Key features:**

- Better compression efficiency than MP3
- Good compatibility with modern devices
- Supports advanced audio features like multichannel audio

### Other Audio Formats

- [FLAC](../audio-encoders/flac/) - Lossless audio format for high-quality archiving
- [OGG Vorbis](../audio-encoders/vorbis/) - Open-source alternative to MP3 with better quality at lower bitrates

## Specialized Formats

### GIF (Graphics Interchange Format)

[GIF](gif/) is useful for creating short, silent animations.

**Key features:**

- Wide web compatibility
- Limited to 256 colors per frame
- Support for transparency
- Ideal for short, looping animations

### Custom Output Format

[Custom output format](custom/) allows integration with third-party DirectShow filters.

**Key features:**

- Maximum flexibility for specialized requirements
- Integration with commercial or custom codecs
- Support for proprietary formats

## Advanced Output Options

### FFMPEG Integration

[FFMPEG EXE](ffmpeg-exe/) integration provides access to FFMPEG's extensive codec library.

**Key features:**

- Support for virtually any format FFMPEG can handle
- Advanced encoding options
- Custom command line arguments for fine-tuned control

## Performance Optimization Tips

When working with video output formats, consider these optimization strategies:

1. **Match format to use case** - Use streaming-optimized formats for web delivery
2. **Consider hardware acceleration** - Many modern codecs support GPU acceleration
3. **Use appropriate bitrates** - Higher isn't always better; find the sweet spot for your content
4. **Test on target devices** - Ensure compatibility before finalizing format choice
5. **Enable multi-threading** - Take advantage of multiple CPU cores for faster encoding

## Implementation Best Practices

- Configure proper keyframe intervals for streaming formats
- Set appropriate bitrate constraints for target platforms
- Use two-pass encoding for highest quality output when time permits
- Consider audio quality requirements alongside video format decisions

## Format Compatibility Matrix

| Format | Windows | macOS | iOS | Android | Web Browsers |
| --- | --- | --- | --- | --- | --- |
| MP4 (H.264) | ✓ | ✓ | ✓ | ✓ | ✓ |
| WebM (VP9) | ✓ | ✓ | Partial | ✓ | ✓ |
| MKV | ✓ | With players | With players | With players | ✗ |
| AVI | ✓ | With players | Limited | Limited | ✗ |
| MP3 | ✓ | ✓ | ✓ | ✓ | ✓ |

---

Visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) for more code samples and implementation examples. Our documentation is continuously updated to reflect new features and optimizations available in the latest SDK releases.

---END OF PAGE---


## MKV Container Format - .NET Video Encoding and Recording
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/mkv/
**Description:** Implement MKV output in .NET with hardware-accelerated encoding, multiple audio tracks, and flexible Matroska container support for video apps.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Recording, Encoding, Editing, MKV, H.264, H.265, AAC, C#
**API:** MKVOutput, VideoCaptureCoreX, VideoEditCoreX, MediaBlocksPipeline, NVENCH264EncoderSettings

# MKV Output in VisioForge .NET SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

## Introduction to MKV Format

MKV (Matroska Video) is a flexible, open-standard container format that can hold an unlimited number of video, audio, and subtitle tracks in one file. The VisioForge SDKs provide robust support for MKV output with various encoding options to meet diverse development requirements.

This format is particularly valuable for developers working on applications that require:

- Multiple audio tracks or languages
- High-quality video with multiple codec options
- Cross-platform compatibility
- Support for metadata and chapters

## Getting Started with MKV Output

The `MKVOutput` class serves as the primary interface for generating MKV files in VisioForge SDKs. You can initialize it with default settings or specify custom encoders to match your application's needs.

### Basic Implementation

```
// Create MKV output with default encoders
var mkvOutput = new MKVOutput("output.mkv");
```

Or specify custom encoders during initialization (the second and third constructor parameters are `IVideoEncoder` / `IAudioEncoder`, both nullable):

```
var videoEncoder = new NVENCH264EncoderSettings();
var audioEncoder = new MFAACEncoderSettings();
var mkvOutput = new MKVOutput("output.mkv", videoEncoder, audioEncoder);
```

## Video Encoding Options

The MKV format supports multiple video codecs, giving developers flexibility in balancing quality, performance, and compatibility. VisioForge SDKs offer both software and hardware-accelerated encoders.

### H.264 Encoder Options

H.264 remains one of the most widely supported video codecs, providing excellent compression and quality. For detailed configuration options, see the [H.264 encoder documentation](../../video-encoders/h264/).

- **OpenH264**: Software-based encoder, used as default when hardware acceleration isn't available
- **NVENC H.264**: NVIDIA GPU-accelerated encoding for superior performance
- **QSV H.264**: Intel Quick Sync Video technology for hardware acceleration
- **AMF H.264**: AMD GPU-accelerated encoding option

### HEVC (H.265) Encoder Options

For applications requiring higher compression efficiency or 4K content, see the [HEVC encoder documentation](../../video-encoders/hevc/) for detailed settings:

- **MF HEVC**: Windows Media Foundation implementation (Windows-only)
- **NVENC HEVC**: NVIDIA GPU acceleration for H.265
- **QSV HEVC**: Intel Quick Sync implementation for H.265
- **AMF HEVC**: AMD GPU acceleration for H.265 encoding

### Setting a Video Encoder

```
mkvOutput.Video = new NVENCH264EncoderSettings();
```

## Audio Encoding Options

Audio quality is equally important for most applications. VisioForge SDKs provide several audio encoder options for MKV output:

### Supported Audio Codecs

- **AAC Encoders** - See [AAC encoder documentation](../../audio-encoders/aac/):
- **VO AAC**: Default choice for non-Windows platforms
- **AVENC AAC**: FFMPEG AAC implementation
- **MF AAC**: Windows Media Foundation implementation (default on Windows)
- **Alternative Audio Formats**:
- **[MP3](../../audio-encoders/mp3/)**: Common format with wide compatibility
- **[Vorbis](../../audio-encoders/vorbis/)**: Open source audio codec
- **[OPUS](../../audio-encoders/opus/)**: Modern codec with excellent quality-to-size ratio

### Configuring Audio Encoding

```
// Platform-specific audio encoder selection
#if NET_WINDOWS
    var aacSettings = new MFAACEncoderSettings
    {
        Bitrate = 192,
        SampleRate = 48000
    };
    mkvOutput.Audio = aacSettings;
#else
    var aacSettings = new VOAACEncoderSettings
    {
        Bitrate = 192,
        SampleRate = 44100
    };
    mkvOutput.Audio = aacSettings;
#endif

// Or use OPUS for better quality at lower bitrates (Bitrate is in Kbit/s; channel count
// is inferred from the input caps, so there is no Channels property on OPUSEncoderSettings)
var opusSettings = new OPUSEncoderSettings
{
    Bitrate = 128
};
mkvOutput.Audio = opusSettings;
```

## Advanced MKV Configuration

### Custom Video and Audio Processing

For applications that require special processing, you can integrate custom MediaBlock processors:

```
// Add a video processor for effects or transformations
var textOverlayBlock = new TextOverlayBlock(new TextOverlaySettings("Hello world!"));
mkvOutput.CustomVideoProcessor = textOverlayBlock;

// Add audio processing
var volumeBlock = new VolumeBlock() { Level = 1.2 }; // Boost volume by 20%
mkvOutput.CustomAudioProcessor = volumeBlock;
```

### Sink Settings Management

Control output file properties through the sink settings:

```
// Change output filename
mkvOutput.Sink.Filename = "processed_output.mkv";

// Get current filename
string currentFile = mkvOutput.GetFilename();

// Update filename with timestamp
string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
mkvOutput.SetFilename($"recording_{timestamp}.mkv");
```

## Integration with VisioForge SDK Components

### With Video Capture SDK

```
// Initialize capture core
var captureCore = new VideoCaptureCoreX();

// Configure video and audio source
// ...

// Add MKV output to recording pipeline
var mkvOutput = new MKVOutput("capture.mkv");
captureCore.Outputs_Add(mkvOutput, true);

// Start recording
await captureCore.StartAsync();
```

### With Video Edit SDK

```
// Initialize editing core
var editCore = new VideoEditCoreX();

// Add input sources
// ...

// Configure MKV output with hardware acceleration
var h265Encoder = new NVENCHEVCEncoderSettings
{
    Bitrate = 10000
};
var mkvOutput = new MKVOutput("edited.mkv", h265Encoder);
editCore.Output_Format = mkvOutput;

// Process the file
await editCore.StartAsync();
```

### With Media Blocks SDK

`MKVOutputBlock` takes encoder **settings** (not encoder blocks) in its constructor and builds the encoder chain internally. Connect source audio/video directly to its input pads.

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Outputs;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.VideoEncoders;
using VisioForge.Core.Types;

// Pipeline.
var pipeline = new MediaBlocksPipeline();

// Source (any file — will be decoded into separate video and audio outputs).
var sourceSettings = await UniversalSourceSettings.CreateAsync("input.mp4");
var sourceBlock = new UniversalSourceBlock(sourceSettings);

// MKV sink — the constructor accepts encoder settings, not encoder blocks.
var mkvSinkSettings = new MKVSinkSettings("processed.mkv");
var mkvOutput = new MKVOutputBlock(
    mkvSinkSettings,
    videoSettings: new OpenH264EncoderSettings(),
    audioSettings: new VOAACEncoderSettings());

// Wire source pads directly to the MKV output — it handles encoding internally.
pipeline.Connect(sourceBlock.VideoOutput, mkvOutput.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(sourceBlock.AudioOutput, mkvOutput.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

## Hardware Acceleration Benefits

Hardware-accelerated encoding offers significant advantages for developers building real-time or batch processing applications:

1. **Reduced CPU Load**: Offloads encoding to dedicated hardware
2. **Faster Processing**: Up to 5-10x performance improvement
3. **Power Efficiency**: Lower energy consumption, important for mobile apps
4. **Higher Quality**: Some hardware encoders provide better quality-per-bitrate

## Best Practices for Developers

When implementing MKV output in your applications, consider these recommendations:

1. **Always check hardware availability** before using GPU-accelerated encoders
2. **Select appropriate bitrates** based on content type and resolution
3. **Use platform-specific encoders** where possible for optimal performance
4. **Test on target platforms** to ensure compatibility
5. **Consider quality-size trade-offs** based on your application's needs

## Conclusion

The MKV format provides developers with a flexible, robust container for video content in .NET applications. With VisioForge SDKs, you can leverage hardware acceleration, advanced encoding options, and custom processing to create high-performance video applications.

By understanding the available encoders and configuration options, you can optimize your implementation for specific hardware platforms while maintaining cross-platform compatibility where needed.

---END OF PAGE---


## MOV File Encoding and Output in .NET Video Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/mov/
**Description:** Generate MOV files in .NET with hardware-accelerated encoding, cross-platform support, and professional audio/video configuration options.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Encoding, Editing, MP4, MOV, H.264, H.265, AAC, MP3, C#
**API:** MOVOutput, NVENCH264EncoderSettings, VOAACEncoderSettings, VideoCaptureCoreX, VideoEditCoreX

# MOV File Output for .NET Video Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

## Introduction to MOV Output in VisioForge

The MOV container format is widely used for video storage in professional environments and Apple ecosystems. VisioForge's .NET SDKs provide robust cross-platform support for generating MOV files with customizable encoding options. The `MOVOutput` class serves as the primary interface for configuring and generating these files across Windows, macOS, and Linux environments.

MOV files created with VisioForge SDKs can leverage hardware acceleration through NVIDIA, Intel, and AMD encoders, making them ideal for performance-critical applications. This guide walks through the essential steps for implementing MOV output in .NET video applications.

### When to Use MOV Format

MOV is particularly well-suited for:

- Video editing workflows
- Projects requiring Apple ecosystem compatibility
- Professional video production pipelines
- Applications needing metadata preservation
- High-quality archival purposes

## Getting Started with MOV Output

The `MOVOutput` class ([API reference](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.MOVOutput.html)) provides the foundation for MOV file generation with VisioForge SDKs. It encapsulates the configuration of video and audio encoders, processing parameters, and sink settings.

### Basic Implementation

Creating a MOV output requires minimal code:

```
// Create a MOV output targeting the specified filename
var movOutput = new MOVOutput("output.mov");
```

This simple implementation automatically:

- Selects NVENC H264 encoder if available (falls back to OpenH264)
- Chooses the appropriate AAC encoder for your platform (MF AAC on Windows, VO-AAC elsewhere)
- Configures MOV container settings for broad compatibility

### Default Configuration Behavior

The default configuration delivers balanced performance and compatibility across platforms. However, for specialized use cases, you'll likely need to customize encoder settings, which we'll cover in the following sections.

## Video Encoder Options for MOV Files

MOV output supports a variety of video encoders to accommodate different performance, quality, and compatibility requirements. The choice of encoder significantly impacts processing speed, resource consumption, and output quality.

### Supported Video Encoders

The MOV output supports these video encoders. For detailed configuration options, see the [H.264 encoder documentation](../../video-encoders/h264/) and [HEVC encoder documentation](../../video-encoders/hevc/):

| Encoder | Technology | Platform | Best For |
| --- | --- | --- | --- |
| OpenH264 | Software | Cross-platform | Compatibility |
| NVENC H264 | NVIDIA GPU | Cross-platform | Performance |
| QSV H264 | Intel GPU | Cross-platform | Efficiency |
| AMF H264 | AMD GPU | Cross-platform | Performance |
| MF HEVC | Software | Windows only | Quality |
| NVENC HEVC | NVIDIA GPU | Cross-platform | Quality/Performance |
| QSV HEVC | Intel GPU | Cross-platform | Efficiency |
| AMF H265 | AMD GPU | Cross-platform | Quality/Performance |

### Configuring Video Encoders

Set a specific video encoder with code like this:

```
// For NVIDIA hardware-accelerated encoding. Bitrate is Kbit/s on X-namespace encoders.
movOutput.Video = new NVENCH264EncoderSettings() {
    Bitrate = 5000,  // Kbit/s — 5 Mbps
};

// For software-based encoding with OpenH264. RateControl is OpenH264RCMode (not RateControlMode).
movOutput.Video = new OpenH264EncoderSettings() {
    RateControl = OpenH264RCMode.Bitrate,
    Bitrate = 2500,  // Kbit/s — 2.5 Mbps
};
```

### Encoder Selection Strategy

When implementing MOV output, consider these factors for encoder selection:

1. **Hardware availability** - Check if GPU acceleration is available
2. **Quality requirements** - HEVC offers better quality at lower bitrates
3. **Processing speed** - Hardware encoders provide significant speed advantages
4. **Platform compatibility** - Some encoders are Windows-specific

A multi-tier approach often works best, checking for the fastest available encoder and falling back as needed:

```
// Try NVIDIA, then Intel, then software encoding
if (NVENCH264EncoderSettings.IsAvailable())
{
    movOutput.Video = new NVENCH264EncoderSettings();
}
else if (QSVH264EncoderSettings.IsAvailable())
{
    movOutput.Video = new QSVH264EncoderSettings();
}
else
{
    movOutput.Video = new OpenH264EncoderSettings();
}
```

## Audio Encoder Options

Audio quality is critical for most video applications. The SDK provides several audio encoders optimized for different use cases.

### Supported Audio Encoders

For audio codec configuration details, see the [AAC encoder documentation](../../audio-encoders/aac/) and [MP3 encoder documentation](../../audio-encoders/mp3/):

| Encoder | Type | Platform | Quality | Use Case |
| --- | --- | --- | --- | --- |
| MP3 | Software | Cross-platform | Good | Web distribution |
| VO-AAC | Software | Cross-platform | Excellent | Professional use |
| AVENC AAC | Software | Cross-platform | Very good | General purpose |
| MF AAC | Hardware-accelerated | Windows only | Excellent | Windows apps |

### Audio Encoder Configuration

Implementing audio encoding requires minimal code:

```
// MP3 configuration. Bitrate is Kbit/s (one of 8/16/.../320). MP3EncoderSettings exposes
// only Bitrate and ForceMono — channel count follows the upstream source.
movOutput.Audio = new MP3EncoderSettings() {
    Bitrate = 320,        // Kbit/s — 320 kbps high quality
    ForceMono = false,    // Leave false (default) to keep stereo from the source
};

// Or AAC for better quality (Windows)
movOutput.Audio = new MFAACEncoderSettings() {
    Bitrate = 192,        // Kbit/s — 192 kbps
};

// Cross-platform AAC implementation. Sample rate follows the source.
movOutput.Audio = new VOAACEncoderSettings() {
    Bitrate = 192,
};
```

### Platform-Specific Audio Considerations

To handle platform differences elegantly, use conditional compilation:

```
// Select appropriate encoder based on platform
#if NET_WINDOWS
    movOutput.Audio = new MFAACEncoderSettings();
#else
    movOutput.Audio = new VOAACEncoderSettings();
#endif
```

## Advanced MOV Output Customization

Beyond basic configuration, VisioForge SDKs enable powerful customization of MOV output through media processing blocks and sink settings.

### Custom Processing Pipeline

For specialized video processing needs, the SDK provides media block integration:

```
// Add custom video processing
movOutput.CustomVideoProcessor = new SomeMediaBlock();

// Add custom audio processing
movOutput.CustomAudioProcessor = new SomeMediaBlock();
```

### MOV Sink Configuration

Fine-tune the MOV container settings for specialized requirements:

```
// Configure sink settings
movOutput.Sink.Filename = "new_output.mov";
```

### Dynamic Encoder Detection

Your application can intelligently select encoders based on system capabilities:

```
// Get available video encoders
var videoEncoders = movOutput.GetVideoEncoders();

// Get available audio encoders
var audioEncoders = movOutput.GetAudioEncoders();

// Display available options to users or auto-select
foreach (var encoder in videoEncoders)
{
    Console.WriteLine($"Available encoder: {encoder.Name}");
}
```

## Integration with VisioForge SDK Core Components

The MOV output integrates seamlessly with the core SDK components for video capture, editing, and processing.

### Video Capture Integration

Add MOV output to a capture workflow:

```
// Create and configure capture core
var core = new VideoCaptureCoreX();

// Add capture devices
// ..
// Add configured MOV output
core.Outputs_Add(movOutput, true);

// Start capture
await core.StartAsync();
```

### Video Edit SDK Integration

Incorporate MOV output in video editing:

```
// Create edit core and configure project
var core = new VideoEditCoreX();

// Add input file
// ...

// Set MOV as output format
core.Output_Format = movOutput;

// Process the video
await core.StartAsync();
```

### Media Blocks SDK Implementation

For direct media pipeline control:

```
// Create encoder blocks (not raw settings — the pipeline consumes blocks).
var aacEncoder = new AACEncoderBlock(new VOAACEncoderSettings { Bitrate = 192 });
var h264Encoder = new H264EncoderBlock(new OpenH264EncoderSettings { Bitrate = 5000 });

// Configure the MOV sink — MOV and MP4 are different muxers (qtmux vs mp4mux), so use MOVSinkBlock.
var movSinkSettings = new MOVSinkSettings("output.mov");
var movSink = new MOVSinkBlock(movSinkSettings);

// Wire encoders into the sink via dynamic inputs.
pipeline.Connect(h264Encoder.Output, movSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output, movSink.CreateNewInput(MediaBlockPadMediaType.Audio));
```

## Platform Compatibility Notes

While VisioForge's MOV implementation is cross-platform, some features are platform-specific:

### Windows-Specific Features

- MF HEVC video encoder provides optimized encoding on Windows
- MF AAC audio encoder offers hardware acceleration on compatible systems

### Cross-Platform Features

- OpenH264, NVENC, QSV, and AMF encoders work across operating systems
- VO-AAC and AVENC AAC provide consistent audio encoding everywhere

## Conclusion

The MOV output capability in VisioForge .NET SDKs provides a powerful and flexible solution for creating high-quality video files. By leveraging hardware acceleration where available and falling back to optimized software implementations when needed, the SDK ensures excellent performance across platforms.

For more information, refer to the [VisioForge API documentation](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.MOVOutput.html) or explore other output formats in our documentation.

---END OF PAGE---


## MP4 Video Output in C# .NET — H.264, HEVC, AAC Muxing
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/mp4/
**Description:** Encoder auto-selection with NVENC/QSV/AMF fallback. File splitting by size, duration, or timecode. Rolling buffer recording and stream muxing. VisioForge SDK.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Recording, Encoding, Editing, Webcam, MP4, H.264, H.265, MPEG-2, AAC, MP3, C#, NuGet
**API:** MP4Output, MP4SplitSinkSettings, NVENCH264EncoderSettings, VOAACEncoderSettings, MP4OutputBlock

# MP4 file output

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

MP4 (MPEG-4 Part 14), introduced in 2001, is a digital multimedia container format most commonly used to store video and audio. It also supports subtitles and images. MP4 is known for its high compression and compatibility across various devices and platforms, making it a popular choice for streaming and sharing.

Capturing videos from a webcam and saving them to a file is a common requirement in many applications. One way to achieve this is by using a software development kit (SDK) like VisioForge Video Capture SDK .Net, which provides an easy-to-use API for capturing and processing videos in C#.

To capture video in MP4 format using Video Capture SDK, you need to configure video output format using one of the classes for MP4 output. You can use several available software and hardware video encoders, including Intel QuickSync, Nvidia NVENC, and AMD/ATI APU.

## Cross-platform MP4 output

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The [MP4Output](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.MP4Output.html?q=MP4Output) class provides a flexible and powerful way to configure MP4 video output settings for video capture and editing operations. This guide will walk you through how to use the MP4Output class effectively, covering its key features and common usage patterns.

MP4Output implements several important interfaces:

- IVideoEditXBaseOutput
- IVideoCaptureXBaseOutput
- Media Block creation

This makes it suitable for both video editing and capture scenarios while providing extensive control over video and audio processing.

### Basic Usage

The simplest way to create an MP4Output instance is using the constructor with a filename:

```
var output = new MP4Output("output.mp4");
```

This creates an MP4Output with default video and audio encoder settings. On Windows, it will use OpenH264 for video encoding and Media Foundation AAC for audio encoding by default.

### Video Encoder Configuration

The MP4Output class supports multiple video encoders through its `Video` property. Here are the supported video encoders:

**[H.264 Encoders](../../video-encoders/h264/)**

- OpenH264EncoderSettings (Default, CPU)
- AMFH264EncoderSettings (AMD)
- NVENCH264EncoderSettings (NVIDIA)
- QSVH264EncoderSettings (Intel Quick Sync)

**[HEVC (H.265) Encoders](../../video-encoders/hevc/)**

- MFHEVCEncoderSettings (Windows only)
- AMFHEVCEncoderSettings (AMD)
- NVENCHEVCEncoderSettings (NVIDIA)
- QSVHEVCEncoderSettings (Intel Quick Sync)

You can check the availability of specific encoders using the `IsAvailable` method:

```
if (NVENCH264EncoderSettings.IsAvailable())
{
    output.Video = new NVENCH264EncoderSettings();
}
```

Example of configuring a specific video encoder:

```
var output = new MP4Output("output.mp4");
output.Video = new NVENCH264EncoderSettings(); // Use NVIDIA encoder
```

### Audio Encoder Configuration

The `Audio` property allows you to specify the audio encoder. Supported audio encoders include:

- [VOAACEncoderSettings](../../audio-encoders/aac/)
- [AVENCAACEncoderSettings](../../audio-encoders/aac/)
- [MFAACEncoderSettings](../../audio-encoders/aac/) (Windows only)
- [MP3EncoderSettings](../../audio-encoders/mp3/)

Example of setting a custom audio encoder:

```
var output = new MP4Output("output.mp4");
output.Audio = new MP3EncoderSettings();
```

The MP4Output class automatically selects appropriate default encoders based on the platform.

### Sample code

Add the MP4 output to the Video Capture SDK core instance:

```
var core = new VideoCaptureCoreX();
core.Outputs_Add(output, true);
```

Set the output format for the Video Edit SDK core instance:

```
var core = new VideoEditCoreX();
core.Output_Format = output;
```

Create a Media Blocks MP4 output instance:

```
var aac = new VOAACEncoderSettings();
var h264 = new OpenH264EncoderSettings();
var mp4SinkSettings = new MP4SinkSettings("output.mp4");
var mp4Output = new MP4OutputBlock(mp4SinkSettings, h264, aac);
```

### File Splitting

The [MP4SplitSinkSettings](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Sinks.MP4SplitSinkSettings.html) class provides automatic file splitting capabilities, allowing you to split MP4 output into multiple files based on size, duration, or timecode. This class can be used with both `MP4OutputBlock` (which includes encoding) and `MP4SinkBlock` (muxing only). This is particularly useful for:

- Long recording sessions that need to be broken into manageable file sizes
- Creating time-based segments for easier archival or distribution
- Managing disk space by limiting the number of files kept on storage
- Implementing rolling buffer recording where only recent files are retained

**Split by File Size**

Split the output when a file reaches a specific size in bytes:

```
var h264 = new OpenH264EncoderSettings();
var aac = new VOAACEncoderSettings();

// Create split sink settings with filename pattern
var splitSettings = new MP4SplitSinkSettings("recording_%05d.mp4");

// Split when file reaches 100 MB (104857600 bytes)
splitSettings.SplitFileSize = 104857600;

// Disable duration-based splitting (default is 1 minute)
splitSettings.SplitDuration = TimeSpan.Zero;

// Create output block
var mp4Output = new MP4OutputBlock(splitSettings, h264, aac);
```

**Split by Duration**

Split the output when a file reaches a specific duration:

```
var h264 = new OpenH264EncoderSettings();
var aac = new VOAACEncoderSettings();

// Create split sink settings with filename pattern
var splitSettings = new MP4SplitSinkSettings("recording_%05d.mp4");

// Split every 5 minutes
splitSettings.SplitDuration = TimeSpan.FromMinutes(5);

// Create output block
var mp4Output = new MP4OutputBlock(splitSettings, h264, aac);
```

**Limit Maximum Files**

Control the maximum number of files to keep on disk. Once the limit is reached, the oldest files are automatically deleted:

```
var h264 = new OpenH264EncoderSettings();
var aac = new VOAACEncoderSettings();

// Create split sink settings
var splitSettings = new MP4SplitSinkSettings("recording_%05d.mp4");

// Split every 10 minutes
splitSettings.SplitDuration = TimeSpan.FromMinutes(10);

// Keep only the last 6 files (1 hour of recordings)
splitSettings.SplitMaxFiles = 6;

// Create output block
var mp4Output = new MP4OutputBlock(splitSettings, h264, aac);
```

**Split by Timecode**

Split the output based on timecode difference between first and last frame:

```
var h264 = new OpenH264EncoderSettings();
var aac = new VOAACEncoderSettings();

// Create split sink settings
var splitSettings = new MP4SplitSinkSettings("recording_%05d.mp4");

// Split when timecode difference reaches 1 hour
// Format: "HH:MM:SS:FF" where FF is frames
splitSettings.SplitMaxSizeTimecode = "01:00:00:00";

// Disable other splitting methods
splitSettings.SplitFileSize = 0;
splitSettings.SplitDuration = TimeSpan.Zero;

// Create output block
var mp4Output = new MP4OutputBlock(splitSettings, h264, aac);
```

**Combined Settings**

You can combine splitting criteria. The file will split when any of the enabled criteria is met:

```
var h264 = new OpenH264EncoderSettings();
var aac = new VOAACEncoderSettings();

// Create split sink settings
var splitSettings = new MP4SplitSinkSettings("recording_%05d.mp4");

// Split at 200 MB OR 10 minutes, whichever comes first
splitSettings.SplitFileSize = 209715200; // 200 MB
splitSettings.SplitDuration = TimeSpan.FromMinutes(10);

// Keep only last 12 files
splitSettings.SplitMaxFiles = 12;

// Start numbering from 1 instead of 0
splitSettings.StartIndex = 1;

// Create output block
var mp4Output = new MP4OutputBlock(splitSettings, h264, aac);
```

**Using with MP4SinkBlock**

For scenarios where you already have encoded streams and only need muxing (container creation), use `MP4SinkBlock` with `MP4SplitSinkSettings`:

```
// Create split sink settings
var splitSettings = new MP4SplitSinkSettings("output_%05d.mp4");
splitSettings.SplitDuration = TimeSpan.FromMinutes(5);

// Create MP4 sink block (muxing only, no encoding)
var mp4Sink = new MP4SinkBlock(splitSettings);

// Connect your pre-encoded streams to the sink block
// (connection logic depends on your pipeline structure)
```

**Important Notes:**

- The filename parameter must include a format specifier (like `%05d`) for the file index
- Set `SplitFileSize` to 0 to disable size-based splitting (default is 0)
- The default `SplitDuration` is 1 minute; set to `TimeSpan.Zero` to disable duration-based splitting
- Set `SplitMaxFiles` to 0 to keep all files (default is 0, no deletion)
- When combining criteria, splitting occurs when ANY criterion is met
- The `StartIndex` property controls the initial file number (default is 0)

### Segment events

When recording with `MP4SplitSinkSettings`, both `MP4OutputBlock` and `MP4SinkBlock` raise events around each segment file, so you can name the files yourself and be notified when a segment is finished:

- `OnSegmentFileNameRequested` — raised just before a new segment file is created. Set the event's `FileName` to a custom path (for example, one that embeds the segment start time). Leave it unset to keep the default name built from the location pattern.
- `OnSegmentCreated` — raised when a new segment file has been opened.
- `OnSegmentClosed` — raised when a segment file has been finished and closed. This is the moment to rename the file (for example, to append its end time).

The same events are available on `MPEGTSSinkBlock` — see the [MPEG-TS output](../mpegts/) page.

[`SegmentSinkFileEventArgs`](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Sinks.SegmentSinkFileEventArgs.html) (passed to `OnSegmentCreated` / `OnSegmentClosed`) properties:

| Property | Type | Description |
| --- | --- | --- |
| `FileName` | string | Full path of the segment file. |
| `FragmentIndex` | uint | Zero-based index of the segment. |
| `RunningTime` | TimeSpan | Pipeline running time at the event (relative to the pipeline start, not wall-clock time). |
| `FragmentOffset` | TimeSpan? | Running time of the segment start. Reported on `OnSegmentClosed` only; otherwise `null`. |
| `FragmentDuration` | TimeSpan? | Duration of the segment. Reported on `OnSegmentClosed` only; otherwise `null`. |

[`SegmentSinkFileNameEventArgs`](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Sinks.SegmentSinkFileNameEventArgs.html) (passed to `OnSegmentFileNameRequested`) properties:

| Property | Type | Description |
| --- | --- | --- |
| `FragmentIndex` | uint | Zero-based index of the segment about to be created. |
| `FileName` | string | Full path to use for the new segment. Set it to override the default name; leave `null`/empty to use the location pattern. |

The following example names each segment from its start time and appends the end time when the segment closes:

```
var splitSettings = new MP4SplitSinkSettings("recording_%05d.mp4")
{
    SplitDuration = TimeSpan.FromMinutes(5)
};

var mp4Sink = new MP4SinkBlock(splitSettings);

// Build a custom name from the segment start time.
mp4Sink.OnSegmentFileNameRequested += (sender, e) =>
{
    e.FileName = Path.Combine(@"c:\recordings", $"rec_{DateTime.Now:yyyyMMdd_HHmmss}_{e.FragmentIndex:D5}.mp4");
};

// Rename the finished file to append the end time.
mp4Sink.OnSegmentClosed += (sender, e) =>
{
    var dir = Path.GetDirectoryName(e.FileName);
    var name = Path.GetFileNameWithoutExtension(e.FileName);
    var ext = Path.GetExtension(e.FileName);
    File.Move(e.FileName, Path.Combine(dir, $"{name}__end_{DateTime.Now:HHmmss}{ext}"));
};
```

Threading

These events fire on a GStreamer streaming thread, so a handler must not touch UI controls directly — marshal to the UI thread (for example, `Dispatcher.Invoke` in WPF). The file rename inside `OnSegmentClosed` is plain file I/O and is safe to do there.

### Best Practices

**Hardware Acceleration**: When possible, use hardware-accelerated encoders (NVENC, AMF, QSV) for better performance:

```
var output = new MP4Output("output.mp4");
if (NVENCH264EncoderSettings.IsAvailable())
{
    output.Video = new NVENCH264EncoderSettings();
}
```

**Encoder Selection**: Use the provided methods to enumerate available encoders:

```
var output = new MP4Output("output.mp4");
var availableVideoEncoders = output.GetVideoEncoders();
var availableAudioEncoders = output.GetAudioEncoders();
```

### Common Issues and Solutions

1. **File Access**: The MP4Output constructor attempts to verify write access by creating and immediately deleting a test file. Ensure the application has proper permissions to the output directory.
2. **Encoder Availability**: Hardware encoders might not be available on all systems. Always provide a fallback:

```
var output = new MP4Output("output.mp4");
if (!NVENCH264EncoderSettings.IsAvailable())
{
    output.Video = new OpenH264EncoderSettings(); // Fallback to software encoder
}
```

1. **Platform Compatibility**: Some encoders are platform-specific. Use conditional compilation or runtime checks when targeting multiple platforms:

```
#if NET_WINDOWS
    output.Audio = new MFAACEncoderSettings();
#else
    output.Audio = new MP3EncoderSettings();
#endif
```

## Windows-only MP4 output

[VideoCaptureCore](#) [VideoEditCore](#)

`The same sample code can be used for Video Edit SDK .Net. Use the VideoEditCore class instead of VideoCaptureCore.`

### CPU encoder or Intel QuickSync GPU encoder

Create an `MP4Output` object for MP4 output.

```
var mp4Output = new MP4Output();
```

Set MP4 mode to `CPU_QSV`.

```
mp4Output.MP4Mode = MP4Mode.CPU_QSV;
```

Set video settings.

```
mp4Output.Video.Profile = H264Profile.ProfileMain; // H264 profile
mp4Output.Video.Level = H264Level.Level4; // H264 level
mp4Output.Video.Bitrate = 2000; // bitrate

// optional parameters
mp4Output.Video.MBEncoding = H264MBEncoding.CABAC; //CABAC / CAVLC
mp4Output.Video.BitrateAuto = false; // true to use auto bitrate
mp4Output.Video.RateControl = H264RateControl.VBR; // rate control - CBR or VBR
```

Set AAC audio settings.

```
mp4Output.Audio_AAC.Bitrate = 192;
mp4Output.Audio_AAC.Version = AACVersion.MPEG4; // MPEG-4 / MPEG-2
mp4Output.Audio_AAC.Output = AACOutput.RAW; // RAW or ADTS
mp4Output.Audio_AAC.Object = AACObject.Low; // type of AAC
```

### Nvidia NVENC encoder

Create the `MP4Output` object for MP4 output.

```
var mp4Output = new MP4Output();
```

Set MP4 mode to `NVENC`.

```
mp4Output.MP4Mode = MP4Mode.NVENC;
```

Set the video settings.

```
mp4Output.Video_NVENC.Profile = NVENCVideoEncoderProfile.H264_Main; // H264 profile
mp4Output.Video_NVENC.Level = NVENCEncoderLevel.H264_4; // H264 level
mp4Output.Video_NVENC.Bitrate = 2000; // bitrate

// optional parameters
mp4Output.Video_NVENC.RateControl = NVENCRateControlMode.VBR; // rate control - CBR or VBR
```

Set the audio settings.

```
mp4Output.Audio_AAC.Bitrate = 192;
mp4Output.Audio_AAC.Version = AACVersion.MPEG4; // MPEG-4 / MPEG-2
mp4Output.Audio_AAC.Output = AACOutput.RAW; // RAW or ADTS
mp4Output.Audio_AAC.Object = AACObject.Low; // type of AAC
```

### CPU/GPU encoders

Using MP4 HW output, you can use hardware-accelerated encoders by Intel (QuickSync), Nvidia (NVENC), and AMD/ATI.

Create `MP4HWOutput` object for MP4 HW output.

```
var mp4Output = new MP4HWOutput();
```

Get available encoders.

```
var availableEncoders = VideoCaptureCore.HWEncodersAvailable();
// or
var availableEncoders = VideoEditCore.HWEncodersAvailable();
```

Depending on available encoders, select video codec.

```
mp4Output.Video.Codec = MFVideoEncoder.MS_H264; // Microsoft H264
mp4Output.Video.Profile = MFH264Profile.Main; // H264 profile
mp4Output.Video.Level = MFH264Level.Level4; // H264 level
mp4Output.Video.AvgBitrate = 2000; // bitrate

// optional parameters
mp4Output.Video.CABAC = true; // CABAC / CAVLC
mp4Output.Video.RateControl = MFCommonRateControlMode.CBR; // rate control

// many other parameters are available
```

Set audio settings.

```
mp4Output.Audio.Bitrate = 192;
mp4Output.Audio.Version = AACVersion.MPEG4; // MPEG-4 / MPEG-2
mp4Output.Audio.Output = AACOutput.RAW; // RAW or ADTS
mp4Output.Audio.Object = AACObject.Low; // type of AAC
```

Now, we can apply MP4 output settings to the core class (VideoCaptureCore or VideoEditCore) and start video capture or editing.

### Apply video capture settings

Set MP4 format settings for output.

```
core.Output_Format = mp4Output;
```

Set a video capture mode (or video convert mode if you use Video Edit SDK).

```
core.Mode = VideoCaptureMode.VideoCapture;
```

Set a file name (ensure you have to write access rights).

```
core.Output_Filename = "output.mp4";
```

Start video capture (convert) to a file.

```
await VideoCapture1.StartAsync();
```

Finally, when we're done capturing the video, stop the pipeline and release the resources. `StopAsync()` flushes the muxer and finalises the output file — don't skip it or the MP4 will be unplayable:

```
await VideoCapture1.StopAsync();
VideoCapture1.Dispose();
```

### Required redists

- Video Capture SDK redist [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/) [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)
- Video Edit SDK redist [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoEdit.x86/) [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoEdit.x64/)
- MP4 redist [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MP4.x86/) [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MP4.x64/)

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## MPEG-TS Video Output with File Splitting in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/mpegts/
**Description:** File splitting by duration, size, or timecode. Rolling buffer with max file limit. H.264/HEVC GPU encoding and Blu-ray M2TS mode. VisioForge SDK examples.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Recording, Encoding, Editing, MP4, TS, H.264, H.265, AAC, MP3, C#, NuGet
**API:** MPEGTSOutput, NVENCH264EncoderSettings, MPEGTSSplitSinkSettings, MFBaseOutput, QSVH264EncoderSettings

# MPEG-TS Output

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The MPEG-TS (Transport Stream) output module in VisioForge SDK functionality for creating MPEG transport stream files with various video and audio encoding options. This guide explains how to configure and use the `MPEGTSOutput` class effectively.

## Cross-platform MPEG-TS output

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

To create a new MPEG-TS output, use the following constructor:

```
// Initialize with AAC audio (recommended)
var output = new MPEGTSOutput("output.ts", useAAC: true);
```

You can also use MP3 audio instead of AAC:

```
// Initialize with MP3 audio instead of AAC
var output = new MPEGTSOutput("output.ts", useAAC: false);
```

### Video Encoding Options

The [MPEGTSOutput](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.MPEGTSOutput.html) supports multiple video encoders through the `Video` property. Available encoders include:

**[H.264 Encoders](../../video-encoders/h264/)**

- OpenH264 (Software-based)
- NVENC H.264 (NVIDIA GPU acceleration)
- QSV H.264 (Intel Quick Sync)
- AMF H.264 (AMD GPU acceleration)

**[H.265/HEVC Encoders](../../video-encoders/hevc/)**

- MF HEVC (Windows Media Foundation, Windows only)
- NVENC HEVC (NVIDIA GPU acceleration)
- QSV HEVC (Intel Quick Sync)
- AMF H.265 (AMD GPU acceleration)

Example of setting a specific video encoder:

```
// Check if NVIDIA encoder is available
if (NVENCH264EncoderSettings.IsAvailable())
{
    output.Video = new NVENCH264EncoderSettings();
}
else
{
    // Fall back to OpenH264
    output.Video = new OpenH264EncoderSettings();
}
```

### Audio Encoding Options

The following audio encoders are supported through the `Audio` property:

**[AAC Encoders](../../audio-encoders/aac/)**

- VO-AAC (Cross-platform)
- AVENC AAC
- MF AAC (Windows only)

**[MP3 Encoder](../../audio-encoders/mp3/)**:

- MP3EncoderSettings

Example of setting an audio encoder:

```
// For Windows platforms
output.Audio = new MFAACEncoderSettings();
```

```
// For cross-platform compatibility
output.Audio = new VOAACEncoderSettings();
```

```
// Using MP3 instead of AAC
output.Audio = new MP3EncoderSettings();
```

### File Management

You can get or set the output filename after initialization:

```
// Get current filename
string currentFile = output.GetFilename();

// Change output filename
output.SetFilename("new_output.ts");
```

### File Splitting

The `MPEGTSSplitSinkSettings` class enables automatic splitting of MPEG-TS output into multiple files based on size, duration, or timecode. This is useful for:

- Creating segmented files for HLS streaming
- Managing storage by limiting file sizes
- Recording time-lapse videos
- Implementing rolling buffer recording

#### Configuration Options

```
using VisioForge.Core.Types.X.Sinks;

// Create split settings with filename pattern
// %05d will be replaced with segment number (00000, 00001, etc.)
var splitSettings = new MPEGTSSplitSinkSettings("video_%05d.ts")
{
    // Split by duration (e.g., every 5 minutes)
    SplitDuration = TimeSpan.FromMinutes(5),

    // Split by file size (e.g., 100 MB, 0 = disabled)
    SplitFileSize = 100 * 1024 * 1024,

    // Maximum number of files to keep (older files deleted, 0 = unlimited)
    SplitMaxFiles = 10,

    // Split by timecode difference (optional)
    SplitMaxSizeTimecode = "01:00:00:00", // 1 hour

    // Starting index for segment numbering
    StartIndex = 0,

    // M2TS mode (Blu-ray format with 192-byte packets)
    M2TSMode = false
};

// Apply to output
output.Sink = splitSettings;
```

#### Split Triggers

Files will be split when any of these conditions are met:

1. **Duration-based**: `SplitDuration` - New file created after specified time
2. **Size-based**: `SplitFileSize` - New file created when size limit reached
3. **Timecode-based**: `SplitMaxSizeTimecode` - New file when timecode difference reached

#### Filename Pattern

The filename pattern uses printf-style formatting for segment numbers:

```
// Examples of filename patterns
"recording_%02d.ts"   // recording_00.ts, recording_01.ts, ...
"stream_%05d.ts"      // stream_00000.ts, stream_00001.ts, ...
"output_%d.ts"        // output_0.ts, output_1.ts, ...
```

#### Rolling Buffer Recording

To implement a rolling buffer that keeps only the last N segments:

```
var settings = new MPEGTSSplitSinkSettings("buffer_%03d.ts")
{
    SplitDuration = TimeSpan.FromMinutes(1),  // 1 minute segments
    SplitMaxFiles = 60  // Keep last 60 minutes
};
```

#### Usage Example

```
// Complete example with split settings
var output = new MPEGTSOutput("video_%05d.ts", useAAC: true);

// Configure split settings
output.Sink = new MPEGTSSplitSinkSettings("video_%05d.ts")
{
    SplitDuration = TimeSpan.FromMinutes(5),
    SplitMaxFiles = 12,  // Keep last hour (12 x 5 minutes)
    M2TSMode = false
};

// Configure encoders
if (NVENCH264EncoderSettings.IsAvailable())
{
    output.Video = new NVENCH264EncoderSettings();
}

// Use with VideoCaptureCoreX or MediaBlocksPipeline
// The filename pattern will be used automatically
```

### Segment events

When recording with `MPEGTSSplitSinkSettings`, the Media Blocks `MPEGTSSinkBlock` raises events around each segment file, so you can name the files yourself and be notified when a segment is finished:

- `OnSegmentFileNameRequested` — raised just before a new segment file is created. Set the event's `FileName` to a custom path (for example, one that embeds the segment start time). Leave it unset to keep the default name built from the location pattern.
- `OnSegmentCreated` — raised when a new segment file has been opened.
- `OnSegmentClosed` — raised when a segment file has been finished and closed — the moment to rename the file (for example, to append its end time).

```
var splitSettings = new MPEGTSSplitSinkSettings("video_%05d.ts")
{
    SplitDuration = TimeSpan.FromMinutes(5)
};

var tsSink = new MPEGTSSinkBlock(splitSettings);

tsSink.OnSegmentClosed += (sender, e) =>
{
    // e.FileName, e.FragmentIndex and e.FragmentDuration are available here.
    Console.WriteLine($"Segment {e.FragmentIndex} finished: {e.FileName}");
};
```

`OnSegmentCreated` / `OnSegmentClosed` receive a [`SegmentSinkFileEventArgs`](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Sinks.SegmentSinkFileEventArgs.html) carrying `FileName` (string), `FragmentIndex` (uint), `RunningTime` (TimeSpan), and — on `OnSegmentClosed` only — `FragmentOffset` and `FragmentDuration` (TimeSpan?). `OnSegmentFileNameRequested` receives a [`SegmentSinkFileNameEventArgs`](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Sinks.SegmentSinkFileNameEventArgs.html) whose settable `FileName` overrides the segment name. The same events are available on `MP4SinkBlock` / `MP4OutputBlock` — see the [MP4 output](../mp4/) page for a full custom-naming and rename-on-close example.

Threading

These events fire on a GStreamer streaming thread, so a handler must not touch UI controls directly — marshal to the UI thread. The file rename inside `OnSegmentClosed` is plain file I/O and is safe to do there.

### Advanced Features

#### Custom Processing

The MPEGTSOutput supports custom video and audio processing through MediaBlocks:

```
// Add custom video processing
output.CustomVideoProcessor = new YourCustomVideoProcessor();

// Add custom audio processing
output.CustomAudioProcessor = new YourCustomAudioProcessor();
```

#### Sink Settings

The output uses `MPEGTSSinkSettings` (or the derived `MPEGTSSplitSinkSettings` for segmented output) for configuration:

```
// Access sink settings
output.Sink.Filename = "modified_output.ts";
```

### Platform Considerations

- Some encoders (MF AAC, MF HEVC) are only available on Windows platforms
- Cross-platform applications should use platform-agnostic encoders like VO-AAC for audio

### Best Practices

1. **Hardware Acceleration**: When available, prefer hardware-accelerated encoders (NVENC, QSV, AMF) over software encoders for better performance.
2. **Audio Codec Selection**: Use AAC for better compatibility and quality unless you have specific requirements for MP3.
3. **Error Handling**: Always check for encoder availability before using hardware-accelerated options:

```
if (NVENCH264EncoderSettings.IsAvailable())
{
    // Use NVIDIA encoder
}
else if (QSVH264EncoderSettings.IsAvailable())
{
    // Fall back to Intel Quick Sync
}
else
{
    // Fall back to software encoding
}
```

**Cross-Platform Compatibility**: For cross-platform applications, ensure you're using encoders available on all target platforms or implement appropriate fallbacks.

### Implementation Example

Here's a complete example showing how to create and configure an MPEG-TS output:

```
var output = new MPEGTSOutput("output.ts", useAAC: true);

// Configure video encoder
if (NVENCH264EncoderSettings.IsAvailable())
{
    output.Video = new NVENCH264EncoderSettings();
}
else if (QSVH264EncoderSettings.IsAvailable())
{
    output.Video = new QSVH264EncoderSettings();
}
else
{
    output.Video = new OpenH264EncoderSettings();
}

// Configure audio encoder based on platform
#if NET_WINDOWS
    output.Audio = new MFAACEncoderSettings();
#else
    output.Audio = new VOAACEncoderSettings();
#endif

// Optional: Add custom processing
output.CustomVideoProcessor = new YourCustomVideoProcessor();
output.CustomAudioProcessor = new YourCustomAudioProcessor();
```

## Windows-only MPEG-TS output

[VideoCaptureCore](#)

The `MPEGTSOutput` class provides configuration settings for MPEG Transport Stream (MPEG-TS) output in the VisioForge video processing framework. This class inherits from `MFBaseOutput` and implements the `IVideoCaptureBaseOutput` interface, so the classic Windows engine exposes it through `VideoCaptureCore` only — classic `VideoEditCore` has no MPEG-TS output path (use `VideoEditCoreX` for cross-platform MPEG-TS instead).

### Class Hierarchy

```
MFBaseOutput
    └── MPEGTSOutput
```

### Inherited Video Settings

The [MPEGTSOutput](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.MPEGTSOutput.html) class inherits video encoding capabilities from MFBaseOutput, which includes:

**Video Encoding Configuration**: Through the `Video` property, supporting:

- Multiple codec options (H.264/H.265) with hardware acceleration support
- Bitrate control (CBR/VBR)
- Quality settings
- Frame type and GOP structure configuration
- Interlacing options
- Resolution and aspect ratio controls

### Inherited Audio Settings

Audio configuration is handled through the inherited `Audio` property of type M4AOutput, which includes:

AAC audio encoding with configurable:

- Version (default: MPEG-4)
- Object type (default: AAC-LC)
- Bitrate (default: 128 kbps)
- Output format (default: RAW)

### Usage

#### Basic Implementation

```
// Create VideoCaptureCore instance
var core = new VideoCaptureCore();

// Set output filename
core.Output_Filename = "output.ts";

// Create MPEG-TS output
var mpegtsOutput = new MPEGTSOutput();

// Configure video settings
mpegtsOutput.Video.Codec = MFVideoEncoder.MS_H264;
mpegtsOutput.Video.AvgBitrate = 2000; // 2 Mbps
mpegtsOutput.Video.RateControl = MFCommonRateControlMode.CBR;

// Configure audio settings
mpegtsOutput.Audio.Bitrate = 128; // 128 kbps
mpegtsOutput.Audio.Version = AACVersion.MPEG4;

core.Output_Format = mpegtsOutput;
```

#### Serialization Support

The class provides built-in JSON serialization support for saving and loading configurations:

```
// Save configuration
string jsonConfig = mpegtsOutput.Save();

// Load configuration
MPEGTSOutput loadedConfig = MPEGTSOutput.Load(jsonConfig);
```

### Default Configuration

The `MPEGTSOutput` class initializes with these default settings:

#### Video Defaults (inherited from MFBaseOutput)

- Average Bitrate: 2000 kbps
- Codec: Microsoft H.264
- Profile: Main
- Level: 4.2
- Rate Control: CBR
- Quality vs Speed: 85
- Maximum Reference Frames: 2
- MaxKeyFrameSpacing (GOP size): 125 frames
- B-Picture Count: 0
- Low Latency Mode: Disabled
- CABAC: Disabled
- Interlace Mode: Progressive

#### Audio Defaults

- Bitrate: 128 kbps
- AAC Version: MPEG-4
- AAC Object Type: Low Complexity (LC)
- Output Format: RAW

### Best Practices

1. **Bitrate Configuration**:
2. For streaming applications, ensure the combined video and audio bitrates are within your target bandwidth
3. Consider using VBR for storage scenarios and CBR for streaming
4. **Hardware Acceleration**:
5. When available, use hardware-accelerated encoders (QSV, NVENC, AMD) for better performance
6. Fall back to MS\_H264/MS\_H265 when hardware acceleration is unavailable
7. **Quality Optimization**:
8. For higher quality at the cost of performance, increase the `QualityVsSpeed` value
9. Enable CABAC for better compression efficiency in non-low-latency scenarios
10. Adjust `MaxKeyFrameSpacing` based on your specific use case (lower values for better seeking, higher values for better compression)

### Technical Notes

1. **MPEG-TS Characteristics**:
2. Suitable for streaming and broadcasting applications
3. Provides error resilience through packet-based structure
4. Supports multiple programs and elementary streams
5. **Performance Considerations**:
6. Low latency mode trades quality for reduced encoding delay
7. B-frames improve compression but increase latency
8. Hardware acceleration can significantly reduce CPU usage

### Required redists

- Video Capture SDK redist [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/) [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)
- Video Edit SDK redist [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoEdit.x86/) [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoEdit.x64/)
- MP4 redist [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MP4.x86/) [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MP4.x64/)

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Professional MXF Integration for .NET Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/mxf/
**Description:** Generate broadcast MXF files in .NET with hardware acceleration, codec optimization, and professional workflows for broadcast production.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Encoding, Editing, MXF, H.264, H.265, AAC, MP3, C#
**API:** QSVH264EncoderSettings, MXFOutput, NVENCH264EncoderSettings, AMFH264EncoderSettings, MFAACEncoderSettings

# MXF Output in VisioForge .NET SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

Material Exchange Format (MXF) is an industry-standard container format designed for professional video applications. It's widely adopted in broadcast environments, post-production workflows, and archival systems. VisioForge SDKs provide robust cross-platform MXF output capabilities that allow developers to integrate this professional format into their applications.

## Understanding MXF Format

MXF serves as a wrapper that can contain various types of video and audio data along with metadata. The format was designed to address interoperability issues in professional video workflows:

- **Industry Standard**: Adopted by major broadcasters worldwide
- **Professional Metadata**: Supports extensive technical and descriptive metadata
- **Versatile Container**: Compatible with numerous audio and video codecs
- **Cross-Platform**: Supported across Windows, macOS, and Linux

## Getting Started with MXF Output

Two code paths cover 99% of uses:

- **`MXFOutput`** (class in `VisioForge.Core.Types.X.Output`) is a settings object consumed by `VideoCaptureCoreX.Outputs_Add(...)` or set as `VideoEditCoreX.Output_Format`.
- **`MXFSinkBlock`** + **`MXFSinkSettings`** are the Media Blocks path when you drive the pipeline by hand.

### Basic implementation

Here's the foundational code to create an MXF output:

```
var mxfOutput = new MXFOutput(
    filename: "output.mxf",
    videoStreamType: MXFVideoStreamType.H264,
    audioStreamType: MXFAudioStreamType.MPEG
);
```

This creates a valid MXF output with default encoding settings. For professional applications, you'll typically want to customize the encoding parameters.

## Video Encoding Options for MXF

The quality and compatibility of your MXF output largely depends on your choice of video encoder. VisioForge SDKs support multiple encoder options to balance performance, quality, and compatibility. For detailed configuration options, see the [H.264 encoder documentation](../../video-encoders/h264/) and [HEVC encoder documentation](../../video-encoders/hevc/).

> Video encoder `Bitrate` properties on the X namespace are in **Kbps** (so 8000 = 8 Mbps). Don't pass raw bits per second.

### Hardware-Accelerated Encoders

For optimal performance in real-time applications, hardware-accelerated encoders are recommended:

#### NVIDIA NVENC Encoders

```
// Check availability first
if (NVENCH264EncoderSettings.IsAvailable())
{
    var nvencSettings = new NVENCH264EncoderSettings
    {
        Bitrate = 8000, // 8 Mbps (Kbps)
    };

    mxfOutput.Video = nvencSettings;
}
```

#### Intel Quick Sync Video (QSV) Encoders

```
if (QSVH264EncoderSettings.IsAvailable())
{
    var qsvSettings = new QSVH264EncoderSettings
    {
        Bitrate = 8000,
    };

    mxfOutput.Video = qsvSettings;
}
```

#### AMD Advanced Media Framework (AMF) Encoders

```
if (AMFH264EncoderSettings.IsAvailable())
{
    var amfSettings = new AMFH264EncoderSettings
    {
        Bitrate = 8000,
    };

    mxfOutput.Video = amfSettings;
}
```

### Software-Based Encoders

When hardware acceleration isn't available, software encoders provide reliable alternatives:

#### OpenH264 Encoder

```
var openH264Settings = new OpenH264EncoderSettings
{
    Bitrate = 8000,
};

mxfOutput.Video = openH264Settings;
```

### High-Efficiency Video Coding (HEVC/H.265)

For applications requiring higher compression efficiency:

```
// NVIDIA HEVC encoder
if (NVENCHEVCEncoderSettings.IsAvailable())
{
    var nvencHevcSettings = new NVENCHEVCEncoderSettings
    {
        Bitrate = 5000, // Lower bitrate possible with HEVC
    };

    mxfOutput.Video = nvencHevcSettings;
}
```

## Audio Encoding for MXF Files

While video often gets the most attention, proper audio encoding is crucial for professional MXF outputs. VisioForge SDKs offer multiple audio encoder options. For detailed configuration options, see the [AAC encoder documentation](../../audio-encoders/aac/) and [MP3 encoder documentation](../../audio-encoders/mp3/).

> Audio encoder `Bitrate` on the X namespace is also in **Kbps** (so 192 = 192 kbps). `MFAACEncoderSettings` and `VOAACEncoderSettings` do expose a `SampleRate` property (default 48000); only `MP3EncoderSettings` has no sample-rate setter and follows the upstream source's audio format. Channel layout on all three follows the upstream audio unless reshaped upstream (e.g., via `AudioResamplerBlock`).

### AAC Encoders

AAC is the preferred codec for most professional applications:

```
// Media Foundation AAC (Windows-only)
#if NET_WINDOWS
    var mfAacSettings = new MFAACEncoderSettings
    {
        Bitrate = 192, // kbps
    };

    mxfOutput.Audio = mfAacSettings;
#else
    // Cross-platform AAC alternative
    var voAacSettings = new VOAACEncoderSettings
    {
        Bitrate = 192,
    };

    mxfOutput.Audio = voAacSettings;
#endif
```

### MP3 Encoder

For maximum compatibility:

```
var mp3Settings = new MP3EncoderSettings
{
    Bitrate = 320,         // Kbps — must be one of 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320
    ForceMono = false      // Default; set true to downmix to mono
};

mxfOutput.Audio = mp3Settings;
```

## Advanced MXF Configuration

### Custom Processing Pipelines

One of the powerful features of VisioForge SDKs is the ability to add custom processing to your MXF output chain:

```
// Add custom video processing
mxfOutput.CustomVideoProcessor = yourVideoProcessingBlock;

// Add custom audio processing
mxfOutput.CustomAudioProcessor = yourAudioProcessingBlock;
```

### Sink Configuration

Fine-tune your MXF output with sink settings:

```
// Access sink settings (MXFSinkSettings)
mxfOutput.Sink.Filename = "new_output.mxf";
```

## Cross-Platform Considerations

Building applications that work across different platforms requires careful planning:

```
// Platform-specific encoder selection
var mxfOutput = new MXFOutput(
    filename: "output.mxf",
    videoStreamType: MXFVideoStreamType.H264,
    audioStreamType: MXFAudioStreamType.MPEG
);

#if NET_WINDOWS
    if (QSVH264EncoderSettings.IsAvailable())
    {
        mxfOutput.Video = new QSVH264EncoderSettings { Bitrate = 8000 };
        mxfOutput.Audio = new MFAACEncoderSettings { Bitrate = 192 };
    }
#elif NET_MACOS
    mxfOutput.Video = new OpenH264EncoderSettings { Bitrate = 8000 };
    mxfOutput.Audio = new VOAACEncoderSettings { Bitrate = 192 };
#else
    mxfOutput.Video = new OpenH264EncoderSettings { Bitrate = 8000 };
    mxfOutput.Audio = new MP3EncoderSettings { Bitrate = 320 };
#endif
```

## Error Handling and Validation

Robust MXF implementations require proper error handling:

```
try
{
    // Create MXF output
    var mxfOutput = new MXFOutput(
        filename: Path.Combine(outputDirectory, "output.mxf"),
        videoStreamType: MXFVideoStreamType.H264,
        audioStreamType: MXFAudioStreamType.MPEG
    );

    // Validate encoder availability
    if (!OpenH264EncoderSettings.IsAvailable())
    {
        throw new ApplicationException("No compatible H.264 encoder found");
    }

    // Validate output directory
    var directoryInfo = new DirectoryInfo(Path.GetDirectoryName(mxfOutput.Sink.Filename));
    if (!directoryInfo.Exists)
    {
        Directory.CreateDirectory(directoryInfo.FullName);
    }

    // Attach MXFOutput as a VideoCaptureCoreX output
    videoCapture.Outputs_Add(mxfOutput, autostart: true);
    await videoCapture.StartAsync();
}
catch (Exception ex)
{
    logger.LogError($"MXF output error: {ex.Message}");
    // Implement fallback strategy
}
```

## Performance Optimization

For optimal MXF output performance:

1. **Prioritize Hardware Acceleration**: Always check for and use hardware encoders first
2. **Buffer Management**: Adjust buffer sizes based on system capabilities
3. **Parallel Processing**: Utilize multi-threading where appropriate
4. **Preset Selection**: Choose encoder presets based on quality vs. speed requirements

## Complete Implementation Example — VideoCaptureCoreX

Here's a full example demonstrating MXF implementation with fallback options:

```
// Create MXF output with specific stream types
var mxfOutput = new MXFOutput(
    filename: "output.mxf",
    videoStreamType: MXFVideoStreamType.H264,
    audioStreamType: MXFAudioStreamType.MPEG
);

// Configure video encoder with prioritized fallback chain (bitrate in Kbps)
if (NVENCH264EncoderSettings.IsAvailable())
{
    mxfOutput.Video = new NVENCH264EncoderSettings { Bitrate = 8000 };
}
else if (QSVH264EncoderSettings.IsAvailable())
{
    mxfOutput.Video = new QSVH264EncoderSettings { Bitrate = 8000 };
}
else if (AMFH264EncoderSettings.IsAvailable())
{
    mxfOutput.Video = new AMFH264EncoderSettings { Bitrate = 8000 };
}
else
{
    mxfOutput.Video = new OpenH264EncoderSettings { Bitrate = 8000 };
}

// Configure platform-optimized audio (Kbps)
#if NET_WINDOWS
    mxfOutput.Audio = new MFAACEncoderSettings { Bitrate = 192 };
#else
    mxfOutput.Audio = new VOAACEncoderSettings { Bitrate = 192 };
#endif

// Attach to VideoCaptureCoreX (or VideoEditCoreX: videoEdit.Output_Format = mxfOutput;)
videoCapture.Outputs_Add(mxfOutput, autostart: true);

await videoCapture.StartAsync();
```

## Complete Implementation Example — MediaBlocksPipeline

When you're driving the pipeline by hand, use `MXFSinkBlock` + `MXFSinkSettings` instead of `MXFOutput`:

```
var pipeline = new MediaBlocksPipeline();

var mxfSettings = new MXFSinkSettings("output.mxf",
    videoStreamType: MXFVideoStreamType.H264,
    audioStreamType: MXFAudioStreamType.MPEG);

var mxfSink = new MXFSinkBlock(mxfSettings);

// videoEncoder / audioEncoder are existing H264EncoderBlock / AACEncoderBlock instances
pipeline.Connect(videoEncoder.Output, mxfSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(audioEncoder.Output, mxfSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

By following this guide, you can implement professional-grade MXF output in your applications using VisioForge .NET SDKs, ensuring compatibility with broadcast workflows and post-production systems.

---END OF PAGE---


## WebM Video Output with VP8, VP9, AV1 Codecs in .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/webm/
**Description:** Create WebM videos in .NET with VP8, VP9, and AV1 codecs for efficient web-ready video streaming and HTML5 content delivery.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Recording, Encoding, Editing, WebM, VP8, VP9, AV1, Opus, Vorbis, C#, NuGet
**API:** WebMOutput, VideoCaptureCore, VideoEditCore, VideoCaptureCoreX, VideoEditCoreX

# WebM Video Output in VisioForge .NET SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## What is WebM?

WebM is an open-source, royalty-free media file format optimized for web delivery. Developed to provide efficient video streaming with minimal processing requirements, WebM has become a standard for HTML5 video content. The format supports modern codecs including VP8 and VP9 for video compression, along with Vorbis and Opus for audio encoding.

The key advantages of WebM include:

- **Web-optimized performance** with fast loading times
- **Broad browser support** across major platforms
- **High-quality video** at smaller file sizes
- **Open-source licensing** without royalty costs
- **Efficient streaming** capabilities for media applications

## Windows Implementation

[VideoCaptureCore](#) [VideoEditCore](#)

On Windows platforms, VisioForge's implementation leverages the [WebMOutput](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.WebMOutput.html) class from the `VisioForge.Core.Types.X.Output` namespace.

### Basic Configuration

To quickly implement WebM output in your Windows application:

```
using VisioForge.Core.Types.Output;

// Initialize WebM output settings
var webmOutput = new WebMOutput();

// Configure essential parameters
webmOutput.Video_Mode = VP8QualityMode.Realtime;
webmOutput.Video_EndUsage = VP8EndUsageMode.VBR;
webmOutput.Video_Encoder = WebMVideoEncoder.VP8;
webmOutput.Video_Bitrate = 2000;
webmOutput.Audio_Quality = 80;

// Apply to your core instance
var core = new VideoCaptureCore(); // or VideoEditCore
core.Output_Format = webmOutput;
core.Output_Filename = "output.webm";
```

### Video Quality Settings

Fine-tuning your WebM video quality involves balancing several parameters:

```
var webmOutput = new WebMOutput();

// Quality parameters
webmOutput.Video_MinQuantizer = 4;    // Lower values = higher quality (range: 0-63)
webmOutput.Video_MaxQuantizer = 48;   // Upper quality bound (range: 0-63)
webmOutput.Video_Bitrate = 2000;      // Target bitrate in kbps

// Encode with multiple threads for better performance
webmOutput.Video_ThreadCount = 4;     // Adjust based on available CPU cores
```

### Keyframe Control

Proper keyframe configuration is crucial for efficient streaming and seeking:

```
// Keyframe settings
webmOutput.Video_Keyframe_MinInterval = 30;   // Minimum frames between keyframes
webmOutput.Video_Keyframe_MaxInterval = 300;  // Maximum frames between keyframes
webmOutput.Video_Keyframe_Mode = VP8KeyframeMode.Auto;
```

### Performance Optimization

Balance encoding speed and quality with these parameters:

```
// Performance settings
webmOutput.Video_CPUUsed = 0;           // Range: -16 to 16 (higher = faster encoding, lower quality)
webmOutput.Video_LagInFrames = 25;      // Frame look-ahead buffer (higher = better quality)
webmOutput.Video_ErrorResilient = true; // Enable for streaming applications
```

### Buffer Management

For streaming applications, proper buffer configuration improves playback stability:

```
// Buffer settings
webmOutput.Video_Decoder_Buffer_Size = 6000;        // Buffer size in milliseconds
webmOutput.Video_Decoder_Buffer_InitialSize = 4000; // Initial buffer fill level
webmOutput.Video_Decoder_Buffer_OptimalSize = 5000; // Target buffer level

// Rate control fine-tuning
webmOutput.Video_UndershootPct = 50;  // Allows bitrate to drop below target
webmOutput.Video_OvershootPct = 50;   // Allows bitrate to exceed target temporarily
```

## Cross-Platform Implementation

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

For cross-platform applications, VisioForge provides the [WebMOutput](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.WebMOutput.html) class from the `VisioForge.Core.Types.X.Output` namespace, offering enhanced codec flexibility.

### Basic Setup

```
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.VideoEncoders;
using VisioForge.Core.Types.X.AudioEncoders;

// Create WebM output
var webmOutput = new WebMOutput("output.webm");

// Configure video encoder (VP8)
webmOutput.Video = new VP8EncoderSettings();

// Configure audio encoder (Vorbis)
webmOutput.Audio = new VorbisEncoderSettings();
```

### Integration with Video Capture SDK

```
// Add WebM output to Video Capture SDK
var core = new VideoCaptureCoreX();
core.Outputs_Add(webmOutput, true);
```

### Integration with Video Edit SDK

```
// Set WebM as output format for Video Edit SDK
var core = new VideoEditCoreX();
core.Output_Format = webmOutput;
```

### Integration with Media Blocks SDK

```
// Create encoders
var vorbis = new VorbisEncoderSettings();
var vp9 = new VP9EncoderSettings();

// Configure WebM output block
var webmSettings = new WebMSinkSettings("output.webm");
var webmOutput = new WebMOutputBlock(webmSettings, vp9, vorbis);

// Add to your pipeline
// pipeline.AddBlock(webmOutput);
```

## Codec Selection Guide

### Video Codecs

VisioForge SDKs support multiple video codecs for WebM:

1. **VP8**
2. Faster encoding speed
3. Lower computational requirements
4. Wider compatibility with older browsers
5. Good quality for standard video
6. **VP9**
7. Better compression efficiency (30-50% smaller files vs. VP8)
8. Higher quality at the same bitrate
9. Slower encoding performance
10. Ideal for high-resolution content
11. **AV1**
12. Next-generation codec with superior compression
13. Highest quality per bit
14. Significantly higher encoding complexity
15. Best for situations where encoding time isn't critical

For codec-specific settings, refer to our dedicated documentation pages:

- [VP8/VP9 Configuration](../../video-encoders/vp8-vp9/)
- [AV1 Configuration](../../video-encoders/av1/)

### Audio Codecs

Two primary audio codec options are available:

1. **Vorbis**
2. Established codec with good overall quality
3. Compatible with all WebM-supporting browsers
4. Default choice for most applications
5. **Opus**
6. Superior audio quality, especially at low bitrates
7. Better for voice content and music
8. Lower latency for streaming applications
9. More efficient for bandwidth-constrained scenarios

For detailed audio settings, see:

- [Vorbis Configuration](../../audio-encoders/vorbis/)
- [Opus Configuration](../../audio-encoders/opus/)

## Optimization Strategies

### For Video Quality

To achieve the highest possible video quality:

- Use VP9 or AV1 for video encoding
- Set lower quantizer values (higher quality)
- Increase `LagInFrames` for better lookahead analysis
- Use 2-pass encoding for offline video processing
- Set higher bitrates for complex visual content

```
// Quality-focused VP9 configuration (properties live on the shared VPXEncoderSettings base).
var vp9 = new VP9EncoderSettings
{
    TargetBitrate = 3000,                    // kbps — higher bitrate for better quality
    CPUUsed       = 0,                       // 0 = slowest/highest-quality; raise toward 5 for speed
    Deadline      = 0,                       // 0 = best, 1 = realtime (microseconds per frame)
    RateControl   = VPXRateControl.VBR,      // variable bitrate for quality work
    MultipassMode = VPXMultipassMode.OnePass // switch to FirstPass/LastPass for 2-pass workflows
};
```

### For Real-time Applications

When low latency is critical:

- Choose VP8 for faster encoding
- Use single-pass encoding
- Set `CPUUsed` to higher values
- Use smaller frame lookahead buffers
- Configure shorter keyframe intervals

```
// Low-latency VP8 configuration
var vp8 = new VP8EncoderSettings
{
    RateControl    = VPXRateControl.CBR,               // constant bitrate for predictable streaming
    CPUUsed        = 8,                                // 0..16 on VP8 — higher = faster/worse quality
    Deadline       = 1,                                // 1 = realtime (microseconds per frame; 0 = best quality)
    ErrorResilient = VPXErrorResilientFlags.Default    // enable resilience bitflags for packet-loss recovery
};
```

### For File Size Efficiency

To minimize storage requirements:

- Use VP9 or AV1 for maximum compression
- Enable two-pass encoding
- Set appropriate target bitrates
- Use Variable Bit Rate (VBR) encoding
- Avoid unnecessary keyframes

```
// Storage-optimized configuration using the AOM reference AV1 encoder.
// Other AV1 variants: SVTAV1EncoderSettings, NVENCAV1EncoderSettings, AMFAV1EncoderSettings, QSVAV1EncoderSettings.
var av1 = new AOMAV1EncoderSettings
{
    RateControl = AOMAV1EncoderEndUsageMode.VBR,  // variable bitrate for efficiency
    CPUUsed     = 2                               // balance between speed and compression (0 = slowest/best)
};
```

## Dependencies

To implement WebM output, add the appropriate NuGet packages to your project:

- For x86 platforms: [VisioForge.DotNet.Core.Redist.WebM.x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.WebM.x86)
- For x64 platforms: [VisioForge.DotNet.Core.Redist.WebM.x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.WebM.x64)

## Learning Resources

For additional implementation examples and more advanced scenarios, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) containing sample code for all VisioForge SDKs.

---END OF PAGE---


## WMV Encoding in .NET — Windows Media Video Output Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/general/output-formats/wmv/
**Description:** Implement Windows Media Video encoding in .NET with audio/video configuration, streaming options, and cross-platform profile management.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Streaming, Encoding, Editing, Screen Capture, MP4, WMV, WMA, C#
**API:** WMVOutput, WMVMode, WMVStreamMode, VideoCaptureCore

# Windows Media Video encoders

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

This documentation covers the Windows Media Video (WMV) encoding capabilities available in VisioForge, including both Windows-specific and cross-platform solutions.

## Windows-only output

[VideoCaptureCore](#) [VideoEditCore](#)

The [WMVOutput](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.WMVOutput.html) class provides comprehensive Windows Media encoding capabilities for both audio and video on Windows platforms.

### Quick Start Guide

#### Simple Video Capture with Default Settings

```
using VisioForge.Core.VideoCapture;
using VisioForge.Core.Types.Output;

var captureCore = new VideoCaptureCore();

// Use default WMV settings (Internal Profile mode)
captureCore.Output_Format = new WMVOutput();
captureCore.Output_Filename = "output.wmv";

await captureCore.StartAsync();
```

#### Simple Video Editing with Default Settings

```
using VisioForge.Core.VideoEdit;
using VisioForge.Core.Types.Output;

var editCore = new VideoEditCore();

// Use default WMV settings
editCore.Output_Format = new WMVOutput();
editCore.Output_Filename = "edited_output.wmv";

// Add input files and configure editing...

await editCore.StartAsync();
```

#### Custom Settings Example

```
using VisioForge.Core.VideoCapture;
using VisioForge.Core.Types.Output;

var wmvOutput = new WMVOutput
{
    Mode = WMVMode.CustomSettings,

    // Video configuration
    Custom_Video_StreamPresent = true,
    Custom_Video_Codec = "Windows Media Video 9",
    Custom_Video_Mode = WMVStreamMode.VBRQuality,
    Custom_Video_Quality = 90,
    Custom_Video_Width = 1280,
    Custom_Video_Height = 720,
    Custom_Video_FrameRate = 30.0,

    // Audio configuration
    Custom_Audio_StreamPresent = true,
    Custom_Audio_Codec = "Windows Media Audio 9.2",
    Custom_Audio_Mode = WMVStreamMode.VBRQuality,
    Custom_Audio_Quality = 90,
    Custom_Audio_Format = "48kHz 16bit Stereo"
};

var captureCore = new VideoCaptureCore();
captureCore.Output_Format = wmvOutput;
captureCore.Output_Filename = "custom_output.wmv";

await captureCore.StartAsync();
```

### Audio Encoding Features

The `WMVOutput` class offers several audio-specific configuration options:

- Custom audio codec selection
- Audio format customization
- Multiple stream modes
- Bitrate control
- Quality settings
- Language support
- Buffer size management

### Rate Control Modes

WMV encoding supports four rate control modes through the `WMVStreamMode` enum:

1. CBR (Constant Bitrate)
2. VBRQuality (Variable Bitrate based on quality)
3. VBRBitrate (Variable Bitrate with target bitrate)
4. VBRPeakBitrate (Variable Bitrate with peak bitrate constraint)

### Configuration Modes

The encoder can be configured in several ways using the `WMVMode` enum:

- ExternalProfile: Load settings from a profile file
- ExternalProfileFromText: Load settings from a text string
- InternalProfile: Use built-in profiles
- CustomSettings: Manual configuration
- V8SystemProfile: Use Windows Media 8 system profiles

### Sample Code

Create new WMV custom output configuration:

```
var wmvOutput = new WMVOutput
{
    // Basic configuration
    Mode = WMVMode.CustomSettings,

    // Audio settings
    Custom_Audio_StreamPresent = true,
    Custom_Audio_Mode = WMVStreamMode.VBRQuality,
    Custom_Audio_Quality = 98,
    Custom_Audio_PeakBitrate = 192000,
    Custom_Audio_PeakBufferSize = 3,

    // Optional language setting
    Custom_Audio_LanguageID = "en-US"
};
```

Using an internal profile:

```
var profileWmvOutput = new WMVOutput
{
    Mode = WMVMode.InternalProfile,
    Internal_Profile_Name = "Windows Media Video 9 for Local Network (768 kbps)"
};
```

Network streaming configuration:

```
var streamingWmvOutput = new WMVOutput
{
    Mode = WMVMode.CustomSettings,
    Network_Streaming_WMV_Maximum_Clients = 20,
    Custom_Audio_Mode = WMVStreamMode.CBR
};
```

### Custom Profile Configuration

Custom profiles give you the most flexibility by allowing you to configure every aspect of the encoding process. Here are several examples for different scenarios:

#### Understanding WMV Custom Settings Properties

Before diving into examples, it's important to understand the key properties available in the `WMVOutput` class for custom configuration:

**Video Properties:** - `Custom_Video_StreamPresent` (bool): Enables video stream in the output - `Custom_Video_Codec` (string): Specifies the video codec (e.g., "Windows Media Video 9") - `Custom_Video_Mode` (WMVStreamMode): Rate control mode (CBR, VBRQuality, VBRBitrate, VBRPeakBitrate) - `Custom_Video_Bitrate` (int): Target bitrate in bits per second - `Custom_Video_Quality` (byte): Quality level (0-100) for VBR quality mode - `Custom_Video_Width` (int): Output video width in pixels - `Custom_Video_Height` (int): Output video height in pixels - `Custom_Video_SizeSameAsInput` (bool): Use input video dimensions - `Custom_Video_FrameRate` (double): Output frame rate - `Custom_Video_KeyFrameInterval` (byte): Number of frames between keyframes - `Custom_Video_Smoothness` (byte): Smoothness level (0-100) - `Custom_Video_Peak_BitRate` (int): Peak bitrate for VBR peak mode - `Custom_Video_Peak_BufferSizeSeconds` (byte): Peak buffer window in seconds - `Custom_Video_Buffer_Size` (int): Buffer size in milliseconds - `Custom_Video_Buffer_UseDefault` (bool): Use default buffer settings - `Custom_Video_TVSystem` (WMVTVSystem): TV system standard (NTSC, PAL)

**Audio Properties:** - `Custom_Audio_StreamPresent` (bool): Enables audio stream in the output - `Custom_Audio_Codec` (string): Specifies the audio codec (e.g., "Windows Media Audio 9.2") - `Custom_Audio_Format` (string): Format specification (e.g., "48kHz 16bit Stereo") - `Custom_Audio_Mode` (WMVStreamMode): Rate control mode - `Custom_Audio_Quality` (byte): Quality level (0-100) for VBR quality mode - `Custom_Audio_PeakBitrate` (int): Peak bitrate in bits per second - `Custom_Audio_PeakBufferSize` (byte): Peak buffer window in seconds - `Custom_Audio_LanguageID` (string): Language identifier (e.g., "en-US")

**Profile Metadata:** - `Custom_Profile_Name` (string): Profile name for identification - `Custom_Profile_Description` (string): Detailed description of profile purpose - `Custom_Profile_Language` (string): Profile language identifier

#### High-Quality Video Streaming Configuration

Perfect for professional streaming applications requiring excellent visual quality:

```
var highQualityConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,

    // Video settings - High quality 1080p
    Custom_Video_StreamPresent = true,
    Custom_Video_Codec = "Windows Media Video 9",
    Custom_Video_Mode = WMVStreamMode.VBRQuality,
    Custom_Video_Quality = 95,
    Custom_Video_Width = 1920,
    Custom_Video_Height = 1080,
    Custom_Video_FrameRate = 30.0,
    Custom_Video_KeyFrameInterval = 4,
    Custom_Video_Smoothness = 80,
    Custom_Video_Buffer_UseDefault = false,
    Custom_Video_Buffer_Size = 4000,

    // Audio settings - High quality stereo
    Custom_Audio_StreamPresent = true,
    Custom_Audio_Codec = "Windows Media Audio 9.2",
    Custom_Audio_Mode = WMVStreamMode.VBRQuality,
    Custom_Audio_Quality = 98,
    Custom_Audio_Format = "48kHz 16bit Stereo",
    Custom_Audio_PeakBitrate = 320000,
    Custom_Audio_PeakBufferSize = 3,

    // Profile metadata
    Custom_Profile_Name = "High Quality Streaming",
    Custom_Profile_Description = "1080p streaming profile with high quality audio",
    Custom_Profile_Language = "en-US"
};

// Apply to VideoCaptureCore
var captureCore = new VideoCaptureCore();
captureCore.Output_Format = highQualityConfig;
captureCore.Output_Filename = "output_hq.wmv";

// Or apply to VideoEditCore
var editCore = new VideoEditCore();
editCore.Output_Format = highQualityConfig;
editCore.Output_Filename = "output_hq.wmv";
```

#### Low Bandwidth Configuration for Mobile Streaming

Optimized for mobile devices with limited bandwidth:

```
var mobileLowBandwidthConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,

    // Video settings optimized for mobile
    Custom_Video_StreamPresent = true,
    Custom_Video_Codec = "Windows Media Video 9",
    Custom_Video_Mode = WMVStreamMode.CBR,
    Custom_Video_Bitrate = 800000, // 800 kbps
    Custom_Video_Width = 854,
    Custom_Video_Height = 480,
    Custom_Video_FrameRate = 24.0,
    Custom_Video_KeyFrameInterval = 5,
    Custom_Video_Smoothness = 60,
    Custom_Video_Buffer_UseDefault = true,

    // Audio settings for low bandwidth
    Custom_Audio_StreamPresent = true,
    Custom_Audio_Codec = "Windows Media Audio 9.2",
    Custom_Audio_Mode = WMVStreamMode.CBR,
    Custom_Audio_PeakBitrate = 64000, // 64 kbps
    Custom_Audio_Format = "44kHz 16bit Mono",
    Custom_Audio_LanguageID = "en-US",

    Custom_Profile_Name = "Mobile Low Bandwidth",
    Custom_Profile_Description = "480p optimized for mobile devices"
};

// Apply to VideoCaptureCore
var captureCore = new VideoCaptureCore();
captureCore.Output_Format = mobileLowBandwidthConfig;
captureCore.Output_Filename = "output_mobile.wmv";
```

#### Audio-Focused Configuration for Music Content

High-quality audio with minimal video processing:

```
var audioFocusedConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,

    // High quality audio settings
    Custom_Audio_StreamPresent = true,
    Custom_Audio_Codec = "Windows Media Audio 9.2 Professional",
    Custom_Audio_Mode = WMVStreamMode.VBRQuality,
    Custom_Audio_Quality = 99,
    Custom_Audio_Format = "96kHz 24bit Stereo",
    Custom_Audio_PeakBitrate = 512000,
    Custom_Audio_PeakBufferSize = 4,
    Custom_Audio_LanguageID = "en-US",

    // Minimal video settings
    Custom_Video_StreamPresent = true,
    Custom_Video_Codec = "Windows Media Video 9",
    Custom_Video_Mode = WMVStreamMode.VBRBitrate,
    Custom_Video_Bitrate = 500000,
    Custom_Video_Width = 1280,
    Custom_Video_Height = 720,
    Custom_Video_FrameRate = 25.0,
    Custom_Video_KeyFrameInterval = 10,
    Custom_Video_Buffer_UseDefault = true,

    Custom_Profile_Name = "Audio Focus",
    Custom_Profile_Description = "High quality audio configuration for music content"
};

// Apply to VideoEditCore for processing audio files with video
var editCore = new VideoEditCore();
editCore.Output_Format = audioFocusedConfig;
editCore.Output_Filename = "output_audio_focus.wmv";
```

#### Constant Bitrate (CBR) for Streaming

CBR mode is ideal for network streaming where consistent bandwidth is required:

```
var cbrStreamingConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,

    // Video settings with CBR
    Custom_Video_StreamPresent = true,
    Custom_Video_Codec = "Windows Media Video 9",
    Custom_Video_Mode = WMVStreamMode.CBR,
    Custom_Video_Bitrate = 2000000, // 2 Mbps constant
    Custom_Video_Width = 1280,
    Custom_Video_Height = 720,
    Custom_Video_FrameRate = 30.0,
    Custom_Video_KeyFrameInterval = 3,
    Custom_Video_Buffer_Size = 3000,
    Custom_Video_Buffer_UseDefault = false,

    // Audio settings with CBR
    Custom_Audio_StreamPresent = true,
    Custom_Audio_Codec = "Windows Media Audio 9.2",
    Custom_Audio_Mode = WMVStreamMode.CBR,
    Custom_Audio_PeakBitrate = 128000, // 128 kbps constant
    Custom_Audio_Format = "48kHz 16bit Stereo",

    // Network streaming configuration
    Network_Streaming_WMV_Maximum_Clients = 50,

    Custom_Profile_Name = "CBR Streaming",
    Custom_Profile_Description = "Constant bitrate for reliable network streaming"
};

var captureCore = new VideoCaptureCore();
captureCore.Output_Format = cbrStreamingConfig;
captureCore.Output_Filename = "output_cbr_stream.wmv";
```

#### Variable Bitrate with Peak Control

VBR with peak bitrate constraint provides quality optimization while limiting maximum bandwidth:

```
var vbrPeakConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,

    // Video settings with peak bitrate control
    Custom_Video_StreamPresent = true,
    Custom_Video_Codec = "Windows Media Video 9 Advanced Profile",
    Custom_Video_Mode = WMVStreamMode.VBRPeakBitrate,
    Custom_Video_Bitrate = 3000000, // 3 Mbps average
    Custom_Video_Peak_BitRate = 5000000, // 5 Mbps peak
    Custom_Video_Peak_BufferSizeSeconds = 3,
    Custom_Video_Width = 1920,
    Custom_Video_Height = 1080,
    Custom_Video_FrameRate = 30.0,
    Custom_Video_KeyFrameInterval = 4,
    Custom_Video_Smoothness = 75,

    // Audio settings with peak control
    Custom_Audio_StreamPresent = true,
    Custom_Audio_Codec = "Windows Media Audio 9.2",
    Custom_Audio_Mode = WMVStreamMode.VBRPeakBitrate,
    Custom_Audio_PeakBitrate = 256000,
    Custom_Audio_PeakBufferSize = 2,
    Custom_Audio_Format = "48kHz 16bit Stereo",

    Custom_Profile_Name = "VBR Peak Control",
    Custom_Profile_Description = "Variable bitrate with peak constraints for quality and bandwidth balance"
};

var editCore = new VideoEditCore();
editCore.Output_Format = vbrPeakConfig;
editCore.Output_Filename = "output_vbr_peak.wmv";
```

#### Screen Recording Optimized Configuration

Optimized for screen capture with efficient encoding of static content:

```
var screenRecordingConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,

    // Video settings optimized for screen content
    Custom_Video_StreamPresent = true,
    Custom_Video_Codec = "Windows Media Video 9 Screen",
    Custom_Video_Mode = WMVStreamMode.VBRQuality,
    Custom_Video_Quality = 90,
    Custom_Video_SizeSameAsInput = true, // Use screen resolution
    Custom_Video_FrameRate = 15.0, // Lower frame rate for screen recording
    Custom_Video_KeyFrameInterval = 10,
    Custom_Video_Smoothness = 50,
    Custom_Video_Buffer_UseDefault = true,

    // Audio settings for voice narration
    Custom_Audio_StreamPresent = true,
    Custom_Audio_Codec = "Windows Media Audio 9.2",
    Custom_Audio_Mode = WMVStreamMode.VBRQuality,
    Custom_Audio_Quality = 85,
    Custom_Audio_Format = "44kHz 16bit Mono", // Mono for voice
    Custom_Audio_LanguageID = "en-US",

    Custom_Profile_Name = "Screen Recording",
    Custom_Profile_Description = "Optimized for screen capture with efficient compression"
};

var captureCore = new VideoCaptureCore();
captureCore.Output_Format = screenRecordingConfig;
captureCore.Output_Filename = "screen_recording.wmv";
```

#### Archival Quality Configuration

Maximum quality for archival purposes:

```
var archivalConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,

    // Video settings for maximum quality
    Custom_Video_StreamPresent = true,
    Custom_Video_Codec = "Windows Media Video 9 Advanced Profile",
    Custom_Video_Mode = WMVStreamMode.VBRQuality,
    Custom_Video_Quality = 100,
    Custom_Video_Width = 1920,
    Custom_Video_Height = 1080,
    Custom_Video_FrameRate = 30.0,
    Custom_Video_KeyFrameInterval = 1, // Every frame is a keyframe
    Custom_Video_Smoothness = 100,
    Custom_Video_Buffer_Size = 8000,
    Custom_Video_Buffer_UseDefault = false,

    // Audio settings for maximum quality
    Custom_Audio_StreamPresent = true,
    Custom_Audio_Codec = "Windows Media Audio 9.2 Lossless",
    Custom_Audio_Mode = WMVStreamMode.VBRQuality,
    Custom_Audio_Quality = 100,
    Custom_Audio_Format = "96kHz 24bit Stereo",
    Custom_Audio_LanguageID = "en-US",

    Custom_Profile_Name = "Archival Quality",
    Custom_Profile_Description = "Maximum quality for long-term storage",
    Custom_Profile_Language = "en-US"
};

var editCore = new VideoEditCore();
editCore.Output_Format = archivalConfig;
editCore.Output_Filename = "archival_quality.wmv";
```

### Internal Profile Usage

Internal profiles provide pre-configured settings optimized for common scenarios. Here are examples of using different internal profiles:

#### Available Codecs and Formats

Before configuring custom settings, it's useful to understand the available codecs and formats:

**Video Codecs:** - "Windows Media Video 9" - Standard WMV9 codec - "Windows Media Video 9 Advanced Profile" - Advanced features support - "Windows Media Video 9 Screen" - Optimized for screen content - "Windows Media Video 8" - Legacy WMV8 codec

**Audio Codecs:** - "Windows Media Audio 9.2" - Standard WMA codec - "Windows Media Audio 9.2 Professional" - High-quality audio - "Windows Media Audio 9.2 Lossless" - Lossless compression - "Windows Media Audio Voice 9" - Optimized for speech

**Audio Formats:** Common format strings for `Custom_Audio_Format` property: - "48kHz 16bit Stereo" - CD quality stereo - "44kHz 16bit Stereo" - Standard quality stereo - "44kHz 16bit Mono" - Standard quality mono - "96kHz 24bit Stereo" - High-resolution audio - "22kHz 16bit Mono" - Voice recording quality

Standard broadcast quality profile:

```
var broadcastProfile = new WMVOutput
{
    Mode = WMVMode.InternalProfile,
    Internal_Profile_Name = "Windows Media Video 9 Advanced Profile",
    Custom_Video_TVSystem = WMVTVSystem.NTSC  // Optional TV system override
};

var captureCore = new VideoCaptureCore();
captureCore.Output_Format = broadcastProfile;
captureCore.Output_Filename = "broadcast_output.wmv";
```

Web streaming profile:

```
var webStreamingProfile = new WMVOutput
{
    Mode = WMVMode.InternalProfile,
    Internal_Profile_Name = "Windows Media Video 9 for Broadband (2 Mbps)",
    Network_Streaming_WMV_Maximum_Clients = 100  // Optional streaming override
};

var captureCore = new VideoCaptureCore();
captureCore.Output_Format = webStreamingProfile;
captureCore.Output_Filename = "web_stream.wmv";
```

Low latency profile for live streaming:

```
var liveStreamingProfile = new WMVOutput
{
    Mode = WMVMode.InternalProfile,
    Internal_Profile_Name = "Windows Media Video 9 Screen (Low Rate)",
    Network_Streaming_WMV_Maximum_Clients = 50
};

var captureCore = new VideoCaptureCore();
captureCore.Output_Format = liveStreamingProfile;
captureCore.Output_Filename = "live_stream.wmv";
```

### External Profile Configuration

External profiles allow you to load encoding settings from files or text. This is useful for sharing configurations across different projects or storing multiple configurations:

Loading profile from a file:

```
var fileBasedProfile = new WMVOutput
{
    Mode = WMVMode.ExternalProfile,
    External_Profile_FileName = @"C:\Profiles\HighQualityStreaming.prx"
};
```

Loading profile from text configuration:

```
var textBasedProfile = new WMVOutput
{
    Mode = WMVMode.ExternalProfileFromText,
    External_Profile_Text = @"
        <profile version=""589824""
                 storageformat=""1""
                 name=""Custom Streaming Profile""
                 description=""High quality streaming profile"">
            <streamconfig majortype=""{73647561-0000-0010-8000-00AA00389B71}""
                         streamnumber=""1""
                         streamname=""Audio Stream""
                         inputname=""Audio409""
                         bitrate=""128000""
                         bufferwindow=""5000""
                         reliabletransport=""0""
                         decodercomplexity=""""
                         rfc1766langid=""en-us""/>
            <!-- Additional profile configuration -->
        </profile>"
};
```

Saving and loading profiles programmatically:

```
async Task SaveAndLoadProfile(WMVOutput profile, string filename)
{
    // Save profile configuration to JSON
    string jsonConfig = profile.Save();
    await File.WriteAllTextAsync(filename, jsonConfig);

    // Load profile configuration from JSON
    string loadedJson = await File.ReadAllTextAsync(filename);
    WMVOutput loadedProfile = WMVOutput.Load(loadedJson);
}
```

Example usage of profile saving/loading:

```
var profile = new WMVOutput
{
    Mode = WMVMode.CustomSettings,
    // ... configure settings ...
};

await SaveAndLoadProfile(profile, "encoding_profile.json");
```

### Working with Legacy Windows Media 8 Profiles

For compatibility with older systems, you can use Windows Media 8 system profiles:

Using Windows Media 8 profile:

```
var wmv8Profile = new WMVOutput
{
    Mode = WMVMode.V8SystemProfile,
    V8ProfileName = "Windows Media Video 8 for Dial-up Access (28.8 Kbps)",
};
```

Customizing streaming settings for Windows Media 8 profiles:

```
var wmv8StreamingProfile = new WMVOutput
{
    Mode = WMVMode.V8SystemProfile,
    V8ProfileName = "Windows Media Video 8 for Local Area Network (384 Kbps)",
    Network_Streaming_WMV_Maximum_Clients = 25,
    Custom_Video_TVSystem = WMVTVSystem.PAL  // Optional TV system override
};
```

### Apply settings to your core object

```
var core = new VideoCaptureCore(); // or VideoEditCore
core.Output_Format = wmvOutput;
core.Output_Filename = "output.wmv";
```

### Complete Working Example

Here's a complete example showing video capture with custom WMV settings, including proper initialization and error handling:

```
using System;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.VideoCapture;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Output;
using VisioForge.Core.Types.VideoCapture;

namespace WMVCaptureExample
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Initialize VisioForge SDK
            VisioForgeX.InitSDK();

            // Create VideoCaptureCore instance
            var captureCore = new VideoCaptureCore();

            try
            {
                // Configure video source (first available camera)
                var videoDevices = captureCore.Video_CaptureDevices();
                if (videoDevices.Length > 0)
                {
                    captureCore.Video_CaptureDevice = new VideoCaptureSource(videoDevices[0].Name);
                }

                // Configure audio source (first available microphone)
                var audioDevices = captureCore.Audio_CaptureDevices();
                if (audioDevices.Length > 0)
                {
                    captureCore.Audio_CaptureDevice = new AudioCaptureSource(audioDevices[0].Name);
                }

                // Configure WMV output with custom settings
                var wmvOutput = new WMVOutput
                {
                    Mode = WMVMode.CustomSettings,

                    // Video settings
                    Custom_Video_StreamPresent = true,
                    Custom_Video_Codec = "Windows Media Video 9",
                    Custom_Video_Mode = WMVStreamMode.VBRQuality,
                    Custom_Video_Quality = 85,
                    Custom_Video_Width = 1280,
                    Custom_Video_Height = 720,
                    Custom_Video_FrameRate = 30.0,
                    Custom_Video_KeyFrameInterval = 5,

                    // Audio settings
                    Custom_Audio_StreamPresent = true,
                    Custom_Audio_Codec = "Windows Media Audio 9.2",
                    Custom_Audio_Mode = WMVStreamMode.VBRQuality,
                    Custom_Audio_Quality = 90,
                    Custom_Audio_Format = "48kHz 16bit Stereo",

                    Custom_Profile_Name = "Standard Capture",
                    Custom_Profile_Description = "Standard quality capture profile"
                };

                // Apply output settings
                captureCore.Output_Format = wmvOutput;
                captureCore.Output_Filename = "capture_output.wmv";
                captureCore.Mode = VideoCaptureMode.VideoCapture;

                // Start capture
                Console.WriteLine("Starting video capture...");
                await captureCore.StartAsync();

                Console.WriteLine("Recording... Press any key to stop.");
                Console.ReadKey();

                // Stop capture
                Console.WriteLine("Stopping video capture...");
                await captureCore.StopAsync();

                Console.WriteLine($"Video saved to: capture_output.wmv");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
                Console.WriteLine($"Stack trace: {ex.StackTrace}");
            }
            finally
            {
                // Clean up
                captureCore?.Dispose();
                VisioForgeX.DestroySDK();
            }

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}
```

### Complete Video Editing Example

Here's a complete example for video editing with custom WMV settings:

```
using System;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.VideoEdit;
using VisioForge.Core.Types.Output;
using VisioForge.Core.Types.VideoEdit;

namespace WMVEditExample
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Initialize VisioForge SDK
            VisioForgeX.InitSDK();

            var editCore = new VideoEditCore();

            try
            {
                // Add input video files
                editCore.Input_AddVideoFile("input_video1.mp4", false);
                editCore.Input_AddVideoFile("input_video2.mp4", false);

                // Configure WMV output
                var wmvOutput = new WMVOutput
                {
                    Mode = WMVMode.CustomSettings,

                    // High-quality video settings
                    Custom_Video_StreamPresent = true,
                    Custom_Video_Codec = "Windows Media Video 9 Advanced Profile",
                    Custom_Video_Mode = WMVStreamMode.VBRPeakBitrate,
                    Custom_Video_Bitrate = 4000000, // 4 Mbps average
                    Custom_Video_Peak_BitRate = 6000000, // 6 Mbps peak
                    Custom_Video_Peak_BufferSizeSeconds = 3,
                    Custom_Video_Width = 1920,
                    Custom_Video_Height = 1080,
                    Custom_Video_FrameRate = 30.0,
                    Custom_Video_KeyFrameInterval = 4,
                    Custom_Video_Smoothness = 80,

                    // High-quality audio settings
                    Custom_Audio_StreamPresent = true,
                    Custom_Audio_Codec = "Windows Media Audio 9.2 Professional",
                    Custom_Audio_Mode = WMVStreamMode.VBRQuality,
                    Custom_Audio_Quality = 95,
                    Custom_Audio_Format = "48kHz 16bit Stereo",

                    Custom_Profile_Name = "High Quality Edit",
                    Custom_Profile_Description = "High quality output for edited videos"
                };

                // Apply output settings
                editCore.Output_Format = wmvOutput;
                editCore.Output_Filename = "edited_output.wmv";

                // Configure edit mode
                editCore.Mode = VideoEditMode.Convert;

                // Start editing
                Console.WriteLine("Starting video editing...");
                await editCore.StartAsync();

                // Monitor progress
                while (editCore.State == VideoEditCoreState.Working)
                {
                    var progress = editCore.Progress();
                    Console.WriteLine($"Progress: {progress}%");
                    await Task.Delay(500);
                }

                Console.WriteLine($"Video editing complete! Output saved to: edited_output.wmv");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
                Console.WriteLine($"Stack trace: {ex.StackTrace}");
            }
            finally
            {
                // Clean up
                editCore?.Dispose();
                VisioForgeX.DestroySDK();
            }

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}
```

## Cross-platform WMV output

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

The `WMVEncoderSettings` class provides a cross-platform solution for WMV encoding using GStreamer technology.

### Features

- Platform-independent implementation
- Integration with GStreamer backend
- Simple configuration interface
- Availability checking

### Sample Code

#### VideoCaptureCoreX Configuration

Add the WMV output to the Video Capture SDK core instance:

```
// Basic configuration with default settings
var wmvOutput = new WMVOutput("output.wmv");
var core = new VideoCaptureCoreX();
core.Outputs_Add(wmvOutput, true);

// With custom encoder settings
var wmvOutput2 = new WMVOutput("output_custom.wmv");
wmvOutput2.Video = new WMVEncoderSettings();
wmvOutput2.Audio = new WMAEncoderSettings
{
    Bitrate = 192,  // Bitrate in Kbps
    SampleRate = 48000,  // Sample rate in Hz
    Channels = 2  // Stereo
};

var core2 = new VideoCaptureCoreX();
core2.Outputs_Add(wmvOutput2, true);
```

#### VideoEditCoreX Configuration

Set the output format for the Video Edit SDK core instance:

```
// Basic configuration
var wmvOutput = new WMVOutput("output.wmv");
var core = new VideoEditCoreX();
core.Output_Format = wmvOutput;

// With custom audio settings
var wmvOutput2 = new WMVOutput("output_high_quality.wmv");
wmvOutput2.Audio = new WMAEncoderSettings
{
    Bitrate = 256,  // High-quality audio
    SampleRate = 48000,
    Channels = 2
};

var core2 = new VideoEditCoreX();
core2.Output_Format = wmvOutput2;
```

#### Media Blocks Pipeline Configuration

Create a Media Blocks WMV output instance:

```
// Configure audio encoder
var wma = new WMAEncoderSettings
{
    Bitrate = 128,  // Bitrate in Kbps
    SampleRate = 48000,  // 48 kHz
    Channels = 2  // Stereo
};

// Configure video encoder
var wmv = new WMVEncoderSettings();

// Configure ASF sink (container)
var sinkSettings = new ASFSinkSettings("output.wmv");

// Create output block
var wmvOutput = new WMVOutputBlock(sinkSettings, wmv, wma);

// Add to pipeline
var pipeline = new MediaBlocksPipeline();
// ... configure sources and connect to wmvOutput
```

#### Checking Encoder Availability

Always check if encoders are available before use:

```
// Check WMV encoder availability
if (WMVEncoderSettings.IsAvailable())
{
    Console.WriteLine("WMV encoder is available");
    var wmvOutput = new WMVOutput("output.wmv");
    // ... use encoder
}
else
{
    Console.WriteLine("WMV encoder is not available on this system");
    // Fall back to alternative encoder
}

// Check WMA encoder availability
if (WMAEncoderSettings.IsAvailable())
{
    Console.WriteLine("WMA encoder is available");
}
```

#### Advanced Cross-Platform Configuration

```
// Create a high-quality cross-platform WMV output
var wmvOutput = new WMVOutput("output_hq.wmv");

// Configure high-quality audio
wmvOutput.Audio = new WMAEncoderSettings
{
    Bitrate = 320,  // Maximum quality
    SampleRate = 48000,
    Channels = 2
};

// Video encoder settings (uses default WMV1 encoder)
wmvOutput.Video = new WMVEncoderSettings();

// Check if custom video processor is needed
// wmvOutput.CustomVideoProcessor = myCustomProcessor;

// Apply to core
var core = new VideoCaptureCoreX();
core.Outputs_Add(wmvOutput, true);

// Start capture
await core.StartAsync();
```

#### Available Audio Settings

The `WMAEncoderSettings` class provides the following configuration options:

```
var audioSettings = new WMAEncoderSettings
{
    // Bitrate in Kbps - supported values: 128, 192, 256, 320
    Bitrate = 192,

    // Sample rate in Hz - supported values: 44100, 48000
    SampleRate = 48000,

    // Number of channels - supported values: 1 (mono), 2 (stereo)
    Channels = 2
};

// Get supported bitrates
int[] supportedBitrates = audioSettings.GetSupportedBitrates();
// Returns: [128, 192, 256, 320]

// Get supported sample rates
int[] supportedSampleRates = audioSettings.GetSupportedSampleRates();
// Returns: [44100, 48000]

// Get supported channel counts
int[] supportedChannels = audioSettings.GetSupportedChannelCounts();
// Returns: [1, 2]
```

### Choosing Between Encoders

Consider the following factors when choosing between Windows-specific `WMVOutput` and cross-platform `WMVEncoderSettings`:

#### Windows-Specific WMVOutput

- Pros:
- Full access to Windows Media format features
- Advanced rate control options
- Network streaming support
- Profile-based configuration
- Cons:
- Windows-only compatibility
- Requires Windows Media components

#### Cross-Platform WMV

- Pros:
- Platform independence
- Simpler implementation
- Cons:
- More limited feature set
- Basic configuration options only

## Best Practices

### MSDN References

For detailed information about Windows Media technologies, refer to these official Microsoft resources:

- [Windows Media Format SDK](https://learn.microsoft.com/es-es/windows/win32/wmformat/windows-media-format-11-sdk) - Complete Windows Media Format documentation
- [Working with Profiles](https://learn.microsoft.com/en-us/windows/win32/wmformat/working-with-profiles) - Profile management and configuration
- [Windows Media Codecs](https://learn.microsoft.com/en-us/windows/win32/medfound/windows-media-codecs) - Audio and video codec information
- [ASF File Structure](https://learn.microsoft.com/en-us/windows/win32/medfound/asf-file-structure) - Advanced Systems Format container details
- [Configuring Video Streams](https://learn.microsoft.com/en-us/windows/win32/wmformat/configuring-video-streams) - Video encoding parameters
- [Configuring Audio Streams](https://learn.microsoft.com/en-us/windows/win32/wmformat/configuring-audio-streams) - Audio encoding parameters

### Choosing Rate Control Modes

Select the appropriate rate control mode based on your use case:

1. **CBR (Constant Bitrate)**
2. Use for: Network streaming, broadcasting
3. Advantages: Predictable bandwidth, consistent quality
4. Disadvantages: Less efficient compression, may not adapt to content complexity
5. Example: Live streaming to ensure smooth playback
6. **VBRQuality (Variable Bitrate - Quality)**
7. Use for: File-based output, archival, high-quality video
8. Advantages: Best quality-to-size ratio, adapts to content complexity
9. Disadvantages: Unpredictable file size and bitrate
10. Example: Recording tutorials or presentations for later playback
11. **VBRBitrate (Variable Bitrate - Target Bitrate)**
12. Use for: When you need quality optimization with size constraints
13. Advantages: Balances quality and target file size
14. Disadvantages: Quality may vary between scenes
15. Example: Creating videos for upload with size limits
16. **VBRPeakBitrate (Variable Bitrate - Peak Constrained)**
17. Use for: Streaming with bandwidth constraints
18. Advantages: Quality optimization with bandwidth ceiling
19. Disadvantages: More complex configuration
20. Example: Adaptive streaming scenarios

### Performance Optimization

1. **Buffer Configuration**
2. Set `Custom_Video_Buffer_UseDefault = false` for fine-tuned control
3. Increase `Custom_Video_Buffer_Size` for smoother streaming (default: 3000ms)
4. Balance buffer size with latency requirements
5. **KeyFrame Interval**
6. Lower values (1-3): Better seek performance, larger file size
7. Higher values (5-10): Smaller file size, less seek precision
8. Recommended: 3-5 for streaming, 10+ for screen recording
9. **Smoothness Settings**
10. 0-50: Prioritize compression efficiency
11. 50-75: Balanced quality and efficiency
12. 75-100: Prioritize visual quality

### Resolution and Frame Rate Guidelines

```
// 4K/UHD Configuration
var uhd4KConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,
    Custom_Video_StreamPresent = true,
    Custom_Video_Codec = "Windows Media Video 9 Advanced Profile",
    Custom_Video_Mode = WMVStreamMode.VBRQuality,
    Custom_Video_Quality = 95,
    Custom_Video_Width = 3840,
    Custom_Video_Height = 2160,
    Custom_Video_FrameRate = 30.0,
    // ... other settings
};

// Full HD Configuration
var fullHDConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,
    Custom_Video_StreamPresent = true,
    Custom_Video_Width = 1920,
    Custom_Video_Height = 1080,
    Custom_Video_FrameRate = 30.0,
    // ... other settings
};

// HD Ready Configuration
var hdReadyConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,
    Custom_Video_StreamPresent = true,
    Custom_Video_Width = 1280,
    Custom_Video_Height = 720,
    Custom_Video_FrameRate = 30.0,
    // ... other settings
};

// SD Configuration
var sdConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,
    Custom_Video_StreamPresent = true,
    Custom_Video_Width = 720,
    Custom_Video_Height = 480,
    Custom_Video_FrameRate = 29.97,
    Custom_Video_TVSystem = WMVTVSystem.NTSC,
    // ... other settings
};
```

### Error Handling and Validation

Always validate your configuration before starting capture or editing:

```
var wmvOutput = new WMVOutput
{
    Mode = WMVMode.CustomSettings,
    // ... configuration
};

try
{
    var captureCore = new VideoCaptureCore();
    captureCore.Output_Format = wmvOutput;
    captureCore.Output_Filename = "output.wmv";

    // Validate configuration
    if (captureCore.Output_Filename == null || captureCore.Output_Filename.Length == 0)
    {
        throw new InvalidOperationException("Output filename is required");
    }

    await captureCore.StartAsync();
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
    // Handle error appropriately
}
```

### Network Streaming Configuration

For network streaming scenarios, configure both encoder and streaming settings:

```
var streamingConfig = new WMVOutput
{
    Mode = WMVMode.CustomSettings,

    // Video settings optimized for streaming
    Custom_Video_StreamPresent = true,
    Custom_Video_Codec = "Windows Media Video 9",
    Custom_Video_Mode = WMVStreamMode.CBR,
    Custom_Video_Bitrate = 1500000, // 1.5 Mbps
    Custom_Video_Width = 1280,
    Custom_Video_Height = 720,
    Custom_Video_FrameRate = 30.0,
    Custom_Video_KeyFrameInterval = 3,
    Custom_Video_Buffer_Size = 2000, // Lower buffer for reduced latency
    Custom_Video_Buffer_UseDefault = false,

    // Audio settings
    Custom_Audio_StreamPresent = true,
    Custom_Audio_Codec = "Windows Media Audio 9.2",
    Custom_Audio_Mode = WMVStreamMode.CBR,
    Custom_Audio_PeakBitrate = 128000,
    Custom_Audio_Format = "48kHz 16bit Stereo",

    // Network streaming settings
    Network_Streaming_WMV_Maximum_Clients = 100,

    Custom_Profile_Name = "Network Streaming",
    Custom_Profile_Description = "Optimized for network streaming with low latency"
};

var captureCore = new VideoCaptureCore();
captureCore.Output_Format = streamingConfig;
captureCore.Output_Filename = "http://localhost:8080/stream"; // Or file path
```

### Testing and Validation

1. **Always test your configuration** with sample content before production use
2. **Monitor encoding performance** to ensure real-time encoding capability
3. **Check file compatibility** with your target playback devices
4. **Validate audio sync** especially with custom frame rates
5. **Test network streaming** under various bandwidth conditions

### Profile Management

Save and reuse configurations for consistency:

```
// Save configuration to JSON
var wmvOutput = new WMVOutput
{
    Mode = WMVMode.CustomSettings,
    // ... configuration
};

string jsonConfig = wmvOutput.Save();
File.WriteAllText("profile_high_quality.json", jsonConfig);

// Load configuration from JSON
string loadedJson = File.ReadAllText("profile_high_quality.json");
var loadedProfile = WMVOutput.Load(loadedJson);

var captureCore = new VideoCaptureCore();
captureCore.Output_Format = loadedProfile;
```

### Common Issues and Solutions

1. **Large File Sizes**
2. Use VBRBitrate mode instead of VBRQuality
3. Reduce video quality or resolution
4. Increase KeyFrameInterval
5. Consider using screen codec for screen recordings
6. **Poor Quality**
7. Increase video quality setting
8. Use higher bitrate
9. Switch to VBRQuality mode
10. Ensure sufficient buffer size
11. **Streaming Issues**
12. Use CBR mode for consistent bandwidth
13. Reduce buffer size for lower latency
14. Test with appropriate client count
15. Monitor network bandwidth
16. **Codec Not Available**
17. Ensure Windows Media components are installed
18. Check codec enumeration programmatically
19. Fall back to default internal profiles
20. Consider cross-platform alternatives (WMVEncoderSettings)

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Enable Debug Logs for .NET SDK Troubleshooting Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/general/sendlogs/
**Description:** Enable and capture debug logs for .NET SDK troubleshooting with step-by-step instructions for demo and production environments.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET

# Troubleshooting with Logs for .NET SDK Products

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Why Logs Matter in SDK Troubleshooting

When developing applications that utilize media SDKs, you may encounter technical issues that require detailed investigation. Debug logs provide critical information that helps identify the root cause of problems quickly and efficiently. These logs capture everything from initialization sequences to detailed operation steps, error conditions, and system information.

Properly collected logs offer several key benefits:

- **Faster Issue Resolution**: Technical support can quickly identify the source of problems
- **Complete Context**: Logs provide a full picture of what happened before, during, and after an issue
- **System Information**: Details about your environment help reproduce and solve problems
- **Development Insights**: Understanding logs can help you optimize your implementation

## Log Collection in Demo Applications

Our demo applications include built-in debugging capabilities that make it easy to collect logs for troubleshooting. Follow these steps to enable and share logs:

### Step-by-Step Guide for Demo Application Logging

1. **Launch the Demo Application**
2. Open the relevant demo application for your SDK
3. Locate the main interface where settings can be configured
4. **Enable Debug Mode**
5. Find and check the "Debug" checkbox in the application interface
6. This activates detailed logging of all SDK operations
7. **Reproduce the Issue**
8. Configure any other required settings for your specific scenario
9. Press the Start or Play button (depending on which SDK you're using)
10. Allow the application to run until the issue occurs
11. After sufficient time to capture the problem, press the Stop button
12. **Collect Log Files**
13. Navigate to "My Documents\VisioForge" on your system
14. This folder contains all generated log files
15. **Important**: Exclude any audio/video recordings from your collection to reduce file size
16. **Share Logs Securely**
17. Compress the log files into a ZIP archive
18. Upload to a secure file sharing service like Dropbox, Google Drive, or OneDrive
19. Share the access link with technical support

## Implementing Logging in Your Custom Applications

When you're developing your own applications with our SDKs, you'll need to explicitly enable and configure logging. This section explains how to implement logging with different SDK components.

### Enabling Debug Logs in Your Code

Regardless of which SDK you're using, the basic approach to enabling logs follows a similar pattern:

```
// Example for MediaPlayer SDK
mediaPlayer.Debug_Mode = true;
mediaPlayer.Debug_Dir = "C:\\Logs\\MyApplication";

// Example for Video Capture SDK
videoCapture.Debug_Mode = true;
videoCapture.Debug_Dir = "C:\\Logs\\MyApplication";

// Example for Video Edit SDK
videoEdit.Debug_Mode = true;
videoEdit.Debug_Dir = "C:\\Logs\\MyApplication";
```

### Detailed Implementation Guide

1. **Set Debug Mode Property**
2. For any SDK component you're using, set the `Debug_Mode` property to `true`
3. This must be done before calling initialization or playback methods
4. Example: `MediaPlayer1.Debug_Mode = true;`
5. **Specify Log Directory**
6. Set the `Debug_Dir` property to a valid directory path
7. Ensure the specified directory exists and your application has write permissions
8. Example: `MediaPlayer1.Debug_Dir = "C:\\LogFiles\\MyApp";`
9. **Configure Additional Parameters**
10. Set up any other required parameters for your specific use case
11. These could include video sources, codecs, output settings, etc.
12. **Initialize and Run the Component**
13. Call the appropriate method to start the component (e.g., `Start()` or `Play()`)
14. Let the application run until you've reproduced the issue you're troubleshooting
15. **Collect and Share Logs**
16. Locate the log files in both your specified directory and "My Documents\VisioForge"
17. Compress all log files into a ZIP archive
18. Share via secure file sharing service

## Advanced Logging Techniques

For more complex applications or difficult-to-reproduce issues, consider these advanced logging approaches:

### Conditional Debug Activation

You might want to enable debug logging only in certain scenarios or based on user actions:

```
// Enable debug mode only when troubleshooting
if (troubleshootingMode)
{
    mediaPlayer.Debug_Mode = true;
    mediaPlayer.Debug_Dir = Path.Combine(
        Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
        "AppLogs"
    );
}
```

### Environment-Specific Logging

Different deployment environments may require different logging approaches:

```
#if DEBUG
    // Development environment logging
    videoCapture.Debug_Mode = true;
    videoCapture.Debug_Dir = Path.Combine(
        Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
        "DevLogs"
    );
#else
    // Production environment logging (if permitted by your privacy policy)
    string appDataPath = Path.Combine(
        Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
        "YourCompany",
        "YourApp",
        "Logs"
    );
    Directory.CreateDirectory(appDataPath);
    videoCapture.Debug_Mode = true;
    videoCapture.Debug_Dir = appDataPath;
#endif
```

## Best Practices for Effective Logging

To ensure you get the most valuable information from your logs, follow these best practices:

### 1. Clear Initial State

Before starting a logging session, consider resetting your application state:

- Close and restart the application
- Clear any cached data if relevant
- Ensure you're capturing from a known starting point

### 2. Capture Complete Sessions

When possible, capture the entire session from start to finish:

- Enable logging before initializing SDK components
- Let logging run through the entire operation
- Continue logging until after the issue occurs

### 3. Document Reproduction Steps

Along with your logs, provide clear steps to reproduce the issue:

- Note specific settings used
- Document the exact sequence of operations
- Include timing information if relevant (e.g., "crash occurs after 30 seconds of playback")

### 4. Manage Log Size

Debug logs can grow large, especially for long sessions:

- For extended tests, consider breaking logging into multiple sessions
- Focus on capturing just the problematic scenario
- Always exclude large media files when sharing logs

### 5. Secure Sensitive Information

Before sharing logs, be aware of potential sensitive data:

- Review logs for any personal or sensitive information
- Consider using sanitized test content when possible
- Use secure methods to transfer log files

## Interpreting Common Log Messages

While advanced log analysis is best left to technical support, understanding some common log patterns can help you identify issues:

- **Initialization Errors**: Look for messages containing "Init" or "Initialize"
- **Format Issues**: Watch for "format" or "codec" related messages
- **Resource Problems**: Messages about "memory", "handles", or "resources"
- **Performance Warnings**: Notes about "frame drops", "processing time", or "buffers"

## Conclusion

Proper logging is essential for efficient troubleshooting of SDK-based applications. By following the guidelines in this document, you can provide the detailed information needed to quickly resolve any issues you encounter. Remember that detailed logs significantly reduce resolution time and help improve the quality of both your application and our SDKs.

For additional code samples and implementation guides, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Build a Unity App with Video Playback for Android arm64
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/android/
**Description:** Build settings, IL2CPP, AndroidManifest permissions and troubleshooting for the VisioForge Media Blocks SDK .NET in Unity 6 on Android.
**Tags:** Media Blocks SDK, .NET, Unity, Android, IL2CPP, RTSP, C#
**API:** VisioForgeEnvironment, MediaBlocksPipeline, RTSPSourceBlock

# Build for Android

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

The Android flavor ships as a monolithic `libgstreamer_android.so` with every GStreamer plugin statically linked in, plus the package's managed assemblies built against `netstandard2.1`. This page covers the Build Profile settings, the manifest permissions, and the Android-specific gotchas. For the bring-up sequence shared across platforms, see [Bootstrap and lifecycle](../bootstrap/).

The Android flavor is bundled into the `.unitypackage` when the build pipeline is run with `-IncludeAndroid`. The result is one cumulative package that holds the Windows, Android, and any opt-in Apple runtimes together — Unity then picks the correct one at build time from the per-file `PluginImporter` metadata.

## Player Settings

| Setting | Value | Where |
| --- | --- | --- |
| Target Platform | **Android** | File → Build Profiles → Android |
| Texture Compression | **ASTC** *(recommended; default in Unity 6)* | File → Build Profiles → Android |
| Api Compatibility Level | **.NET Standard 2.1** | Project Settings → Player → Other Settings → Configuration |
| Scripting Backend | **IL2CPP** *(mandatory — Mono is not supported on Android by Unity itself)* | Project Settings → Player → Other Settings → Configuration |
| Target Architectures | **ARM64** *(ARMv7 not shipped — uncheck it)* | Project Settings → Player → Other Settings → Configuration |
| Internet Access | **Require** *(needed for RTSP / HTTPS sources)* | Project Settings → Player → Other Settings → Configuration |
| Write Permission | **External (SDCard)** if you write or record media to external storage | Project Settings → Player → Other Settings → Configuration |
| Minimum API Level | **24 (Android 7.0)** or later | Project Settings → Player → Other Settings → Identification |

Mono cannot load `libgstreamer_android.so` correctly through Unity's Android runtime — only IL2CPP is exercised in CI and supported in production.

## Required AndroidManifest entries

Unity generates `AndroidManifest.xml` for you. The settings above translate into the standard entries; if you need a custom manifest, make sure it contains:

```
<uses-permission android:name="android.permission.INTERNET" />

<!-- Only if your app uses RTSP discovery / streams audio-out via UDP on the local segment -->
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

<!-- Only if your app uses the microphone or camera as a source -->
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.CAMERA" />

<!-- Only if you read media from external storage -->
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
                 android:maxSdkVersion="32" />
<uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
<uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
```

`READ_MEDIA_VIDEO` / `READ_MEDIA_AUDIO` replace the legacy `READ_EXTERNAL_STORAGE` on Android 13+ (API 33+); declare both forms so older devices keep working.

## What the package adds for Android

The `deploy-unity-natives.ps1` step stages the Android runtime into your project as follows:

| Path | Contents |
| --- | --- |
| `Assets/Plugins/Android/libs/arm64-v8a/libgstreamer_android.so` | Monolithic GStreamer runtime — all plugins statically linked. |
| `Assets/Plugins/Android/libs/arm64-v8a/libVisioForge_Core.so` | The SDK's Android-flavor native shim. |
| `Assets/Plugins/Android/visioforge-gstreamer.aar` | The Java archive that exposes `org.freedesktop.gstreamer.GStreamer.init(Context)`. |
| `Assets/VisioForge/link.xml` | Type / member preservation rules for IL2CPP. |
| `Assets/Plugins/Android/` | Managed assemblies built against `netstandard2.1` with `UNITY_NS21_ANDROID` defined. |

The `link.xml` is mandatory. Without it, IL2CPP's managed-code stripping removes types the SDK references through reflection — `GLib.SignalArgs` subclasses, `SignalClosure.MarshalCallback` — and the first delegate firing throws `MissingMethodException`. The package ships a tested `link.xml`; do not remove it from `Assets/`.

## Build size

The Android flavor adds roughly **35 MB** to the APK / AAB:

- `libgstreamer_android.so` — ~30 MB (arm64-v8a, stripped)
- `libVisioForge_Core.so` — ~2 MB
- Managed assemblies — ~3 MB

If you ship ARMv7 too (not currently included by the package, but if you stage it manually), expect to double the native libraries.

## Standalone build

**File → Build Profiles → Android → Build** (or **Build And Run**) produces an APK / AAB.

Tested on:

- Unity 6 (`6000.x`) with the Android Build Support module installed
- Android 9 through Android 15 devices
- Pixel 6 / 7 / 8 / 9, Galaxy S22 / S23 / S24

## Troubleshooting

| Symptom | Cause | Fix |
| --- | --- | --- |
| `DllNotFoundException: libgstreamer_android` at scene start | Scripting Backend is Mono, not IL2CPP. | Switch to IL2CPP under Project Settings → Player → Other Settings. |
| `MissingMethodException` from `GLib.SignalArgs` or `SignalClosure.MarshalCallback` | `link.xml` is missing or was stripped. | Confirm `Assets/VisioForge/link.xml` exists. Re-import the package if it is not there. |
| `InvalidOperationException: Unity Android bootstrap requires com.unity3d.player.UnityPlayer.currentActivity to be available` | Wear OS / Android TV / Unity-as-a-library host where the field is null at `BeforeSceneLoad`. | Defer `VisioForgeEnvironment.Configure()` to the first Activity event you can observe and call it manually from there. |
| Java init fails with `failed to find getFilesDir` | Activity is not a `UnityPlayerActivity` and does not expose the standard Android Context API. | Confirm the host Activity inherits from a real Android `Activity`. |
| RTSPS / HTTPS streams fail with a TLS error | CA bundle extraction failed silently. | Look in the Logcat for `[VisioForge] CA cert extraction failed`. Re-import the package if the embedded resource is missing. |
| App crashes on the second `Awake` after returning from background | `VisioForgeX.DestroySDK()` was called in `OnDestroy`. | Don't call it — see [Bootstrap and lifecycle](../bootstrap/#the-editor-lifecycle). |

## Frequently Asked Questions

### Why is ARMv7 not shipped?

Modern Android devices (API 24 / Android 7.0 baseline) are predominantly arm64. Shipping the ~30 MB monolithic GStreamer for both ABIs would double the package size for a vanishingly small device share. If you have a hard ARMv7 requirement, contact support.

### Can I use the SDK in a non-Unity Android project?

Yes — the underlying SDK ships as a standalone `VisioForge.CrossPlatform.Core.Android` NuGet package for raw .NET Android apps. The Unity package wraps that runtime plus the Java bootstrap and `link.xml`; the wrapper is Unity-specific.

### Does the SDK work in the Android Editor (Project Player → Run In Editor) mode?

Run-in-Editor for Android targets is not exercised; build and deploy to a real device. The Editor itself runs the **Windows** flavor of the SDK on a Windows host — switching the Build Target to Android in Build Profiles does not change which native runtime the Editor loads.

### Which sources work over RTSP on Android?

The same `RTSPSourceBlock` used on Windows. Auto-reconnect, optional credentials, video-only and video+audio streams, and the standard RTSP transports (TCP, UDP, UDP multicast) are all supported. The Android flavor uses the GStreamer `rtspsrc` element internally — the same one as the Windows and macOS flavors.

## See also

- [Install the Media Blocks SDK in Unity](../../../install/unity/) — package setup
- [Bootstrap and lifecycle](../bootstrap/) — the Android Java bootstrap explained
- [View an RTSP camera in Unity](../rtsp-viewer/) — the `RTSPViewer` sample
- [Troubleshooting](../troubleshooting/) — cross-platform error reference
- [Platform matrix](../platform-matrix/) — feature support by Unity platform

---END OF PAGE---


## Unity SDK Bootstrap — Configure the Native Runtime
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/bootstrap/
**Description:** How VisioForgeEnvironment.Configure starts the native GStreamer runtime in Unity 6 on Windows, Android, macOS and iOS plus the Editor lifecycle.
**Tags:** Media Blocks SDK, Media Player SDK, Video Capture SDK, Video Edit SDK, .NET, Unity, Bootstrap, Windows, Android, macOS, iOS, C#
**API:** VisioForgeEnvironment, VisioForgeX

# Bootstrap and lifecycle

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

The Unity package ships a static helper, `VisioForgeEnvironment`, that brings up the bundled native runtime before the first scene loads. You do not call it from your scripts — Unity invokes it automatically through `RuntimeInitializeOnLoadMethod`. This page explains what it does on each platform and the lifecycle rules your scripts have to follow.

The same two-step bring-up applies to **every** engine in the package: the low-level `MediaBlocksPipeline` and the high-level `MediaPlayerCoreX`, `VideoCaptureCoreX`, and `VideoEditCoreX` engines all run on the one bundled GStreamer runtime that `Configure()` and `InitializeSdk()` start. Bootstrap is engine-agnostic — nothing on this page is specific to a single engine.

If you only need to ship the SDK, you can skip this page: drop `MediaBlocksPlayer` or `RTSPViewerPlayer` into a scene and press **Play**. Come back here when you build your own scripts, hit a runtime error, or want to understand why the Editor settings are mandatory.

## The two entry points

`VisioForgeEnvironment` has exactly two public methods your code interacts with:

| Method | When it runs | What it does |
| --- | --- | --- |
| `Configure()` | Automatically, **before the first scene loads** (`[RuntimeInitializeOnLoadMethod(BeforeSceneLoad)]`). | Prepares the native runtime for the current platform — DLL search path, environment variables, CA bundle, Java bootstrap. Idempotent. |
| `InitializeSdk()` | You call it once before building a pipeline. The sample players do this in `Start()`. | Calls `VisioForgeX.InitSDK()` and scans the bundled plugin registry. Idempotent. |

Both methods are static. Both flag themselves complete only after every step succeeds — so a recoverable failure (for example, the Android Java bootstrap firing before `currentActivity` is ready) leaves the flag unset and a later call retries instead of silently no-op-ing into a broken state.

## What `Configure()` does on each platform

`Configure()` dispatches on compile-time symbols (`UNITY_STANDALONE_WIN`, `UNITY_STANDALONE_OSX`, `UNITY_ANDROID`, `UNITY_IOS`) — Unity defines exactly one of these per build target. The body of each branch is the minimum the platform needs for GStreamer to find its plugins, locate its TLS roots, and resolve the rest of the bundled runtime via its native loader.

WindowsmacOSAndroidiOSOther

1. Validate the bundled natives directory exists (`StreamingAssets/VisioForge/x64`). Refuse to mutate any process state if not — a missing folder must not poison the process `PATH`.
2. Strip any system GStreamer entry from the **process** `PATH` (a homebrew / system install on `PATH` would load a second physical copy of `gstreamer-1.0-0.dll`, double-register GLib types and hang the pipeline).
3. Point the Win32 DLL loader at the bundled natives via `SetDllDirectoryW`.
4. Prepend the natives folder to the process `PATH` so each plugin's transitive core-lib dependencies resolve (`SetDllDirectory` alone is not enough for those).
5. Set `GST_PLUGIN_PATH` / `GST_PLUGIN_SYSTEM_PATH` to the same flat folder.
6. Set `SSL_CERT_FILE` and `CA_CERTIFICATES` to the bundled `ca-certificates.crt` so RTSPS and HTTPS verify peers.

The user / system `PATH` is never touched — only the live process copy.

1. Resolve the natives path by probing the Unity-known layouts: `Plugins/macOS` (Editor and some Standalone Player versions), then `Contents/PlugIns`, `Contents/PlugIns/macOS`, `Contents/Frameworks`, and `Contents/Resources/Data/Plugins/macOS` for a Standalone `.app`. The first folder that contains `libgstreamer-1.0.0.dylib` wins. The result is cached.
2. Prune any system / homebrew GStreamer from `DYLD_LIBRARY_PATH` (`/opt/homebrew/lib`, `/usr/local/lib`) — same double-init failure mode as the Windows `PATH` prune.
3. Set `GST_PLUGIN_PATH` / `GST_PLUGIN_SYSTEM_PATH` to the natives folder so GStreamer can enumerate the bundled plugins.
4. Set `GIO_MODULE_DIR` so GIO finds `libgioopenssl.so` (the TLS backend that RTSPS / HTTPS verify peers through).
5. Set `SSL_CERT_FILE` and `CA_CERTIFICATES` to the bundled CA bundle.

Each bundled `.dylib` has its `@rpath` / `@loader_path` baked in by the NuGet pack, so once dyld has loaded one through the first `[DllImport]`, the others resolve siblings automatically — no `SetDllDirectory` equivalent is needed.

1. Acquire `com.unity3d.player.UnityPlayer.currentActivity` through JNI. If the field is null — Wear OS / Android TV variants, Unity-as-a-library hosts that have not assigned it yet, very early `BeforeSceneLoad` on some Unity 6 startup paths — fail fast with a descriptive exception so the customer sees something better than an opaque `NullReferenceException` from deep inside JNI.
2. Resolve `getFilesDir()` and `getCacheDir()` from the Activity.
3. Capture the previous values of `TMP`, `TEMP`, `TMPDIR`, `XDG_RUNTIME_DIR`, `XDG_CACHE_HOME`, `HOME`, `GST_REGISTRY`, `SSL_CERT_FILE`, `CA_CERTIFICATES` so a later failure can roll them back.
4. Point GLib at the app-private writable dirs by setting the variables above (only the app-private dirs are writable on Android).
5. Extract the embedded `ca-certificates.crt` resource into `filesDir/ssl/certs/` and point `SSL_CERT_FILE` / `CA_CERTIFICATES` at it.
6. Call `org.freedesktop.gstreamer.GStreamer.init(activity)` — this loads `libgstreamer_android.so`, captures the JavaVM in `JNI_OnLoad`, runs `gst_init`, and registers every plugin statically linked into the monolith.
7. If any of those throws, restore the captured environment and rethrow.

1. Extract the embedded `ca-certificates.crt` resource into `Application.persistentDataPath/ssl/certs/`.
2. Set `SSL_CERT_FILE` / `CA_CERTIFICATES` to that path so GIO's OpenSSL backend can verify RTSPS / HTTPS peers.
3. Prime the `NativesPath` cache on the main thread (`s_cachedNativesPath = Application.dataPath.Replace('\\', '/')`). Without this prime, a background-thread reader — the GStreamer bus, an async log callback, a pad-added callback — would later hit the lazy getter and call `Application.dataPath` off the main thread, which throws `UnityException`. The compute formula matches the lazy getter byte-for-byte.

iOS does not need a plugin scan: every GStreamer plugin is statically registered inside `GStreamerX.framework` at `gst_plugin_register_static()` time, and dyld resolves `@rpath/GStreamerX.framework/GStreamerX` automatically when the first `[DllImport]` fires.

`Configure()` sets the success flag and logs a warning. No native runtime exists for the current platform, so any later `[DllImport]` would throw `DllNotFoundException`. Build for one of the four supported platforms instead.

## What `InitializeSdk()` does

After `Configure()` has prepared the runtime, `InitializeSdk()` finishes the bring-up:

1. Refuse to run if `Configure()` never succeeded — failing fast here surfaces an actionable error instead of a `DllNotFoundException` deep inside the SDK.
2. Refuse to run on an unsupported `Application.platform` value at runtime (Windows / Android / macOS / iOS are admitted; everything else short-circuits with a warning).
3. On Windows and macOS, before calling the native SDK, double-check that the resolved natives folder exists on disk. This catches the cross-flavor mismatch (Windows-only `.unitypackage` imported into a macOS host, or the opposite) with a clear message instead of an opaque `DllNotFoundException`. Android and iOS skip this check (no folder to probe).
4. Call `VisioForgeX.InitSDK()`. Catch and log on failure; leave the flag unset so a later retry can succeed.
5. On Windows and macOS, explicitly scan the bundled plugin folder with `Gst.Registry.Get().ScanPath(NativesPath)`. Unity's in-process plugin scan does not reliably honour `GST_PLUGIN_PATH` on either platform; the explicit scan is what makes blocks like `BufferSinkBlock` (which depends on `appsink`) load. Android registers plugins statically in `GStreamer.init`; iOS registers them statically in the framework — both skip the scan.
6. Set the success flag.

Every sample script — the low-level `MediaBlocksPlayer` / `RTSPViewerPlayer` and the high-level `MediaPlayerXPlayer` / `VideoCaptureXRecorder` / `IPCameraXViewer` / `VideoEditXRenderer` — calls `InitializeSdk()` from its `Start()` method, before it builds a pipeline or constructs an engine. Your scripts should follow the same pattern.

## The Editor lifecycle

The SDK initializes once per Editor process and is reused across **Play → Stop → Play** sessions. Two consequences:

- **You do not need to disable Domain Reload.** Unity's default Enter Play Mode behavior (Domain + Scene Reload) is fully supported. The SDK runs its GLib main-loop on a background thread Unity cannot abort, but the package installs a reload guard (below) that stops that thread before each domain reload, so entering/leaving Play mode and script recompiles all complete cleanly.
- **Do not call `VisioForgeX.DestroySDK()` on Stop or in `OnDestroy`.** GStreamer's `gst_deinit` cannot be re-initialized in the same process — destroying the SDK on Stop and trying to use it again on the next Play crashes inside the native registry. The sample players follow this rule: their `OnDestroy` disposes only the per-play pipeline. The SDK stays alive for the rest of the process lifetime.

There is one Editor-only guard the package installs automatically: a `VisioForgeEditorReloadGuard` that calls `VisioForgeX.StopMainLoop()` on `beforeAssemblyReload` and `EditorApplication.quitting`. The GLib main-loop runs on a dedicated background thread, blocked inside a native call Unity cannot abort — without this guard, the domain reload that follows a script recompile or entering Play mode would hang. The guard does **not** call `DestroySDK` (see above); it stops only the loop thread, and the next Play rebuilds the loop. This guard is internal — your scripts should ignore it.

## Frequently Asked Questions

### Do I have to call `Configure()` manually?

No. Unity's `[RuntimeInitializeOnLoadMethod(BeforeSceneLoad)]` attribute runs it for you before the first scene loads. The only time you would call it again is from a custom recovery path when an earlier attempt failed — and `Configure()` is idempotent, so a redundant call is harmless.

### Why does `Configure()` mutate environment variables instead of passing arguments?

GLib reads `GST_PLUGIN_PATH`, `GIO_MODULE_DIR`, `SSL_CERT_FILE`, `HOME`, etc. from the C `environ` directly during `gst_init` and again at first TLS use. The SDK has no API to override them — the only correct way to point the runtime at the bundled assets is to set the variables before any pipeline is built. The mutations are scoped to the process; the user and system environments are untouched.

### What happens if I call `InitializeSdk()` before `Configure()` has succeeded?

It logs an error and returns. The success flag stays unset so a later retry can succeed once `Configure()` works. This guard exists because `InitSDK()` will otherwise crash deep inside native code with a far less actionable error.

### Can I run two pipelines side by side?

Yes. `InitializeSdk()` brings the SDK up once per process; after that you can construct as many `MediaBlocksPipeline` instances — or `MediaPlayerCoreX` / `VideoCaptureCoreX` / `VideoEditCoreX` engines — as you want. Each is independent — the sample multi-camera RTSP pattern is to attach one `RTSPViewerPlayer` per `RawImage`, and each builds and tears down its own pipeline.

## See also

- [Using VisioForge in Unity](../) — package overview and how rendering works
- [Build for Windows](../windows/) — Windows Editor and Standalone build settings
- [Build for Android](../android/) — Android IL2CPP build settings
- [Build for macOS](../macos/) — macOS Standalone build settings
- [Build for iOS](../ios/) — iOS device build settings
- [Troubleshooting](../troubleshooting/) — common bootstrap and runtime errors

---END OF PAGE---


## Get Started with Media Blocks SDK in Unity 6 — Quickstart
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/getting-started/
**Description:** Five-step quickstart from a fresh Unity 6 project to a playing video — import the VisioForge .unitypackage, apply Player Settings, run the sample.
**Tags:** Media Blocks SDK, .NET, Unity, Quickstart, Windows, C#
**API:** VisioForgeEnvironment, MediaBlocksPipeline, BufferSinkBlock

# Getting started

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

This page is the five-step path from a fresh Unity 6 project to a playing video. For installation details, deep platform notes, and the bootstrap explanation, follow the links at the end.

## What you need

- **Unity 6 LTS** (`6000.x`) — verified on `6000.4.6f1`. Older Unity LTS (2022 / 2023) may also work (untested), provided they offer `.NET Standard 2.1` as an Api Compatibility Level option.
- **A short NTFS project path** on Windows — for example, `C:\unity\MyApp`. Avoid Dev Drive (ReFS) and very long paths; Unity's package cache can overflow Windows' 260-character `MAX_PATH`.
- For the mobile / Apple targets, the matching Unity module installed via Unity Hub (Android Build Support, iOS Build Support, macOS Build Support).

## Step 1 — Download the cumulative `.unitypackage`

[**VisioForge.MediaBlocks.Unity.unitypackage**](https://files.visioforge.com/unity/VisioForge.MediaBlocks.Unity.unitypackage)

```
https://files.visioforge.com/unity/VisioForge.MediaBlocks.Unity.unitypackage
```

The package is self-contained — managed assemblies, every supported native runtime, sample scenes, and the one-time setup helper are all inside it. No NuGet restore, no external GStreamer install, no per-platform downloads.

## Step 2 — Import the package

In Unity: **Assets → Import Package → Custom Package…**, select the downloaded `.unitypackage`, and click **Import** with all items checked.

The published cumulative package adds all four platform runtimes (a custom private build only includes the platforms its `-Include*` switches opted into):

- `Assets/StreamingAssets/VisioForge/x64/` — Windows native runtime
- `Assets/Plugins/Android/` — Android native runtime
- `Assets/Plugins/macOS/` — macOS native runtime
- `Assets/Plugins/iOS/GStreamerX.framework/` — iOS native runtime
- `Assets/Plugins/` — managed SDK assemblies
- `Assets/Scripts/` — the shared `VisioForgeEnvironment`, `VisioForgeVideoView`, and two sample player components
- `Assets/Scenes/SimplePlayer.unity` and `Assets/Scenes/RTSPViewer.unity` — sample scenes
- `Assets/VisioForge/` — the one-time setup helper and (on mobile / macOS builds) `link.xml`

## Step 3 — Apply the project settings

On first import the setup helper offers to apply the mandatory setting. Click **Apply** and it is configured for you:

| Setting | Value | Why |
| --- | --- | --- |
| Api Compatibility Level | `.NET Standard 2.1` | The SDK ships as `netstandard2.1` assemblies. The legacy `.NET Framework` setting cannot load them. |

Unity's default **Enter Play Mode** behavior (Domain + Scene Reload) is fully supported — you do **not** need to disable Domain Reload. The SDK survives the Editor's Play/Stop reloads.

If you click **Skip**, set the Api Compatibility Level manually under **Edit → Project Settings → Player → Other Settings → Configuration → Api Compatibility Level**.

For mobile targets (Android, iOS), set **Scripting Backend = IL2CPP** in the same Configuration section. Mono is not supported on Android or iOS by Unity itself.

## Step 4 — Run the sample scene

1. In the **Project** window open `Assets/Scenes/SimplePlayer.unity` (double-click — do not stay on the empty default scene).
2. Select the **RawImage** GameObject in the **Hierarchy**.
3. In the **Inspector** set **File Path** to an absolute path to a local media file.
4. Press **▶ Play**.

Video renders in the Game view; audio plays through the system default device.

If you have a local RTSP camera, open `Assets/Scenes/RTSPViewer.unity` instead, set **Rtsp Url** (plus **Login** / **Password** if the camera requires authentication), and press **Play**.

## Step 5 — Adapt to your own scene

You do not have to use the sample scenes. To play a video into your own UI:

1. Add a **Canvas → Raw Image** (*GameObject → UI → Raw Image*).
2. Select the **Raw Image** and **Add Component →** `MediaBlocksPlayer` (or `RTSPViewerPlayer` for RTSP).
3. Set the **File Path** (or **Rtsp Url**) field and press **▶ Play**.

The aspect handling, vertical flip, and `Texture2D` upload are handled by the bundled `VisioForgeVideoView`. Your script is just the pipeline — see [Play a media file in Unity](../simple-player/) for the C# breakdown.

## Build for a target platform

When you are ready to ship:

- [Windows x64](../windows/) — Editor and Standalone Player baseline.
- [Android](../android/) — IL2CPP arm64, AndroidManifest permissions, build size notes.
- [macOS](../macos/) — Universal arm64+x86\_64, code-signing and notarization.
- [iOS](../ios/) — Xcode export, Info.plist permissions, IL2CPP arm64 device only.

The cumulative `.unitypackage` contains every platform you opted into when it was built; Unity picks the right runtime per Build Target via the per-file `PluginImporter` metadata.

## See also

- [Install the Media Blocks SDK in Unity](../../../install/unity/) — installation reference
- [Using VisioForge in Unity](../) — architecture and rendering overview
- [Bootstrap and lifecycle](../bootstrap/) — what `Configure()` and `InitializeSdk()` do
- [Platform matrix](../platform-matrix/) — feature availability by platform
- [Troubleshooting](../troubleshooting/) — common errors and fixes

---END OF PAGE---


## Video Playback & RTSP in Unity with Media Blocks SDK .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/
**Description:** Add video playback and live RTSP to Unity 6 with the VisioForge Media Blocks SDK .NET — cross-platform .unitypackage for Windows, Android, macOS, iOS.
**Tags:** Media Blocks SDK, .NET, Unity, Windows, Android, macOS, iOS, RTSP, C#
**API:** MediaBlocksPipeline, BufferSinkBlock, UniversalSourceBlock, RTSPSourceBlock, AudioRendererBlock, VisioForgeEnvironment

# Video playback and RTSP streaming in Unity

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

The **Media Blocks SDK .NET** ships a cross-platform, ready-to-import **`.unitypackage`** that brings video-file playback, live RTSP / IP-camera streaming, and the rest of the Media Blocks pipeline into **Unity 6**. The same package targets four platforms — **Windows x64**, **Android (IL2CPP arm64)**, **macOS Standalone (Universal arm64+x86\_64)**, and **iOS Standalone (device arm64)**. Import once, switch Build Target, build.

To install the package, see **[Install the Media Blocks SDK in Unity](../../install/unity/)**. For the five-step shortcut, see **[Quickstart](getting-started/)**.

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups and verified code examples.

The full SDK is available — the samples are just a starting point

The package bundles the **complete Media Blocks SDK .NET**. The included sample scenes are examples to get you running quickly — your scripts have access to the **entire Media Blocks API**: capture and multiple source types, decoders and encoders, audio/video processing and effects, mixing and compositing, recording to file, and network streaming output. Build whatever pipeline your app needs. See the [Media Blocks SDK .NET documentation](../../mediablocks/) for the full block catalog.

## Cumulative platform packaging

The shipped `.unitypackage` is **cumulative** — one file carries the managed assemblies plus every native runtime, and Unity's per-file `PluginImporter` metadata picks the right copy when you switch Build Target. There is no per-platform download.

| Platform | Native runtime | Architecture | Build profile |
| --- | --- | --- | --- |
| Windows | flat GStreamer install in `StreamingAssets/VisioForge/x64/` | x86\_64 | [Build for Windows](windows/) |
| Android | monolithic `libgstreamer_android.so` + Java AAR | arm64-v8a | [Build for Android](android/) |
| macOS | ~300 separate dylibs in `Plugins/macOS/` | Universal arm64 + x86\_64 | [Build for macOS](macos/) |
| iOS | embedded `GStreamerX.framework` (statically registered plugins) | device arm64 | [Build for iOS](ios/) |

All four flavors share the same managed surface — `MediaBlocksPipeline`, `BufferSinkBlock`, `RTSPSourceBlock`, `UniversalSourceBlock`, every effect, every encoder, every sink. The only per-platform thing your script ever sees is the `Application.platform` value at runtime.

## Samples

The package ships ready scenes under `Assets/Scenes/`. Open one in the **Project** window (double-click it — do not stay on the empty default scene) and press **▶ Play**:

- **[Play a media file](simple-player/)** — two scenes: the low-level `SimplePlayer` (`MediaBlocksPipeline`) and the high-level `MediaPlayerX` (`MediaPlayerCoreX`, with seek/pause/volume).
- **[View an RTSP camera](rtsp-viewer/)** — two scenes: the low-level `RTSPViewer` (`MediaBlocksPipeline`) and the high-level `IPCameraX` (`VideoCaptureCoreX`, with optional recording).
- **[Capture a webcam](video-capture-x/)** — the `VideoCaptureX` scene: local webcam + microphone with MP4 recording (`VideoCaptureCoreX`, Windows / macOS).
- **[Edit and render](video-edit-x/)** — the `VideoEditX` scene: a multi-clip timeline previewed live, then rendered to MP4 (`VideoEditCoreX`).

The low-level scenes use the `MediaBlocksPipeline` API; the high-level CoreX scenes render into a `RawImage` through the Unity-only `OnVideoFrameUnity` event (tightly packed RGBA32, `Texture2D`-ready).

The RawImage looks empty until you press Play

The video texture is created at runtime, so the `RawImage` is blank (white) in edit mode. That is expected — nothing is drawn until the pipeline starts.

## How rendering works

Two shared helpers handle setup and rendering for you, so each player script is just the Media Blocks pipeline:

1. **`VisioForgeEnvironment.Configure()`** runs automatically before the first scene loads and prepares the bundled native runtime for the current platform — Windows DLL search path, macOS dylib loader hints, Android Java bootstrap, or iOS framework bring-up. You don't manage any native dependencies or paths. The full story is in [Bootstrap and lifecycle](bootstrap/).
2. **`VisioForgeEnvironment.InitializeSdk()`** initializes the SDK once. Call it before you build a pipeline (the sample players call it in `Start()`).
3. Each player builds a pipeline ending in a **`BufferSinkBlock(VideoFormatX.RGBA)`**; its `OnVideoFrameBuffer` event hands video frames to **`VisioForgeVideoView`**.
4. **`VisioForgeVideoView`** uploads each frame into a Unity `Texture2D` on the main thread and applies the aspect mode, so the video shows up in your `RawImage`. You don't write any texture code — just attach it (the sample players do this for you).

### Editor lifecycle

The SDK runs its GStreamer GLib main-loop on a background thread Unity cannot abort. Two points follow from that:

- **You do not need to disable Domain Reload.** Unity's default Enter Play Mode behavior (Domain + Scene Reload) is fully supported — the package's reload guard stops the main-loop thread before each reload, so Play/Stop completes without hanging.
- The sample players dispose only the per-play pipeline on Stop (`StopAsync`) and intentionally **do not** shut the whole SDK down — keep that pattern in your own scripts.

If you hit instability after a script recompile, restart the Editor. See [Bootstrap and lifecycle](bootstrap/#the-editor-lifecycle) for the rationale.

## Frequently Asked Questions

### Do I get the full Media Blocks SDK, or only playback?

The full SDK. The sample scenes are starting points; your scripts have access to the entire Media Blocks SDK .NET API — capture, multiple source types, decoders and encoders, audio/video processing and effects, mixing and compositing, recording to file, and network streaming.

### Can I render video into my own UI instead of the sample scenes?

Yes. Add a `RawImage`, attach `MediaBlocksPlayer` (file) or `RTSPViewerPlayer` (RTSP), or build your own pipeline and feed a `BufferSinkBlock` into `VisioForgeVideoView`. The texture upload, aspect handling, and flip are handled for you.

### Is the same package used for every platform?

Yes — one cumulative `.unitypackage` contains the Windows, Android, macOS, and iOS native runtimes plus a single set of `netstandard2.1` managed assemblies. Unity picks the matching slot at build time from per-file `PluginImporter` metadata; you do not import a separate package per platform.

### Can I see which platform code path is running?

Yes. `VisioForgeEnvironment.Configure()` logs one of `[VisioForge] Environment configured. Natives: <path>` (Windows / macOS), `[VisioForge] Android GStreamer bootstrap complete.`, or `[VisioForge] iOS environment configured (GStreamerX.framework via @rpath).` in the Console. Use that line to confirm which branch ran.

## See Also

- [Install the Media Blocks SDK in Unity](../../install/unity/) — full setup, step by step
- [Quickstart](getting-started/) — the five-step path to a playing video
- [Bootstrap and lifecycle](bootstrap/) — what `Configure()` and `InitializeSdk()` do
- [Play a media file in Unity](simple-player/) — the file-playback sample
- [View an RTSP camera in Unity](rtsp-viewer/) — the live RTSP / IP camera sample
- [Capture a webcam with VideoCaptureCoreX](video-capture-x/) · [Edit and render with VideoEditCoreX](video-edit-x/) — the standalone CoreX engine samples
- [Build for Windows](windows/) · [Android](android/) · [macOS](macos/) · [iOS](ios/)
- [Platform matrix](platform-matrix/) — feature support by Unity platform
- [Troubleshooting](troubleshooting/) — common errors and fixes
- [Media Blocks SDK .NET overview](../../mediablocks/) — the full block catalog
- [IP camera brands directory](../../camera-brands/) — tested camera URLs and settings

---END OF PAGE---


## Build a Unity App with Video Playback for iOS (device arm64)
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/ios/
**Description:** Build settings, Xcode workflow, Info.plist permissions, and troubleshooting for the VisioForge Media Blocks SDK .NET in Unity 6 on iOS Standalone.
**Tags:** Media Blocks SDK, .NET, Unity, iOS, IL2CPP, RTSP, Xcode, C#
**API:** VisioForgeEnvironment, MediaBlocksPipeline, RTSPSourceBlock

# Build for iOS

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

The iOS flavor ships as a single `GStreamerX.framework` (~68 MB on disk, arm64 device only) with every GStreamer plugin statically registered inside the framework, plus the package's managed assemblies built against `netstandard2.1`. There are no separate plugin files and no plugin scan at runtime — dyld loads the framework via `@rpath` when the first `[DllImport]` fires. This page covers the Xcode export workflow, the Info.plist entries, and the iOS-specific gotchas; for the bring-up sequence see [Bootstrap and lifecycle](../bootstrap/).

The iOS flavor is bundled into the `.unitypackage` when the build pipeline is run with both `-IncludeMacOS` and `-IncludeIOS`. iOS development happens on a Mac host, so the macOS flavor is required alongside iOS — without it, the Editor on the Mac would have no native runtime to load when opening the package. The result is one cumulative package that holds Windows, Android, macOS, and iOS together.

## Player Settings

| Setting | Value | Where |
| --- | --- | --- |
| Target Platform | **iOS** | File → Build Profiles → iOS |
| Target SDK | **Device SDK** | File → Build Profiles → iOS |
| Target minimum iOS Version | **15.0** or later | Project Settings → Player → Other Settings → Configuration |
| Architecture | **ARM64** | Project Settings → Player → Other Settings → Configuration |
| Api Compatibility Level | **.NET Standard 2.1** | Project Settings → Player → Other Settings → Configuration |
| Scripting Backend | **IL2CPP** *(mandatory — Mono is not supported on iOS by Unity itself)* | Project Settings → Player → Other Settings → Configuration |
| Target Device | **iPhone + iPad** | Project Settings → Player → Other Settings → Configuration |
| Enable Bitcode | **Off** *(removed from Xcode 14+)* | Project Settings → Player → Other Settings → Configuration |

The Editor automatically applies `Api Compatibility Level = .NET Standard 2.1` for iOS when the package's one-time setup dialog runs. If you skipped that dialog, set it manually.

## Required Info.plist entries

These are appended to the generated Xcode project's `Info.plist`. Edit them either through Unity's **Player Settings** UI or via a post-process script in your Editor scripts:

| Key | Value | Required for |
| --- | --- | --- |
| `NSCameraUsageDescription` | Reason you need camera access | Camera capture sources |
| `NSMicrophoneUsageDescription` | Reason you need microphone access | Microphone capture sources |
| `NSLocalNetworkUsageDescription` | Reason you need LAN access | RTSP streams on the local network (`192.168.*`, mDNS discovery) |
| `NSAppTransportSecurity` → `NSAllowsArbitraryLoads` = `YES` | (optional) | Plain `http://` URLs and self-signed `https://` / `rtsps://` certificates |

Without `NSLocalNetworkUsageDescription`, iOS 14+ silently blocks the first connection attempt to any local-network address — `RTSPSourceBlock` then surfaces a connect timeout that looks like a camera-side error. Set the string to something the App Store reviewers will accept (for example, "This app streams video from local IP cameras on your network.").

If you stream only public `https://` / `rtsps://` URLs from internet hosts with valid CA-signed certificates, you can skip the ATS exception entirely — App Transport Security accepts those by default.

## On-disk layout

The `deploy-unity-natives.ps1 -Platform iOS` step stages the iOS runtime as:

| Path | Contents |
| --- | --- |
| `Assets/Plugins/iOS/GStreamerX.framework/GStreamerX` | The Mach-O arm64 binary — every GStreamer plugin statically registered. |
| `Assets/Plugins/iOS/GStreamerX.framework/Info.plist` | Framework metadata. |
| `Assets/Plugins/iOS/GStreamerX.framework/Modules/module.modulemap` | Swift / Objective-C module map. |
| `Assets/Plugins/iOS/libVisioForge_Core.a` | The SDK's iOS-flavor static archive. |
| `Assets/VisioForge/link.xml` | IL2CPP preservation rules (shared across mobile flavors). |
| `Assets/Plugins/iOS/Managed/` | Managed assemblies built against `netstandard2.1` with `UNITY_NS21_IOS` defined. |

`PluginImporter` metadata on the framework folder marks it `Add To Embedded Binaries = YES`, so Unity embeds it into the generated Xcode project automatically. Dyld resolves `@rpath/GStreamerX.framework/GStreamerX` when the first `[DllImport]` from the SDK fires — no search path setup is required.

The CA bundle is **not** a separate file on iOS — it is an embedded managed resource inside `VisioForge.Core.dll` (`VisioForge.Core.ResourcesData.ca-certificates.crt`). `VisioForgeEnvironment.Configure()` extracts it to `Application.persistentDataPath/ssl/certs/` at startup and points `SSL_CERT_FILE` there.

## Xcode workflow

1. **File → Build Profiles → iOS → Build** — Unity produces an Xcode project, not a final `.ipa`.
2. Open the generated `.xcworkspace` (or `.xcodeproj`) in Xcode on the same Mac.
3. **Signing & Capabilities** tab on the Unity-iPhone target — set your Apple Developer team and a bundle identifier you own.
4. Connect the iPhone (or simulator stub — see the Simulator note below), pick it as the Run target, and press **▶ Run**.

The first build takes a few minutes — Xcode is compiling IL2CPP-generated C++ into device arm64. Incremental builds are seconds.

Simulator is not supported

`GStreamerX.framework` ships device-arm64 only. The iOS Simulator (x86\_64 on Intel Macs, arm64-sim on Apple silicon) cannot load it — Xcode aborts the build with `Could not find module 'GStreamerX' for target 'arm64-apple-ios-simulator'`. Test on a real iPhone or iPad. If you have a hard Simulator requirement, contact support.

## Build size

The iOS flavor adds roughly **40 MB** to the final `.ipa`:

- `GStreamerX.framework/GStreamerX` — ~38 MB device-arm64 binary after link-time thinning (from the ~68 MB on-disk framework)
- `libVisioForge_Core.a` — linked into the IL2CPP binary, ~2 MB delta
- Managed assemblies — ~3 MB

The compressed `.ipa` is typically smaller after App Store thinning.

## Troubleshooting

| Symptom | Cause | Fix |
| --- | --- | --- |
| Xcode aborts: `dyld: Library not loaded: @rpath/GStreamerX.framework/GStreamerX` | `Add To Embedded Binaries` was not applied to the framework PluginImporter slot. | Confirm `Assets/Plugins/iOS/GStreamerX.framework`'s `.meta` has `AddToEmbeddedBinaries: 1`. If you replaced it manually, re-import the package. |
| `UnityException: get_dataPath can only be called from the main thread` from a GStreamer callback | The first reader of `NativesPath` ran on a background thread before `Configure()`'s main-thread prime. | Confirm `Configure()` completed — it prints `[VisioForge] iOS environment configured (GStreamerX.framework via @rpath).` in the Console. If absent, the bootstrap failed before priming. |
| `MissingMethodException` from `GLib.SignalArgs` or `SignalClosure.MarshalCallback` | `link.xml` was removed or IL2CPP managed stripping is on without it. | Confirm `Assets/VisioForge/link.xml` exists. Re-import the package if missing. |
| RTSP stream times out before connecting on iOS 14+ | `NSLocalNetworkUsageDescription` is missing — iOS blocks the first LAN connection. | Add the key to `Info.plist` with a user-facing reason. |
| RTSPS / HTTPS fails with TLS error on first request | CA bundle extraction failed silently. | Check Console for `[VisioForge] CA cert extraction failed`. The embedded resource ships in `VisioForge.Core.dll` — confirm the DLL was not stripped. |
| App rejected from App Store review for "missing privacy reason" | A capture source needs `NSCameraUsageDescription` or `NSMicrophoneUsageDescription`. | Add the matching keys with user-facing reasons. |
| Crash on the second `Play` in Xcode | `VisioForgeX.DestroySDK()` was called in `OnDestroy`. | Don't call it — see [Bootstrap and lifecycle](../bootstrap/#the-editor-lifecycle). |

## Frequently Asked Questions

### Can I use Mono on iOS?

No. Unity itself does not support Mono on iOS — IL2CPP is the only backend for iOS Standalone builds. The SDK matches that constraint.

### Does the iOS flavor work in the iOS Simulator?

No. `GStreamerX.framework` is device-arm64 only — see the note above. Test on real hardware.

### Why is the Xcode build the slow step?

IL2CPP transpiles every managed assembly (your scripts + Unity engine + the SDK) into C++, then Xcode compiles that C++ for device arm64. The first cold build is ~3 — 5 minutes; incremental builds are seconds because Xcode caches almost everything.

### Does the SDK upload data to VisioForge servers?

No. The SDK runs entirely in-process — no telemetry, no licensing call-home, no usage analytics. The `NSLocalNetworkUsageDescription` requirement is purely about your app's outgoing RTSP / HTTP connections, which iOS treats as user-visible.

## See also

- [Install the Media Blocks SDK in Unity](../../../install/unity/) — package setup
- [Bootstrap and lifecycle](../bootstrap/) — how `Configure()` brings up the iOS runtime
- [Build for macOS](../macos/) — the matching macOS host you need to build iOS
- [View an RTSP camera in Unity](../rtsp-viewer/) — the `RTSPViewer` sample
- [Troubleshooting](../troubleshooting/) — cross-platform error reference

---END OF PAGE---


## Build a Unity Game with Video Playback for macOS (Universal)
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/macos/
**Description:** Build settings, dylib layout, code-signing, and troubleshooting for the VisioForge Media Blocks SDK .NET in Unity 6 on macOS Standalone.
**Tags:** Media Blocks SDK, .NET, Unity, macOS, Standalone Player, RTSP, C#
**API:** VisioForgeEnvironment, MediaBlocksPipeline, RTSPSourceBlock

# Build for macOS

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

The macOS flavor ships a Universal (arm64 + x86\_64) GStreamer runtime plus the package's managed assemblies built against `netstandard2.1`. The native runtime is a set of ~300 separate dylibs — core GStreamer libs, plugins, GIO modules, OpenSSL TLS backend, CA bundle — flat in `Assets/Plugins/macOS/`. This page covers the Build Profile settings, the dylib layout, and the macOS-specific issues; for the bring-up sequence see [Bootstrap and lifecycle](../bootstrap/).

The macOS flavor is bundled into the `.unitypackage` when the build pipeline is run with `-IncludeMacOS`. The result is one cumulative package that holds Windows-x64, Android, and macOS together — Unity picks the right files per Build Target through the per-file `PluginImporter` metadata.

## Player Settings

| Setting | Value | Where |
| --- | --- | --- |
| Target Platform | **macOS** | File → Build Profiles → macOS |
| Architecture | **Intel 64-bit + Apple silicon** (Universal) | File → Build Profiles → macOS |
| Api Compatibility Level | **.NET Standard 2.1** | Project Settings → Player → Other Settings → Configuration |
| Scripting Backend | **Mono** *or* **IL2CPP** *(both are tested)* | Project Settings → Player → Other Settings → Configuration |
| Mac App Store Validation | **Off** *(or sign the GStreamer dylibs first, see below)* | Project Settings → Player → Other Settings |

Both scripting backends are tested. Mono is the default and is faster to iterate on; switch to IL2CPP only if you have a project-wide reason. The same `link.xml` that the package ships preserves the SDK's managed types on either backend.

## On-disk layout

The `deploy-unity-natives.ps1 -Platform macOS` step stages the macOS runtime as:

| Path | Contents |
| --- | --- |
| `Assets/Plugins/macOS/libgstreamer-1.0.0.dylib` | Core GStreamer library. |
| `Assets/Plugins/macOS/libgio-2.0.0.dylib`, `libglib-2.0.0.dylib`, `libgobject-2.0.0.dylib` | GLib core. |
| `Assets/Plugins/macOS/libgst*.dylib` | Every GStreamer plugin (decoders, encoders, sources, sinks, base elements). |
| `Assets/Plugins/macOS/libgioopenssl.so` | GIO TLS backend that RTSPS / HTTPS verify peers through. |
| `Assets/Plugins/macOS/ca-certificates.crt` | CA bundle for OpenSSL. |
| `Assets/Plugins/macOS/libVisioForge_Core.dylib` | The SDK's native shim. |
| `Assets/VisioForge/link.xml` | IL2CPP preservation rules (shared with Android). |
| `Assets/Plugins/macOS/` | Managed assemblies built against `netstandard2.1` with `UNITY_NS21_MACOS` defined. |

The layout is flat — every dylib's `@rpath` / `@loader_path` is baked in by the NuGet pack, so once dyld has loaded one via the first `[DllImport]`, the siblings resolve automatically.

## Standalone build

**File → Build Profiles → macOS → Build** produces a `.app` bundle.

Where the natives end up in the bundle depends on the Unity version:

| Layout | Used by | `VisioForgeEnvironment.NativesPath` resolves to |
| --- | --- | --- |
| `<app>.app/Contents/PlugIns/` | Unity 6 default | `…/Contents/PlugIns` |
| `<app>.app/Contents/PlugIns/macOS/` | some Unity 6 patch releases | `…/Contents/PlugIns/macOS` |
| `<app>.app/Contents/Frameworks/` | older Unity layouts | `…/Contents/Frameworks` |
| `<app>.app/Contents/Resources/Data/Plugins/macOS/` | very old layouts | `…/Contents/Resources/Data/Plugins/macOS` |

`NativesPath` probes all four locations at startup, looking for the sentinel `libgstreamer-1.0.0.dylib`. The first folder that contains it wins, and the result is cached for the rest of the process — there is no setting you adjust per Unity version.

## Build size

The macOS flavor adds roughly **100 MB** to the `.app` bundle (Universal arm64 + x86\_64). It is the largest of the cumulative-package flavors because every plugin ships as its own dylib and both architectures are included. If you target Apple silicon only, you can post-process the bundle to strip the x86\_64 slices with `lipo`, but the package itself does not split them by default.

## Code-signing and notarization

For distribution outside the Mac App Store you typically want to sign and notarize the bundle:

1. **Hardened Runtime** enabled (Project Settings → Player → Other Settings or your signing workflow).
2. **Codesign every dylib in `Contents/PlugIns/`** with your Developer ID Application certificate before signing the `.app` itself. Unity does not sign third-party plugins for you.
3. **Notarize** the final `.app` (or its `.zip` / `.dmg`) with `xcrun notarytool submit … --wait`.
4. **Staple** the notarization ticket with `xcrun stapler staple <app-bundle>`.

The GStreamer dylibs do not require any Apple entitlements beyond the Hardened Runtime default; they do not access protected resources from inside their native code. Your own app determines which entitlements (camera, microphone, network, etc.) are required.

For Mac App Store submission, the bundled `libgioopenssl.so` and `libgmp.10.dylib` are statically linked and ship under permissive licenses, but the App Store review may flag the file extension `.so` for a macOS bundle. If you need App Store distribution, contact support — that path is not exercised by the package CI.

## Troubleshooting

| Symptom | Cause | Fix |
| --- | --- | --- |
| `DllNotFoundException: libgstreamer-1.0.0` on Play | `Plugins/macOS/` is empty or the sentinel `libgstreamer-1.0.0.dylib` is missing. | Re-import the `.unitypackage` with all items checked. The Console shows the resolved `NativesPath` — confirm the sentinel is there. |
| `[VisioForge] Native runtime folder not found at '…/Contents/PlugIns'` on a Standalone build | Plugins were not staged into the `.app` because the macOS flavor was not in the package. | Re-build the package with `-IncludeMacOS` (or import the cumulative `.unitypackage` that includes macOS). |
| Pipeline hangs at startup, log shows two `gst_init` calls | A homebrew or system GStreamer install is on `DYLD_LIBRARY_PATH`. | `Configure()` prunes it — confirm the stripped count is non-zero in the Console. Hardened Runtime strips `DYLD_*` before the process starts, so this is mostly a Mono-Editor concern. |
| RTSPS / HTTPS fails with `Peer certificate cannot be authenticated with given CA certificates` | `ca-certificates.crt` not found at the expected path. | `Configure()` logs a warning if the bundle is missing. Re-import the package or re-run `deploy-unity-natives.ps1 -Platform macOS`. |
| Bundle launched from Finder shows `Damaged app` dialog | The `.app` is unsigned and downloaded with the quarantine flag set. | Sign + notarize for distribution, or for local testing run `xattr -d com.apple.quarantine <app-bundle>` once. |
| Bundle launched from a Mac App Store TestFlight build crashes | `.so` files in the bundle violate App Store layout rules. | Contact support — App Store submission needs an alternate native packaging. |

## Frequently Asked Questions

### Does the macOS flavor work in the Editor on a Mac?

Yes — both `OSXEditor` (the Editor itself) and `OSXPlayer` (a Standalone build) are admitted runtime targets. `Configure()` resolves `Plugins/macOS/` from the project root in the Editor and probes the bundle layout in the player.

### Do I need the macOS flavor to open the package in a Mac-host Editor?

Yes. The `.unitypackage` you import must contain the macOS flavor (`-IncludeMacOS`) for the Mac-host Editor to find a native runtime to load. A Windows-only package, opened in a Mac Editor, will surface the cross-flavor mismatch as `[VisioForge] Native runtime folder not found at '…' for runtime platform OSXEditor` — see [Bootstrap and lifecycle](../bootstrap/).

### Can I ship Apple silicon only and skip x86\_64?

Yes. After the build, run `lipo -thin arm64 <dylib> -output <dylib>` on each `.dylib` in `Contents/PlugIns/` to strip the Intel slices. The package does not do this by default because both architectures are still useful for compatibility testing.

### Does the same package work on iOS too?

The iOS flavor is shipped as a separate platform inside the same `.unitypackage` when built with `-IncludeIOS`. See [Build for iOS](../ios/).

## See also

- [Install the Media Blocks SDK in Unity](../../../install/unity/) — package setup
- [Bootstrap and lifecycle](../bootstrap/) — how `Configure()` finds the macOS runtime
- [Build for iOS](../ios/) — the matching iOS flavor (requires a Mac host)
- [View an RTSP camera in Unity](../rtsp-viewer/) — the `RTSPViewer` sample
- [Troubleshooting](../troubleshooting/) — cross-platform error reference

---END OF PAGE---


## Unity Media Blocks SDK .NET — platform feature matrix
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/platform-matrix/
**Description:** Feature support by Unity build target — sources, sinks, encoders, capture, and effects across Windows x64, Android, macOS Standalone, and iOS device.
**Tags:** Media Blocks SDK, .NET, Unity, Platform Matrix, Windows, Android, macOS, iOS, C#
**API:** MediaBlocksPipeline, UniversalSourceBlock, RTSPSourceBlock, BufferSinkBlock

# Platform matrix

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

This page lists what works on which Unity build target — the matrix is filtered to the runtime that ships in the cumulative `.unitypackage`. For the SDK-wide feature matrix that covers all .NET project types (not just Unity), see [Platform matrix (.NET)](../../../platform-matrix/).

Legend: ✅ supported · ⚠️ partial · ❌ not supported

## Build targets

| Build target | Architecture | Scripting backend | Min. version |
| --- | --- | --- | --- |
| Windows Editor + Standalone Player | x86\_64 | Mono *(default)* or IL2CPP | Windows 10 1809 / Server 2019 |
| macOS Editor + Standalone Player | Universal arm64 + x86\_64 | Mono *(default)* or IL2CPP | macOS 11 Big Sur |
| Android Standalone Player | arm64-v8a | IL2CPP *(mandatory)* | Android 7.0 / API 24 |
| iOS Standalone Player | device arm64 | IL2CPP *(mandatory)* | iOS 15 |

Other build targets (Linux, WebGL, UWP, tvOS, visionOS, console SDKs) are not part of the package today.

## Source blocks

| Source | Windows | Android | macOS | iOS |
| --- | --- | --- | --- | --- |
| `UniversalSourceBlock` (file / URL via decodebin) | ✅ | ✅ | ✅ | ✅ |
| `RTSPSourceBlock` (live RTSP / RTSPS) | ✅ | ✅ | ✅ | ✅ |
| `VirtualVideoSourceBlock` (test pattern) | ✅ | ✅ | ✅ | ✅ |
| `HTTPMJPEGSourceBlock` | ✅ | ✅ | ✅ | ✅ |
| `NDISourceBlock` | ✅ | ❌ | ✅ | ❌ |
| `DecklinkVideoSourceBlock` | ✅ | ❌ | ✅ | ❌ |
| `SystemVideoSourceBlock` (camera) | ✅ DirectShow / MediaFoundation | ✅ Camera2 | ✅ AVFoundation | ✅ AVFoundation |
| `SystemAudioSourceBlock` (microphone) | ✅ WASAPI | ✅ OpenSL | ✅ CoreAudio | ✅ AVAudio |
| `ScreenSourceBlock` (desktop capture) | ✅ | ❌ | ✅ | ❌ |

## Sink blocks

| Sink | Windows | Android | macOS | iOS |
| --- | --- | --- | --- | --- |
| `BufferSinkBlock` (raw frame callback into `RawImage`) | ✅ | ✅ | ✅ | ✅ |
| `AudioRendererBlock` (system default device) | ✅ WASAPI | ✅ OpenSL | ✅ CoreAudio | ✅ AVAudio |
| `MP4SinkBlock` (file mux) | ✅ | ✅ | ✅ | ✅ |
| `MKVSinkBlock` (file mux) | ✅ | ✅ | ✅ | ✅ |
| `WebMSinkBlock` (file mux) | ✅ | ✅ | ✅ | ✅ |
| `RTSPServerBlock` (egress) | ✅ | ⚠️ no auto port-forward | ✅ | ⚠️ no auto port-forward |
| `RTMPSinkBlock` (egress) | ✅ | ✅ | ✅ | ✅ |
| `SRTSinkBlock` (egress) | ✅ | ✅ | ✅ | ✅ |
| `HLSSinkBlock` (egress) | ✅ | ✅ | ✅ | ✅ |

Unity's built-in renderer is not exposed via `VideoRendererBlock` — render through `BufferSinkBlock` + `VisioForgeVideoView`, which uploads each frame into a `Texture2D` you attach to a `RawImage` (or any material).

## Codecs

### Video decode

| Codec | Windows | Android | macOS | iOS |
| --- | --- | --- | --- | --- |
| H.264 | ✅ | ✅ HW | ✅ HW (VideoToolbox) | ✅ HW (VideoToolbox) |
| H.265 / HEVC | ✅ | ✅ HW | ✅ HW (VideoToolbox) | ✅ HW (VideoToolbox) |
| AV1 | ✅ SW (libdav1d) | ✅ HW where available | ✅ HW where available, SW (libdav1d) otherwise | ✅ HW where available, SW (libdav1d) otherwise |
| VP8 / VP9 | ✅ | ✅ | ✅ | ✅ |
| MPEG-4 part 2 | ✅ | ✅ | ✅ | ✅ |
| MPEG-2 | ✅ | ✅ | ✅ | ✅ |
| MJPEG | ✅ | ✅ | ✅ | ✅ |
| ProRes | ✅ | ⚠️ SW only | ✅ HW | ⚠️ SW only |

### Video encode

| Codec | Windows | Android | macOS | iOS |
| --- | --- | --- | --- | --- |
| H.264 | ✅ NVENC / QSV / SW | ✅ HW (MediaCodec) | ✅ HW (VideoToolbox) | ✅ HW (VideoToolbox) |
| H.265 / HEVC | ✅ NVENC / QSV / SW | ✅ HW (MediaCodec) | ✅ HW (VideoToolbox) | ✅ HW (VideoToolbox) |
| AV1 | ✅ SW (SVT-AV1) | ⚠️ device-dependent | ⚠️ SW only | ❌ not available |
| VP8 / VP9 | ✅ SW | ✅ SW | ✅ SW | ✅ SW |
| MJPEG | ✅ | ✅ | ✅ | ✅ |

### Audio decode / encode

| Codec | Windows | Android | macOS | iOS |
| --- | --- | --- | --- | --- |
| AAC | ✅ | ✅ | ✅ | ✅ |
| MP3 | ✅ | ✅ | ✅ | ✅ |
| Opus | ✅ | ✅ | ✅ | ✅ |
| FLAC | ✅ | ✅ | ✅ | ✅ |
| Vorbis | ✅ | ✅ | ✅ | ✅ |
| AC-3 / E-AC-3 | ✅ decode | ✅ decode | ✅ decode | ✅ decode |

## Effects and processing

| Feature | Windows | Android | macOS | iOS |
| --- | --- | --- | --- | --- |
| `BufferSinkBlock` RGBA frame callback | ✅ | ✅ | ✅ | ✅ |
| Audio effects (volume, EQ, normalize) | ✅ | ✅ | ✅ | ✅ |
| Video effects (color, transform, deinterlace) | ✅ | ✅ | ✅ | ✅ |
| `TextOverlayBlock` / `ImageOverlayBlock` (text / image on video) | ✅ | ✅ | ✅ | ✅ |
| `VideoMixerBlock` / `AudioMixerBlock` (live compositing) | ✅ | ✅ | ✅ | ✅ |

## Network protocols

| Protocol | Windows | Android | macOS | iOS |
| --- | --- | --- | --- | --- |
| RTSP (TCP / UDP / multicast) | ✅ | ✅ | ✅ | ✅ |
| RTSPS (TLS) | ✅ | ✅ | ✅ | ✅ |
| RTMP / RTMPS | ✅ | ✅ | ✅ | ✅ |
| SRT (caller / listener) | ✅ | ✅ | ✅ | ✅ |
| HLS (read / write) | ✅ | ✅ | ✅ | ✅ |
| HTTP / HTTPS | ✅ | ✅ | ✅ | ✅ |
| WebRTC | ✅ | ✅ | ✅ | ✅ |
| NDI | ✅ | ❌ | ✅ | ❌ |

WebRTC is supported on every target. Like any WebRTC deployment it needs a signalling server and ICE / STUN / TURN configuration for your network — that wiring is app-specific, not a platform limitation.

## Cumulative-package shipping

The cumulative `.unitypackage` contains the platforms its build was opted into. The package shipped from `https://files.visioforge.com/unity/` carries:

- Windows-x64 (always)
- Android arm64
- macOS Universal
- iOS device arm64

If a private build skipped a platform with the matching `-Include*` switch left out, the package's `PluginImporter` slots for that platform are absent and Unity will fail to load the SDK when the Build Target is switched to it.

## See also

- [Install the Media Blocks SDK in Unity](../../../install/unity/) — install + targeting
- [Bootstrap and lifecycle](../bootstrap/) — runtime bring-up across platforms
- [Build for Windows](../windows/) · [Android](../android/) · [macOS](../macos/) · [iOS](../ios/)
- [Platform matrix (.NET, full SDK surface)](../../../platform-matrix/) — feature support across every .NET host (WPF, WinForms, MAUI, Avalonia, Uno, Unity, raw .NET)
- [Media Blocks SDK .NET overview](../../../mediablocks/) — the full block catalog

---END OF PAGE---


## RTSP Camera in Unity with Media Blocks or VideoCaptureCoreX
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/rtsp-viewer/
**Description:** View a live RTSP / IP camera in Unity 6 with the Media Blocks RTSPViewer pipeline or the high-level VideoCaptureCoreX engine, with optional recording.
**Tags:** Media Blocks SDK, Video Capture SDK, .NET, Unity, Windows, Android, macOS, iOS, RTSP, IP Camera, Streaming, C#
**API:** MediaBlocksPipeline, RTSPSourceBlock, BufferSinkBlock, VideoCaptureCoreX, RTSPSourceSettings, MP4Output

# View an RTSP camera in Unity

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

There are two ways to view a live RTSP / IP camera stream in Unity, and the package ships a ready scene for each. Both render into a Unity `RawImage` and run on **Windows**, **Android**, **macOS Standalone**, and **iOS**. This article assumes you have imported the Unity package and applied the two required project settings — see [Using VisioForge in Unity](../) first.

## Two scenes, two engines

| Scene | Engine | Level | Best for |
| --- | --- | --- | --- |
| **`RTSPViewer`** | `MediaBlocksPipeline` (Media Blocks SDK) | Low-level | Full control over the pipeline — pick your own sinks, effects, and outputs. |
| **`IPCameraX`** | `VideoCaptureCoreX` (Video Capture SDK) | High-level | Ready-made capture engine — adds recording outputs, snapshots, audio routing, and overlays on top of the same stream. |

Pick `RTSPViewer` when you want to assemble the pipeline yourself; pick `IPCameraX` when you want a capture engine that can also record while it previews. Both feed the same bundled `VisioForgeVideoView`, so the texture upload, aspect handling, and vertical flip are identical.

## RTSPViewer — the Media Blocks pipeline

The **`RTSPViewer`** scene displays a live RTSP / IP camera stream with the low-level **Media Blocks SDK .NET**, rendered into a `RawImage`.

### Run the RTSPViewer scene

1. In the **Project** window open `Assets/Scenes/RTSPViewer.unity` (double-click it).
2. In the **Hierarchy** select the **RawImage** GameObject. The `RTSPViewerPlayer` component is attached to it.
3. In the **Inspector**, set **Rtsp Url** (and **Login** / **Password** if the camera requires authentication).
4. Press **▶ Play** — the stream renders in the Game view.

### Inspector fields (RTSPViewerPlayer)

| Field | Default | Description |
| --- | --- | --- |
| **Rtsp Url** | `rtsp://192.168.1.10:554/stream` | RTSP URL of the camera/stream. |
| **Login** | *(empty)* | RTSP username — leave empty if the stream needs no auth. |
| **Password** | *(empty)* | RTSP password. |
| **Auto Play On Start** | `true` | Connect automatically in `Start()`. |
| **Render Audio** | `true` | Render audio through the system default device. |
| **Aspect Mode** | `Letterbox` | How the video is fitted into the `RawImage`: `Stretch`, `Letterbox`, or `Crop`. |

### The RTSPViewer pipeline

`RTSPViewerPlayer` builds this pipeline:

```
graph LR;
    src[RTSPSourceBlock] -->|video| sink["BufferSinkBlock (RGBA)"];
    sink --> view["VisioForgeVideoView (Texture2D)"];
    src -->|audio, optional| audio[AudioRendererBlock];
```

The core of `PlayAsync`:

```
_pipeline = new MediaBlocksPipeline();

// readInfo:false skips the media pre-probe (it can fail under the Unity runtime, and
// probing a live stream adds connect latency); the codec is negotiated when playback starts.
var settings = await RTSPSourceSettings.CreateAsync(
    new Uri(rtspUrl), login ?? string.Empty, password ?? string.Empty,
    audioEnabled: _renderAudio, readInfo: false);

_source = new RTSPSourceBlock(settings);

_videoSink = new BufferSinkBlock(VideoFormatX.RGBA);
_videoSink.OnVideoFrameBuffer += _videoView.OnFrameBuffer;
_pipeline.Connect(_source.VideoOutput, _videoSink.Input);

if (_renderAudio && _source.AudioOutput != null)
{
    _audioRenderer = new AudioRendererBlock();
    _pipeline.Connect(_source.AudioOutput, _audioRenderer.Input);
}

await _pipeline.StartAsync();
```

## IPCameraX — the VideoCaptureCoreX engine

The **`IPCameraX`** scene views the same RTSP / IP camera with the high-level **`VideoCaptureCoreX`** engine. On top of the live preview it can record to MP4 and exposes snapshots, audio routing, and overlays — the capture-engine features the hand-built `RTSPViewer` pipeline does not provide out of the box.

### The OnVideoFrameUnity event

`VideoCaptureCoreX` exposes the Unity-only **`OnVideoFrameUnity`** event: each frame arrives as tightly packed **RGBA32** (`Stride == Width * 4`), ready for `Texture2D.LoadRawTextureData` with no conversion. Subscribe before `StartAsync`.

### Run the IPCameraX scene

1. In the **Project** window open `Assets/Scenes/SampleScene.unity`.
2. In the **Hierarchy** select the **RawImage** GameObject — the `IPCameraXViewer` component is attached to it.
3. In the **Inspector** set **Rtsp Url** (and **Login** / **Password** if the camera needs them).
4. Press **▶ Play** — the camera stream appears in the Game view.

### Inspector fields (IPCameraXViewer)

| Field | Default | Description |
| --- | --- | --- |
| **Rtsp Url** | `rtsp://192.168.1.10:554/stream` | RTSP / HTTP camera URL. |
| **Login** | *(empty)* | Camera user name (empty for open streams). |
| **Password** | *(empty)* | Camera password (empty for open streams). |
| **Render Audio** | `false` | Request and render the camera audio stream, if present. |
| **Record To File** | `false` | Record the stream to MP4 while previewing. |
| **Output Path** | *(empty)* | MP4 path. Empty → `<persistentDataPath>/ipcamera.mp4`. |
| **Auto Play On Start** | `true` | Connect automatically in `Start()`. |
| **Aspect Mode** | `Letterbox` | How the video is fitted into the `RawImage`. |

### The IPCameraX pipeline

```
graph LR;
    rtsp["VideoCaptureCoreX (RTSP source)"] -->|OnVideoFrameUnity, RGBA32| view["VisioForgeVideoView (Texture2D)"];
    rtsp -->|optional record| mp4["MP4Output (H264 + AAC)"];
```

The core of `PlayAsync`:

```
_capture = new VideoCaptureCoreX();

// readInfo:false skips the media pre-probe (it can fail under the Unity runtime and adds latency).
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri(rtspUrl), login, password, audioEnabled: renderAudio, readInfo: false);
_capture.Video_Source = rtspSettings;

// Texture-ready RGBA32 frames straight into the view.
_capture.OnVideoFrameUnity += _videoView.OnFrameBuffer;

if (recordToFile)
    _capture.Outputs_Add(new MP4Output(outputPath), autostart: true);

await _capture.StartAsync();
```

## Use it in your own scene

Add a **Canvas → Raw Image** (*GameObject → UI → Raw Image*), select it, **Add Component →** `RTSPViewerPlayer` (Media Blocks pipeline) or `IPCameraXViewer` (VideoCaptureCoreX engine), set **Rtsp Url**, and press **▶ Play**. The `RawImage` layout, aspect handling, and vertical flip are handled by the bundled `VisioForgeVideoView`. For local file playback instead of RTSP, use `MediaBlocksPlayer` or `MediaPlayerXPlayer` (see [Play a media file](../simple-player/)).

## Per-platform Build Settings and network permissions

Both scenes run unchanged on every supported platform — but each target has its own network-permission and Build Profile requirements.

WindowsAndroidmacOSiOS

| Setting | Value |
| --- | --- |
| Architecture | x86\_64 |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | Mono *(default)* or IL2CPP |

Outbound TCP / UDP to the camera's RTSP port works with no special declaration. Windows Defender Firewall may prompt the first time the player binds a UDP socket — accept the private-network prompt. See [Build for Windows](../windows/) for the full checklist.

| Setting | Value |
| --- | --- |
| Architecture | arm64-v8a (**uncheck ARMv7**) |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | **IL2CPP** (mandatory) |
| Internet Access | **Require** |

`AndroidManifest.xml` must declare:

```
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
```

For RTSP over UDP on a public network, Android 9+ (API 28+) also requires `android:usesCleartextTraffic="true"` on the `<application>` element if the camera is reachable only via plain RTSP / RTP without TLS. See [Build for Android](../android/) for the full checklist.

| Setting | Value |
| --- | --- |
| Architecture | Universal arm64 + x86\_64 |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | Mono *(default)* or IL2CPP |

No additional manifest entries — outbound connections are unrestricted by default. For Mac App Store distribution add the **com.apple.security.network.client** entitlement to the signed bundle so the App Sandbox allows outbound network access. See [Build for macOS](../macos/) for code-signing and notarization notes.

| Setting | Value |
| --- | --- |
| Architecture | device arm64 (Simulator not supported) |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | **IL2CPP** (mandatory) |

iOS 14+ blocks the first connection attempt to any local-network address until your app declares why. Add to `Info.plist`:

```
<key>NSLocalNetworkUsageDescription</key>
<string>This app streams video from local IP cameras on your network.</string>
```

For plain `rtsp://` (no TLS) or `http://` URLs, add an App Transport Security exception:

```
<key>NSAppTransportSecurity</key>
<dict>
    <key>NSAllowsArbitraryLoads</key>
    <true/>
</dict>
```

Public `https://` / `rtsps://` URLs with CA-signed certificates need no ATS exception. See [Build for iOS](../ios/) for the full Xcode workflow.

## Auto-reconnect

Both engines reconnect automatically when the stream drops, with backoff between attempts — no manual state machine in your script. For `RTSPViewer`, raise the timeout on the underlying `RTSPSourceSettings` before passing them to `RTSPSourceBlock` if you need a longer window; `IPCameraX` (`VideoCaptureCoreX`) handles camera reboots and brief interruptions the same way.

## Frequently Asked Questions

### Which scene should I use — RTSPViewer or IPCameraX?

Use **`RTSPViewer`** (`MediaBlocksPipeline`) for a lean view-only pipeline you assemble yourself. Use **`IPCameraX`** (`VideoCaptureCoreX`) when you also want recording to MP4, snapshots, audio routing, or overlays on the same stream — they are ready-made on the capture engine.

### How do I provide camera credentials?

Set the **Login** and **Password** fields on either component. Leave them empty for streams that need no authentication; the credentials are sent to the camera, not embedded in the URL.

### What URL format should I use?

The standard `rtsp://host:port/path` form your camera exposes, e.g. `rtsp://192.168.1.21:554/Streaming/Channels/101` (Hikvision) or `rtsp://192.168.1.22:554/cam/realmonitor?channel=1&subtype=0` (Dahua). Check your camera's manual for its exact stream path.

### Does it record the camera?

`IPCameraX` does — enable **Record To File** to add an `MP4Output` alongside the preview. `RTSPViewer` is view-only; add a recording branch to its pipeline yourself if you need it.

### What if the camera has no audio?

Both work as video-only. The audio branch is connected only when the stream actually carries audio, so a video-only camera needs no changes.

### Can I display several cameras at once?

Yes. Add a `RawImage` with its own `RTSPViewerPlayer` or `IPCameraXViewer` for each camera; each builds an independent pipeline.

## See Also

- [Using VisioForge in Unity](../) — package overview, setup, and how rendering works
- [Play a media file in Unity](../simple-player/) — the local file / URL playback scenes
- [Capture a webcam in Unity](../video-capture-x/) — local-camera capture (Windows / macOS)
- [RTSP streaming guide](../../network-streaming/rtsp/) — RTSP across the VisioForge .NET SDKs
- [IP camera brands directory](../../../camera-brands/) — tested camera URLs and settings
- [Media Blocks RTSP player in C#](../../../mediablocks/Guides/rtsp-player-csharp/) — a non-Unity RTSP example

---END OF PAGE---


## Play Media in Unity with Media Blocks or MediaPlayerCoreX
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/simple-player/
**Description:** Play files and URLs in Unity 6 with the Media Blocks SimplePlayer pipeline or the high-level MediaPlayerCoreX engine, rendering into a RawImage.
**Tags:** Media Blocks SDK, Media Player SDK, .NET, Unity, Windows, Android, macOS, iOS, Playback, C#
**API:** MediaBlocksPipeline, UniversalSourceBlock, BufferSinkBlock, MediaPlayerCoreX, UniversalSourceSettings

# Play a media file in Unity

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

There are two ways to play a local file or a network URL in Unity, and the package ships a ready scene for each. Both render into a Unity `RawImage` and run on **Windows**, **Android**, **macOS Standalone**, and **iOS**. This article assumes you have imported the Unity package and applied the two required project settings; see [Using VisioForge in Unity](../) first.

## Two scenes, two engines

| Scene | Engine | Level | Best for |
| --- | --- | --- | --- |
| **`SimplePlayer`** | `MediaBlocksPipeline` (Media Blocks SDK) | Low-level | Full control over the pipeline — pick your own source, sinks, effects, and encoders. |
| **`MediaPlayerX`** | `MediaPlayerCoreX` (Media Player SDK) | High-level | Ready-made playback control — play, pause, resume, seek, volume, and rate with no manual wiring. |

Pick `SimplePlayer` when you want to assemble the pipeline yourself; pick `MediaPlayerX` when you want a player engine that already exposes transport controls. Both feed the same bundled `VisioForgeVideoView`, so the texture upload, aspect handling, and vertical flip are identical.

## SimplePlayer — the Media Blocks pipeline

The **`SimplePlayer`** scene plays a local video file with the low-level **Media Blocks SDK .NET** and renders it into a `RawImage`.

### Run the SimplePlayer scene

1. In the **Project** window open `Assets/Scenes/SimplePlayer.unity` (double-click it).
2. In the **Hierarchy** select the **RawImage** GameObject. The `MediaBlocksPlayer` component is attached to it.
3. In the **Inspector**, set **File Path** to an absolute path to a local media file.
4. Press **▶ Play** — the video appears in the Game view and audio plays through the system default device.

The RawImage is blank until you press Play

The video texture is created at runtime, so the `RawImage` shows nothing in edit mode.

### Inspector fields (MediaBlocksPlayer)

| Field | Default | Description |
| --- | --- | --- |
| **File Path** | `C:\Samples\!video.avi` | Absolute path to the media file to play. |
| **Auto Play On Start** | `true` | Start playback automatically in `Start()`. |
| **Render Audio** | `true` | Render audio through the system default device. |
| **Use Test Pattern** | `false` | Play a synthetic test pattern instead of the file (diagnostic baseline). |
| **Aspect Mode** | `Letterbox` | How the video is fitted into the `RawImage`: `Stretch`, `Letterbox`, or `Crop`. |

### The SimplePlayer pipeline

`MediaBlocksPlayer` builds this pipeline:

```
graph LR;
    src[UniversalSourceBlock] -->|video| sink["BufferSinkBlock (RGBA)"];
    sink --> view["VisioForgeVideoView (Texture2D)"];
    src -->|audio, optional| audio[AudioRendererBlock];
```

The core of `PlayAsync`:

```
_pipeline = new MediaBlocksPipeline();

_videoSink = new BufferSinkBlock(VideoFormatX.RGBA);
_videoSink.OnVideoFrameBuffer += _videoView.OnFrameBuffer;

// ignoreMediaInfoReader:true skips the media pre-probe (it can fail under the Unity
// runtime); the codec is negotiated when the pipeline starts.
var settings = await UniversalSourceSettings.CreateAsync(
    filePath, renderVideo: true, renderAudio: _renderAudio, ignoreMediaInfoReader: true);

_source = new UniversalSourceBlock(settings);
_pipeline.Connect(_source.VideoOutput, _videoSink.Input);

if (_renderAudio && _source.AudioOutput != null)
{
    _audioRenderer = new AudioRendererBlock();
    _pipeline.Connect(_source.AudioOutput, _audioRenderer.Input);
}

await _pipeline.StartAsync();
```

`UniversalSourceBlock` auto-detects the container and codec. The audio branch is connected only when the file has an audio stream (`_source.AudioOutput != null`).

## MediaPlayerX — the MediaPlayerCoreX engine

The **`MediaPlayerX`** scene plays the same files and URLs with the high-level **`MediaPlayerCoreX`** engine. Unlike the hand-built `SimplePlayer` pipeline, `MediaPlayerCoreX` gives you ready-made playback control — play, pause, resume, seek, volume, and playback rate — with no manual pipeline wiring.

### The OnVideoFrameUnity event

`MediaPlayerCoreX`, `VideoCaptureCoreX`, and `VideoEditCoreX` expose a Unity-only event, **`OnVideoFrameUnity`**, that delivers each preview frame as tightly packed **RGBA32** (`Stride == Width * 4`, no row padding). It is uploaded straight into a `Texture2D` with no pixel conversion. Subscribe to it before opening the source so the engine wires its internal frame grabber into the pipeline.

### Run the MediaPlayerX scene

1. In the **Project** window open `Assets/Scenes/SampleScene.unity`.
2. In the **Hierarchy** select the **RawImage** GameObject — the `MediaPlayerXPlayer` component is attached to it.
3. In the **Inspector**, set **File Path** to an absolute path or a URL.
4. Press **▶ Play** — the video appears in the Game view and audio plays through the default device.

### Inspector fields (MediaPlayerXPlayer)

| Field | Default | Description |
| --- | --- | --- |
| **File Path** | `C:\Samples\!video.mp4` | Absolute path, or a `file`/`http`/`https`/`rtsp`/`hls` URL. |
| **Auto Play On Start** | `true` | Start playback automatically in `Start()`. |
| **Render Audio** | `true` | Render audio through the system default output device. |
| **Volume** | `1.0` | Initial audio volume (0..1). |
| **Aspect Mode** | `Letterbox` | How the video is fitted into the `RawImage`: `Stretch`, `Letterbox`, or `Crop`. |

### The MediaPlayerX pipeline

```
graph LR;
    player["MediaPlayerCoreX (headless)"] -->|OnVideoFrameUnity, RGBA32| view["VisioForgeVideoView (Texture2D)"];
    player -->|audio| out["Audio output device"];
```

The core of `PlayAsync`:

```
_player = new MediaPlayerCoreX();

// Texture-ready RGBA32 frames straight into the view.
_player.OnVideoFrameUnity += _videoView.OnFrameBuffer;

// MediaPlayerCoreX only renders audio when an output device is set.
var outputs = await _player.Audio_OutputDevicesAsync();
if (outputs != null && outputs.Length > 0)
{
    _player.Audio_OutputDevice = new AudioRendererSettings(outputs[0]);
    _player.Audio_OutputDevice_Volume = 1.0;
}

// ignoreMediaInfoReader:true skips the media pre-probe (it can fail under the Unity runtime).
var source = await UniversalSourceSettings.CreateAsync(
    filePath, renderVideo: true, renderAudio: true, renderSubtitle: false,
    deepDiscovery: false, ignoreMediaInfoReader: true);

await _player.OpenAsync(source);
await _player.PlayAsync();
```

`PauseAsync`, `ResumeAsync`, and `Position_SetAsync(TimeSpan)` give you transport control; the sample exposes them as `PauseAsync()`, `ResumeAsync()`, and `SeekAsync(position)`.

## Use it in your own scene

You do not have to use a sample scene:

1. Add a **Canvas → Raw Image** (*GameObject → UI → Raw Image*).
2. Select the **Raw Image** and **Add Component →** `MediaBlocksPlayer` (Media Blocks pipeline) or `MediaPlayerXPlayer` (MediaPlayerCoreX engine).
3. Set **File Path** and press **▶ Play**.

The aspect handling (`Stretch` / `Letterbox` / `Crop`), the `RawImage` layout, and the vertical flip are handled for you by the bundled `VisioForgeVideoView` — you do not write any texture code. To switch the same GameObject to RTSP playback, use `RTSPViewerPlayer` or `IPCameraXViewer` (see [View an RTSP camera](../rtsp-viewer/)).

## Per-platform Build Settings

Both scenes run unchanged on every supported platform. Switch Build Target and apply the matching settings:

WindowsAndroidmacOSiOS

| Setting | Value |
| --- | --- |
| Architecture | x86\_64 |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | Mono *(default)* or IL2CPP |

Local file paths use the standard Windows form (`C:\Samples\video.mp4`). See [Build for Windows](../windows/) for the full checklist.

| Setting | Value |
| --- | --- |
| Architecture | arm64-v8a (**uncheck ARMv7**) |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | **IL2CPP** (mandatory) |
| Internet Access | Require (for network URLs) |

Local files live under `Application.persistentDataPath` or `Application.streamingAssetsPath` — absolute Windows paths are not portable. To read media from external storage, declare `READ_MEDIA_VIDEO` / `READ_MEDIA_AUDIO` in `AndroidManifest.xml`. See [Build for Android](../android/) for the full checklist.

| Setting | Value |
| --- | --- |
| Architecture | Universal arm64 + x86\_64 |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | Mono *(default)* or IL2CPP |

Local file paths use Unix form (`/Users/<you>/Movies/video.mp4`). See [Build for macOS](../macos/) for code-signing and notarization notes.

| Setting | Value |
| --- | --- |
| Architecture | device arm64 (Simulator not supported) |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | **IL2CPP** (mandatory) |
| App Transport Security | Add an ATS exception for plain-HTTP/RTSP URLs |

Local files must live inside the app sandbox — typically `Application.persistentDataPath` (the Documents folder) or `Application.streamingAssetsPath` (read-only inside the `.app` bundle). See [Build for iOS](../ios/) for the Xcode workflow.

## Frequently Asked Questions

### Which scene should I use — SimplePlayer or MediaPlayerX?

Use **`SimplePlayer`** (`MediaBlocksPipeline`) when you want to build the pipeline yourself — add effects, multiple sinks, recording, or custom sources. Use **`MediaPlayerX`** (`MediaPlayerCoreX`) when you want a player engine that already provides seeking, pause/resume, duration, audio device selection, and rate control as ready-made methods.

### Which video and audio formats can it play?

The package bundles FFmpeg/libav, so common formats decode out of the box — MP4, MKV, AVI, MOV with H.264/H.265, MPEG-4, plus MP3/AAC audio, among others. Both engines auto-detect the format.

### Can it play network streams?

Yes. `MediaPlayerX` takes an `http`/`https`/`rtsp`/`hls` URL directly in **File Path** (`UniversalSourceSettings` handles both local files and URLs). `SimplePlayer` plays local files; for a dedicated live-camera pipeline use [View an RTSP camera](../rtsp-viewer/).

### How do I seek or pause?

On `MediaPlayerX`, call `SeekAsync(TimeSpan)`, `PauseAsync()`, and `ResumeAsync()` on the component — they wrap `Position_SetAsync`, `PauseAsync`, and `ResumeAsync` on `MediaPlayerCoreX`. The low-level `SimplePlayer` does not expose transport controls; rebuild the pipeline to change source.

### Why does MediaPlayerX need an audio output device set?

`MediaPlayerCoreX` renders audio only when `Audio_OutputDevice` is set. The sample enumerates output devices with `Audio_OutputDevicesAsync()` and selects the first one. `SimplePlayer` instead routes audio through an `AudioRendererBlock`.

### How do I control how the video fits the RawImage?

Use the **Aspect Mode** field on either component: `Stretch` (fill, may distort), `Letterbox` (fit with bars), or `Crop` (fill and crop the overflow).

## See Also

- [Using VisioForge in Unity](../) — package overview, setup, and how rendering works
- [View an RTSP camera in Unity](../rtsp-viewer/) — the live RTSP / IP camera scenes
- [Capture a webcam in Unity](../video-capture-x/) — the VideoCaptureCoreX recorder sample
- [Edit and render in Unity](../video-edit-x/) — the VideoEditCoreX timeline sample
- [Media Blocks SDK .NET overview](../../../mediablocks/) — the full block catalog

---END OF PAGE---


## Troubleshoot the Media Blocks SDK in Unity — Common Errors
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/troubleshooting/
**Description:** Common errors and fixes for the VisioForge Media Blocks SDK .NET in Unity 6 — bootstrap, missing natives, IL2CPP, TLS and Editor lifecycle.
**Tags:** Media Blocks SDK, .NET, Unity, Troubleshooting, Windows, Android, macOS, iOS, C#
**API:** VisioForgeEnvironment, MediaBlocksPipeline

# Troubleshooting

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

This page collects the symptoms you are most likely to hit and the root cause for each. Errors are grouped by category. The per-platform pages ([Windows](../windows/), [Android](../android/), [macOS](../macos/), [iOS](../ios/)) also have a target-specific Troubleshooting table — check both.

## Bootstrap and initialization

### `[VisioForge] Native runtime not found at <path>`

`VisioForgeEnvironment.Configure()` could not find the bundled natives folder on disk. Causes:

- The `.unitypackage` import was partial. Re-import with all items checked.
- On Standalone macOS, the Build Target did not include the macOS flavor — the package was built without `-IncludeMacOS`. Re-build the package or import the cumulative variant.
- On Android, the per-Build-Target flavor staging step did not run. Open `Assets/Plugins/Android/libs/arm64-v8a/` in the Project window and confirm `libgstreamer_android.so` is present.

### `[VisioForge] InitializeSdk() called before Configure() succeeded`

A platform branch of `Configure()` failed and left `s_envConfigured = false`. The earlier Console line (`[VisioForge] Android GStreamer init failed: …`, `[VisioForge] SetDllDirectoryW failed (Win32 error …)`, etc.) explains why. Fix the underlying issue and let `Configure()` retry on the next scene load.

### `UnityException: get_dataPath can only be called from the main thread`

A background thread inside the SDK or your script read `Application.dataPath` (or `Application.streamingAssetsPath`, or `Application.platform`) without going through the cached path. The fix:

- On iOS, `Configure()` primes `s_cachedNativesPath` on the main thread — confirm the Console shows `[VisioForge] iOS environment configured (GStreamerX.framework via @rpath).`. If absent, the bootstrap aborted before priming and the next reader hits the lazy path off the main thread.
- In your own code, do not call Unity API from a `Task.Run`, GStreamer pad-added callback, or bus signal handler. Marshal the call back to the main thread with `UnitySynchronizationContext` or by setting a flag the `Update()` method checks.

### `InvalidOperationException: Unity Android bootstrap requires com.unity3d.player.UnityPlayer.currentActivity to be available`

The Android Java bootstrap could not get a non-null `currentActivity` at `BeforeSceneLoad`. Happens on Wear OS, Android TV variants without `UnityPlayerActivity`, and Unity-as-a-library hosts that have not assigned the field yet. Defer `Configure()` to your first observable Activity event:

```
private void Start()
{
    if (!VisioForgeIsConfigured())
        VisioForgeEnvironment.Configure();   // re-run after Activity is ready
    VisioForgeEnvironment.InitializeSdk();
}
```

`Configure()` is idempotent — a redundant call after a successful one is harmless.

## Missing libraries

### `DllNotFoundException: gstreamer-1.0-0`

Windows: the natives folder is missing from `Assets/StreamingAssets/VisioForge/x64/`. Re-import the package. If you are running a Standalone build, confirm `<game>_Data/StreamingAssets/VisioForge/x64/` is also populated — Unity copies it verbatim, so a missing folder in the build means it was missing in the project.

### `DllNotFoundException: libgstreamer_android`

Android: Scripting Backend is set to **Mono**. Switch to **IL2CPP** under Project Settings → Player → Other Settings → Configuration. Mono is not supported on Android by Unity itself.

### `DllNotFoundException: libgstreamer-1.0.0` *(macOS)*

The `.app` bundle does not contain `libgstreamer-1.0.0.dylib` at any of the probed locations (`Contents/PlugIns`, `Contents/PlugIns/macOS`, `Contents/Frameworks`, `Contents/Resources/Data/Plugins/macOS`). Re-build the package with `-IncludeMacOS` and re-export the Standalone build.

### `dyld: Library not loaded: @rpath/GStreamerX.framework/GStreamerX`

iOS: the framework's PluginImporter slot did not get **Add To Embedded Binaries = YES**. Re-import the package; the package's `.meta` file marks the framework correctly. If you replaced the framework manually, restore the `.meta` from a fresh import.

## IL2CPP / managed stripping

### `MissingMethodException: GLib.SignalArgs..ctor` *(or similar GStreamer / GLib types)*

IL2CPP stripped a managed type the SDK references through reflection. `Assets/VisioForge/link.xml` preserves these types — confirm the file exists in your project. If you accidentally deleted it, re-import the `.unitypackage`. Do **not** edit `link.xml` to remove rules; the package ships a tested set.

### `MarshalDirectiveException` at the first SDK call

A `[DllImport]` signature was stripped or its delegate marshalling failed. Same root cause as `MissingMethodException` — confirm `link.xml` is in place and IL2CPP is not configured with an extra-aggressive stripping level that overrides it.

## TLS / network

### RTSP stream times out before connecting *(iOS 14+)*

iOS blocks the first connection attempt to any local-network address until your `Info.plist` declares why your app needs LAN access. Add:

```
<key>NSLocalNetworkUsageDescription</key>
<string>This app streams video from local IP cameras on your network.</string>
```

App Store reviewers expect a user-facing reason, not boilerplate.

### RTSPS / HTTPS fails with TLS / certificate verification error

GIO's OpenSSL TLS backend could not find a CA bundle:

- Windows / macOS: `Configure()` sets `SSL_CERT_FILE` to the bundled `ca-certificates.crt`. If missing, the Console logs `[VisioForge] CA certificate bundle not found at …`. Re-stage the natives via `deploy-unity-natives.ps1` and re-build.
- Android / iOS: the CA bundle is an embedded managed resource extracted to `<filesDir>/ssl/certs/`. If extraction fails, the Console logs `[VisioForge] CA cert extraction failed`. Confirm `VisioForge.Core.dll` is in `Assets/Plugins/Android/` (Android) or `Assets/Plugins/iOS/Managed/` (iOS).

For self-signed certificates, either install them into the system trust store (out of scope for the SDK) or — for testing only — disable peer verification on the source block. The block-level property name varies; see [View an RTSP camera in Unity](../rtsp-viewer/) for the RTSP example.

### Plain `http://` URLs fail on iOS

App Transport Security (ATS) blocks `http://` by default. Either move to `https://` or, if you must keep `http://`, add `NSAppTransportSecurity → NSAllowsArbitraryLoads = YES` to your `Info.plist`. Be aware that App Store reviewers may ask why you need it.

## Editor lifecycle

### Editor hangs on "Reloading domain" after Play / Stop

Unity's default Domain Reload is fully supported and should **not** hang the Editor: the package installs a reload guard that stops the GStreamer GLib main-loop thread before each domain reload. If you still see a hang, you are on an SDK build older than this release (before the guard was added) — update to the latest SDK. You do not need to disable Domain Reload.

### Editor crashes on the second Play

The SDK was shut down on Stop and re-initialized on Play. The fix:

- Do not call `VisioForgeX.DestroySDK()` in `OnDestroy` or anywhere else. The SDK is process-global and reused across Play sessions.
- The sample players (`MediaBlocksPlayer`, `RTSPViewerPlayer`) follow this pattern — copy their teardown shape (dispose only the per-play pipeline; never destroy the SDK).

See [Bootstrap and lifecycle](../bootstrap/#the-editor-lifecycle) for the full explanation.

### Editor becomes unstable after a long editing session

Repeated script recompiles accumulate GStreamer state across domain reloads. Restart the Editor to recover. This is mostly cosmetic — Standalone Player builds do not exhibit it.

## Build / packaging

### Bundle launched from Finder shows "Damaged app" *(macOS)*

The `.app` is unsigned and downloaded with the quarantine flag set. For distribution, sign and notarize the bundle (see [Build for macOS](../macos/#code-signing-and-notarization)). For local testing only, run `xattr -d com.apple.quarantine <app-bundle>` once.

### App rejected from App Store review for "missing privacy reason" *(iOS)*

A capture source needs an explicit `Info.plist` key:

- `NSCameraUsageDescription` if your app captures from the camera
- `NSMicrophoneUsageDescription` if your app captures from the microphone
- `NSLocalNetworkUsageDescription` if your app talks to a LAN device

The user-facing string should describe the actual use, not "Required by SDK".

### `[VisioForge] Native runtime folder not found at '…' for runtime platform …`

The `.unitypackage` you imported does not contain a flavor for the current Build Target. For example, a Windows-only package opened in a Mac-host Editor surfaces this on the first `InitializeSdk()` call. Re-build (or re-download) the package with the matching `-Include*` switch, or import the cumulative variant that contains every platform.

## When all else fails

Collect a log and contact support:

1. Editor or Player Console export (`Window → General → Console`, right-click → Save All / via Logcat / via Xcode → Devices → Open Console).
2. The `.unitypackage` file name and its build date.
3. Unity version, Build Target, Scripting Backend, Api Compatibility Level.
4. A minimal reproducible scene if possible.

Open an issue at <https://support.visioforge.com/>.

## See also

- [Bootstrap and lifecycle](../bootstrap/) — how the runtime is brought up on each platform
- [Build for Windows](../windows/) · [Android](../android/) · [macOS](../macos/) · [iOS](../ios/) — per-platform troubleshooting tables
- [Platform matrix](../platform-matrix/) — feature support by Unity platform

---END OF PAGE---


## Capture Webcam Video in Unity with VideoCaptureCoreX
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/video-capture-x/
**Description:** Capture a webcam and microphone in Unity 6 with VideoCaptureCoreX — live preview into a RawImage via OnVideoFrameUnity plus MP4 recording to disk.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, Unity, Windows, macOS, Capture, C#
**API:** VideoCaptureCoreX, VideoCaptureDeviceSourceSettings, MP4Output, DeviceEnumerator, MediaBlocksPipeline, SystemVideoSourceBlock, BufferSinkBlock

# Capture a webcam in Unity with VideoCaptureCoreX

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The **`VideoCaptureX`** scene captures from a local webcam (and microphone) with the high-level **`VideoCaptureCoreX`** engine, previews the live frames into a Unity `RawImage`, and records to an MP4 file at the same time. You can also capture a webcam with the low-level **`MediaBlocksPipeline`** API — that recipe is in [Capture with the Media Blocks pipeline](#capture-with-the-media-blocks-pipeline-low-level) below. This article assumes you have imported the Unity package and applied the required project settings; see [Using VisioForge in Unity](../) first.

Platform support for local-camera capture

Local webcam/microphone capture in the Unity package targets **Windows** and **macOS Standalone** in this release. On **Android** and **iOS**, use the [IP / RTSP camera sample](../rtsp-viewer/) — `VideoCaptureCoreX` over RTSP works on all four platforms. Local device capture on Android/iOS depends on platform camera APIs that are not yet wired into the cross-platform package.

## The OnVideoFrameUnity event

`VideoCaptureCoreX` exposes the Unity-only **`OnVideoFrameUnity`** event: each frame arrives as tightly packed **RGBA32** (`Stride == Width * 4`), ready for `Texture2D.LoadRawTextureData` with no conversion. Subscribe before `StartAsync`.

## Run the sample

1. Connect a webcam, then open `Assets/Scenes/SampleScene.unity`.
2. In the **Hierarchy** select the **RawImage** GameObject — the `VideoCaptureXRecorder` component is attached to it.
3. In the **Inspector** set **Camera Index** and the **Output Path**.
4. Press **▶ Play** — the live camera renders into the Game view. Toggle recording with `StartRecordingAsync()` / `StopRecordingAsync()` (for example from a UI button).

## Inspector fields

| Field | Default | Description |
| --- | --- | --- |
| **Camera Index** | `0` | Index into `DeviceEnumerator.VideoSourcesAsync()`. |
| **Capture Audio** | `true` | Capture and record audio from the default microphone. |
| **Record On Start** | `false` | Begin recording to file as soon as preview starts. |
| **Output Path** | *(empty)* | MP4 path. Empty → `<persistentDataPath>/capture.mp4`. |
| **Aspect Mode** | `Letterbox` | How the video is fitted into the `RawImage`. |

## The pipeline

```
graph LR;
    cap["VideoCaptureCoreX (headless)"] -->|OnVideoFrameUnity, RGBA32| view["VisioForgeVideoView (Texture2D)"];
    cap -->|record| mp4["MP4Output (H264 + AAC)"];
```

The core of the preview + record setup:

```
var cameras = await DeviceEnumerator.Shared.VideoSourcesAsync();

_capture = new VideoCaptureCoreX();
_capture.Video_Source = new VideoCaptureDeviceSourceSettings(cameras[cameraIndex]);

var audioSources = await DeviceEnumerator.Shared.AudioSourcesAsync();
if (audioSources.Length > 0)
    _capture.Audio_Source = audioSources[0].CreateSourceSettingsVC();

// Texture-ready RGBA32 frames straight into the view.
_capture.OnVideoFrameUnity += _videoView.OnFrameBuffer;

// Pre-register the MP4 output (autostart:false) so preview runs without recording.
_capture.Outputs_Add(new MP4Output(outputPath), autostart: false);

await _capture.StartAsync();
```

Recording is toggled at runtime so the preview keeps running independently of capture-to-file:

```
await _capture.StartCaptureAsync(0, outputPath); // begin recording
await _capture.StopCaptureAsync(0);              // stop recording
```

## Capture with the Media Blocks pipeline (low-level)

`VideoCaptureCoreX` is the high-level engine. For full control over the pipeline you can capture the same webcam with the low-level **`MediaBlocksPipeline`** API — the approach the [SimplePlayer / RTSPViewer scenes](../simple-player/) use. There is no prebuilt webcam scene for this path; add the recipe below to your own `MonoBehaviour` (model it on the bundled `MediaBlocksPlayer`):

A `TeeBlock` splits the camera video so it feeds the preview (`BufferSinkBlock`) and the recording (`MP4OutputBlock`, which bundles the H.264 + AAC encoders and the MP4 muxer) at the same time. The microphone is added straight to the MP4 output:

```
graph LR;
    cam[SystemVideoSourceBlock] --> tee[TeeBlock];
    tee -->|preview| sink["BufferSinkBlock (RGBA)"];
    sink --> view["VisioForgeVideoView (Texture2D)"];
    tee -->|record| mp4["MP4OutputBlock (H264 + AAC)"];
    mic[SystemAudioSourceBlock] -->|record| mp4;
```

```
_pipeline = new MediaBlocksPipeline();

// Capture sources
var cameras = await DeviceEnumerator.Shared.VideoSourcesAsync();
var videoSource = new SystemVideoSourceBlock(new VideoCaptureDeviceSourceSettings(cameras[cameraIndex]));

var mics = await DeviceEnumerator.Shared.AudioSourcesAsync();
var audioSource = new SystemAudioSourceBlock(mics[0].CreateSourceSettings());

// Preview: tightly packed RGBA frames into the Unity view
var videoSink = new BufferSinkBlock(VideoFormatX.RGBA);
videoSink.OnVideoFrameBuffer += _videoView.OnFrameBuffer;

// Record: H.264 video + AAC audio muxed to MP4
var mp4 = new MP4OutputBlock(outputPath);

// Tee the camera video to both the preview sink and the recording
var videoTee = new TeeBlock(2, MediaBlockPadMediaType.Video);
_pipeline.Connect(videoSource, videoTee);

// Preview branch — one tee output to the buffer sink
_pipeline.Connect(videoTee.Outputs[0], videoSink.Input);

// Record branch — MP4OutputBlock has no fixed inputs; call CreateNewInput once per stream
_pipeline.Connect(videoTee.Outputs[1], mp4.CreateNewInput(MediaBlockPadMediaType.Video));
_pipeline.Connect(audioSource.Output, mp4.CreateNewInput(MediaBlockPadMediaType.Audio));

await _pipeline.StartAsync();             // preview + recording both run
```

`MP4OutputBlock` starts with no input pads — each `CreateNewInput(MediaBlockPadMediaType.Video|Audio)` call adds a typed input wired to the internal H.264 / AAC encoder, so create exactly one per stream. `BufferSinkBlock.OnVideoFrameBuffer` has the same `VisioForgeVideoView.OnFrameBuffer` signature as the engine's `OnVideoFrameUnity`, so the same view renders the preview. Drop the `videoTee` / `MP4OutputBlock` / audio branch to preview only; or use the high-level `VideoCaptureCoreX` path above, which lets you start and stop recording at runtime without rebuilding the pipeline. This low-level path uses the same device source as the engine, so local-camera capture has the same **Windows / macOS** scope.

## Per-platform Build Settings

WindowsmacOS

| Setting | Value |
| --- | --- |
| Architecture | x86\_64 |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | Mono *(default)* or IL2CPP |

No manifest entry is required for camera access. See [Build for Windows](../windows/).

| Setting | Value |
| --- | --- |
| Architecture | Universal arm64 + x86\_64 |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | Mono *(default)* or IL2CPP |
| Privacy | Add camera + microphone usage descriptions / entitlements |

The camera is selected through `avfvideosrc`. See [Build for macOS](../macos/).

## Frequently Asked Questions

### How do I record to a file?

The sample pre-registers an `MP4Output` and toggles capture with `StartCaptureAsync(0, path)` / `StopCaptureAsync(0)`, so the live preview runs whether or not you are recording.

### Can I capture from a local camera on Android or iOS?

Not in this release. Use the [IP / RTSP camera sample](../rtsp-viewer/) on mobile — `VideoCaptureCoreX` over RTSP works on all four platforms. Local device capture on Android/iOS is planned for a future package.

### How do I pick a specific camera?

Set **Camera Index** to the device's position in `DeviceEnumerator.Shared.VideoSourcesAsync()`.

### Which encoders does it record with?

`MP4Output` defaults to H.264 video + AAC audio. Adjust the `MP4Output` settings for custom encoders.

## See Also

- [Using VisioForge in Unity](../) — package overview, setup, and how rendering works
- [View an IP / RTSP camera in Unity](../rtsp-viewer/) — `VideoCaptureCoreX` over RTSP (all platforms)
- [Play media in Unity with MediaPlayerCoreX](../simple-player/) — the high-level player sample
- [Edit and render in Unity](../video-edit-x/) — the VideoEditCoreX timeline sample

---END OF PAGE---


## Edit and Render Video in Unity with VideoEditCoreX
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/video-edit-x/
**Description:** Combine clips, apply effects, and render to MP4 in Unity 6 with VideoEditCoreX — timeline preview into a RawImage via OnVideoFrameUnity, plus file rendering.
**Tags:** Video Edit SDK, .NET, Unity, Windows, Android, macOS, iOS, Editing, C#
**API:** VideoEditCoreX, MP4Output, GrayscaleVideoEffect

# Edit and render video in Unity with VideoEditCoreX

[Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

The **`VideoEditX`** scene combines clips on a **`VideoEditCoreX`** timeline, optionally applies a grayscale effect, and either **previews** the timeline into a Unity `RawImage` or **renders** it to an MP4 file. This article assumes you have imported the Unity package and applied the required project settings; see [Using VisioForge in Unity](../) first.

## The OnVideoFrameUnity event

`VideoEditCoreX` previews the timeline into Unity through the Unity-only **`OnVideoFrameUnity`** event. Because the engine is built on GStreamer Editing Services, the sample redirects the preview video sink to an internal RGBA frame grabber when the event is subscribed and no output file is set. Frames are tightly packed **RGBA32** (`Stride == Width * 4`), ready for `Texture2D.LoadRawTextureData`. In **render** mode (an output file is set) the event is inactive — the timeline is encoded to disk as fast as the host allows.

## Run the sample

1. Open `Assets/Scenes/SampleScene.unity`.
2. In the **Hierarchy** select the **RawImage** GameObject — the `VideoEditXRenderer` component is attached to it.
3. In the **Inspector** set **Clip 1** and **Clip 2** to local files.
4. Leave **Render To File On Start** off to **preview** the timeline, or enable it to **render** an MP4. Press **▶ Play**.

## Inspector fields

| Field | Default | Description |
| --- | --- | --- |
| **Clip 1** | `C:\Samples\clip1.mp4` | First clip (absolute path). |
| **Clip 2** | `C:\Samples\clip2.mp4` | Second clip; leave empty for a single clip. |
| **Grayscale** | `true` | Apply a grayscale video effect to the timeline. |
| **Render To File On Start** | `false` | Render to file on `Start()`; off = preview into the texture. |
| **Output Path** | *(empty)* | MP4 path for render mode. Empty → `<persistentDataPath>/edited.mp4`. |
| **Output Width / Height** | `1920` / `1080` | Output resolution for render mode. |
| **Output Frame Rate** | `30` | Output frame rate for render mode. |
| **Aspect Mode** | `Letterbox` | How the preview is fitted into the `RawImage`. |

## The pipeline

```
graph LR;
    clips["Clips + GrayscaleVideoEffect"] --> edit["VideoEditCoreX timeline"];
    edit -->|preview, OnVideoFrameUnity RGBA32| view["VisioForgeVideoView (Texture2D)"];
    edit -->|render| mp4["MP4Output (H264 + AAC)"];
```

The core of the build + run:

```
// One init call for the whole SDK (brings up GStreamer). VideoEditCoreX initializes GES in its constructor.
VisioForgeEnvironment.InitializeSdk();

_editor = new VideoEditCoreX();
_editor.Input_AddAudioVideoFile(clip1);
_editor.Input_AddAudioVideoFile(clip2);

if (grayscale)
    _editor.Video_Effects.Add(new GrayscaleVideoEffect());

if (renderToFile)
{
    _editor.Output_VideoSize = new Size(1920, 1080);
    _editor.Output_VideoFrameRate = new VideoFrameRate(30.0);
    _editor.Output_Format = new MP4Output(outputPath);
}
else
{
    // Preview mode: no Output_Format → the timeline plays into the OnVideoFrameUnity grabber.
    _editor.OnVideoFrameUnity += _videoView.OnFrameBuffer;
    _editor.Output_Format = null;
}

_editor.Start();
```

In render mode, subscribe to `OnProgress` for progress percentages and `OnStop` for completion.

## Per-platform Build Settings

WindowsAndroidmacOSiOS

| Setting | Value |
| --- | --- |
| Architecture | x86\_64 |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | Mono *(default)* or IL2CPP |

See [Build for Windows](../windows/).

| Setting | Value |
| --- | --- |
| Architecture | arm64-v8a (**uncheck ARMv7**) |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | **IL2CPP** (mandatory) |

Clips must live under `Application.persistentDataPath`. See [Build for Android](../android/).

| Setting | Value |
| --- | --- |
| Architecture | Universal arm64 + x86\_64 |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | Mono *(default)* or IL2CPP |

See [Build for macOS](../macos/).

| Setting | Value |
| --- | --- |
| Architecture | device arm64 (Simulator not supported) |
| Api Compatibility Level | `.NET Standard 2.1` |
| Scripting Backend | **IL2CPP** (mandatory) |

Clips and output must live inside the app sandbox. See [Build for iOS](../ios/).

## Frequently Asked Questions

### What is the difference between preview and render mode?

Preview (no `Output_Format`) plays the timeline live into the `RawImage` through `OnVideoFrameUnity`. Render (`Output_Format` set to an `MP4Output`) encodes the timeline to a file as fast as the host allows; live preview is not produced during a render.

### Do I need a separate SDK init call?

Yes. Call the package's `VisioForgeEnvironment.InitializeSdk()` once — it brings up GStreamer (which is what prevents `DllNotFoundException`). `VideoEditCoreX` initializes GStreamer Editing Services itself in its constructor, so no separate `VideoEditCoreX.SDKInit()` call is needed. `VisioForgeEnvironment.InitializeSdk()` wraps `VisioForgeX.InitSDK()`; for non-Unity .NET hosts the equivalent is `VisioForgeX.InitSDKAsync()` — see [Initialization](../../../init/).

### How do I add more clips or effects?

Call `Input_AddAudioVideoFile` for each clip and add more entries to `Video_Effects`. The sample uses a single `GrayscaleVideoEffect` for illustration.

### How do I know when a render finishes?

Subscribe to `OnStop`; subscribe to `OnProgress` for progress updates while rendering.

## See Also

- [Using VisioForge in Unity](../) — package overview, setup, and how rendering works
- [Play media in Unity with MediaPlayerCoreX](../simple-player/) — the high-level player sample
- [Capture a webcam in Unity](../video-capture-x/) — the VideoCaptureCoreX recorder sample
- [View an IP / RTSP camera in Unity](../rtsp-viewer/) — `VideoCaptureCoreX` over RTSP

---END OF PAGE---


## Build a Unity Game with Video Playback for Windows x64
**URL:** https://www.visioforge.com/help/docs/dotnet/general/unity/windows/
**Description:** Build settings, native runtime layout, and troubleshooting for the VisioForge Media Blocks SDK .NET in Unity 6 on Windows x64 — Editor and Standalone Player.
**Tags:** Media Blocks SDK, .NET, Unity, Windows, Standalone Player, C#
**API:** VisioForgeEnvironment, MediaBlocksPipeline

# Build for Windows

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

Windows x64 is the baseline target for the Unity package — it ships in every `.unitypackage` variant the build pipeline produces. This page covers the Player Settings, the on-disk layout, and the issues you might hit on Windows specifically. For the rest, see [Bootstrap and lifecycle](../bootstrap/).

## Player Settings

| Setting | Value | Where |
| --- | --- | --- |
| Architecture | **x86\_64** | File → Build Profiles → Windows |
| Target Platform | **Windows** | File → Build Profiles → Windows |
| Api Compatibility Level | **.NET Standard 2.1** | Project Settings → Player → Other Settings → Configuration |
| Scripting Backend | **Mono** *(IL2CPP also works; Mono is the default on Windows)* | Project Settings → Player → Other Settings → Configuration |

If you imported the package with the **Apply** dialog, the mandatory project setting (`.NET Standard 2.1`) is already in place. Unity's default Enter Play Mode behavior (Domain + Scene Reload) is fully supported — no need to disable Domain Reload.

## On-disk layout

The `deploy-unity-natives.ps1` build step stages the Windows runtime into your project as follows:

| Path | Contents |
| --- | --- |
| `Assets/StreamingAssets/VisioForge/x64/` | Flat layout: core GStreamer libs, every plugin DLL, GIO modules, `ca-certificates.crt`. ~300 files. |
| `Assets/Plugins/` | Managed assemblies (`VisioForge.Core.dll`, `VisioForge.Libs.dll`, `GstSharp.dll`, `GLibSharp.dll`, etc.) with their `.meta`. |
| `Assets/Scripts/` | The shared helpers (`VisioForgeEnvironment.cs`, `VisioForgeVideoView.cs`) plus the six sample scripts (`MediaBlocksPlayer.cs`, `RTSPViewerPlayer.cs`, `MediaPlayerXPlayer.cs`, `IPCameraXViewer.cs`, `VideoCaptureXRecorder.cs`, `VideoEditXRenderer.cs`). |
| `Assets/Scenes/` | The six sample scenes: `SimplePlayer.unity`, `RTSPViewer.unity`, `MediaPlayerX.unity`, `IPCameraX.unity`, `VideoCaptureX.unity`, `VideoEditX.unity`. |

`StreamingAssets` (not `Plugins/x64`) is used because Unity copies the folder verbatim into a Standalone build, which is exactly what `VisioForgeEnvironment.Configure()` then points the DLL loader at. The same path resolves in both the Editor and the player — `Application.streamingAssetsPath` returns the project's `Assets/StreamingAssets` in the Editor and `<game>_Data/StreamingAssets` in the player.

## Standalone Player build

**File → Build Profiles → Windows → x86\_64 → Build** produces a self-contained player. No extra steps:

- Unity copies `Assets/StreamingAssets/VisioForge/x64/` into `<game>_Data/StreamingAssets/VisioForge/x64/` automatically.
- The managed plugins from `Assets/Plugins/` are staged into `<game>_Data/Managed/`.
- `VisioForgeEnvironment.Configure()` runs `BeforeSceneLoad` and points `SetDllDirectoryW` at the staged natives folder.

The resulting `<game>.exe` plus its `_Data/` folder is the entire shippable artifact.

## On-disk size

The Windows runtime adds roughly **50 MB** of native libraries to your build (down to ~30 MB if you exclude libav with `-SkipLibav` when rebuilding the package). The managed assemblies add another ~5 MB.

## Troubleshooting

| Symptom | Cause | Fix |
| --- | --- | --- |
| `DllNotFoundException: gstreamer-1.0-0` on Play | `Assets/StreamingAssets/VisioForge/x64/` is missing or empty. | Re-import the `.unitypackage` with all items checked, or check the `[VisioForge] Native runtime not found at …` Console line for the resolved path. |
| Pipeline hangs at startup, log shows two `gst_init` calls | A system GStreamer install on `PATH` is loading a second copy of `gstreamer-1.0-0.dll`. | `Configure()` already prunes `PATH` — confirm by inspecting the Console: stripped-count is logged. If the count is 0 but you still see the symptom, an external launcher is re-injecting GStreamer after `Configure()`. |
| `TypeLoadException` at first SDK call | Api Compatibility Level is `.NET Framework` instead of `.NET Standard 2.1`. | Set it to `.NET Standard 2.1` (Project Settings → Player → Other Settings → Configuration → Api Compatibility Level). |
| RTSPS / HTTPS streams fail to connect with TLS error | `SSL_CERT_FILE` not pointing at the bundled CA bundle. | `Configure()` sets it when `ca-certificates.crt` is present in the natives folder. A missing CA bundle is logged as a warning — re-stage the runtime via `deploy-unity-natives.ps1`. |
| Editor hangs on "Reloading domain" after Play/Stop | An SDK build older than this release, before the Editor reload guard was added. | Update to the latest SDK — its reload guard stops the GStreamer main-loop thread before each domain reload, so Domain Reload is safe. You do not need to disable it. |

## Frequently Asked Questions

### Can I use IL2CPP on Windows?

Yes — it compiles and runs. Mono is the default and is what the package's CI build matrix exercises. Switch to IL2CPP only if you have a project-wide reason (other plugins that require it, smaller deployment surface). The same `link.xml` that ships with the package preserves the SDK's managed types from IL2CPP stripping on every backend.

### Does Windows 11 ARM64 work?

Not from this `.unitypackage`. The bundled native runtime is x86\_64 only — running it under x64 emulation on ARM64 is unsupported. An ARM64 native build is not part of the current Unity package.

### Does the SDK need administrator rights?

No. Everything runs from the project folder / player `_Data` folder. The runtime touches no registry keys, installs no global drivers, and writes only to `Application.persistentDataPath` (for logs / temp files when enabled).

## See also

- [Install the Media Blocks SDK in Unity](../../../install/unity/) — package setup
- [Bootstrap and lifecycle](../bootstrap/) — how `Configure()` brings up the Windows runtime
- [Play a media file in Unity](../simple-player/) — the `SimplePlayer` sample
- [View an RTSP camera in Unity](../rtsp-viewer/) — the `RTSPViewer` sample
- [Troubleshooting](../troubleshooting/) — common runtime errors across platforms

---END OF PAGE---


## Video Effects SDK — Add and Configure Effects in .NET C#
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-effects/add/
**Description:** Add and configure video effects in .NET SDK environments for capture, playback, and editing with parameter management and practical C# examples.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS, C#
**API:** VideoEffectLightness

# Implementing Video Effects in .NET SDK Applications

Video effects can significantly enhance the visual quality and user experience of your media applications. This guide demonstrates how to properly implement and manage video effects across various .NET SDK environments.

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Implementation Overview

When working with video processing in .NET applications, you'll often need to apply various effects to enhance or modify the video content. The following sections explain the process step-by-step.

## C# Code Implementation

### Example: Lightness Effect in Media Player SDK

This detailed example demonstrates how to implement a lightness effect, which is a common video enhancement technique. The same implementation approach applies to Video Edit SDK .Net and Video Capture SDK .Net environments.

### Step 1: Define the Effect Interface

First, you need to declare the appropriate interface for your desired effect:

```
IVideoEffectLightness lightness;
```

### Step 2: Retrieve or Create the Effect Instance

Each effect requires a unique identifier. The following code checks if the effect already exists in the SDK control:

```
var effect = MediaPlayer1.Video_Effects_Get("Lightness");
```

### Step 3: Add the Effect if Not Present

If the effect doesn't exist yet, you'll need to instantiate and add it to your video processing pipeline:

```
if (effect == null)
{
    lightness = new VideoEffectLightness(true, 100);
    MediaPlayer1.Video_Effects_Add(lightness);
}
```

### Step 4: Update Existing Effect Parameters

If the effect is already present, you can modify its parameters to achieve the desired visual outcome:

```
else
{
   lightness = effect as IVideoEffectLightness;
   if (lightness != null)
   {
      lightness.Value = 100;
   }
}
```

## Important Implementation Notes

For proper functionality, ensure you enable effects processing before starting video playback or capture:

- Set the `Video_Effects_Enabled` property to `true` before calling any `Play()` or `Start()` methods
- Effects will not be applied if this property is not enabled
- Changing effect parameters during playback will update the visual output in real-time

## System Requirements

To successfully implement video effects in your .NET application, you'll need:

- SDK redistributable packages properly installed
- Sufficient system resources for real-time video processing
- Appropriate .NET framework version

## Additional Resources

For more advanced implementations and examples of video effect techniques:

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) repository for additional code samples and complete projects.

---END OF PAGE---


## Video Effects SDK Reference — Filters, Overlays, and More
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-effects/effects-reference/
**Description:** Comprehensive reference guide for all video effects available in VisioForge .NET SDKs including Classic (Windows-only) and Cross-platform effects.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaPlayerCoreX, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Playback, Editing, Effects, Decklink, NDI, GIF, C#
**API:** VideoEffect, VideoEffectGrayscale, GPUVideoEffect, GrayscaleVideoEffect, GaussianBlurVideoEffect

# Complete Video Effects Reference

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction

This document provides a comprehensive reference for all video effects available in VisioForge .NET SDKs. Effects are available in two distinct implementations:

### Effect Types by SDK Engine

#### Classic Effects (Windows Only)

- **Available in**: VideoCaptureCore, MediaPlayerCore, VideoEditCore
- **Platform**: Windows only (.NET Framework 4.7.2+ and .NET 6-10)
- **Types**:
- `VideoEffect*` - CPU-based processing
- `GPUVideoEffect*` - GPU-accelerated (DirectX)
- `Maxine*` - NVIDIA AI-powered effects (RTX GPUs)
- **Location**: `VisioForge.Core.Types.VideoEffects` namespace

#### Cross-Platform Effects

- **Available in**: VideoCaptureCoreX, MediaPlayerCoreX, VideoEditCoreX, Media Blocks SDK
- **Platform**: Windows, Linux, macOS, Android, iOS
- **Types**:
- `*VideoEffect` classes in `VisioForge.Core.Types.X.VideoEffects`
- Cross-platform processing for universal compatibility
- **Location**: `VisioForge.Core.Types.X.VideoEffects` namespace

> **Important**: When choosing effects, select based on your target SDK and platform requirements. Cross-platform effects provide broader compatibility, while Classic effects offer Windows-specific optimizations and DirectX GPU acceleration.

## Effect Categories

The following sections list all available effects. Each effect includes SDK availability markers: - 🪟 **Classic** = VideoCaptureCore/MediaPlayerCore/VideoEditCore (Windows only) - 🌍 **Cross-platform** = VideoCaptureCoreX/MediaPlayerCoreX/VideoEditCoreX/Media Blocks (Cross-platform)

### Color Adjustment Effects

#### Brightness and Darkness

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectDarkness | 🪟 Classic | Adjusts overall darkness/lightness. Values above 128 darken, values below lighten the image. |
| GPUVideoEffectDarkness | 🪟 Classic (GPU) | GPU-accelerated darkness adjustment. |
| GPUVideoEffectBrightness | 🪟 Classic (GPU) | GPU-accelerated brightness adjustment. Adds or subtracts uniform values to RGB components. |
| VideoEffectLightness | 🪟 Classic | Adjusts lightness in HSL color space, preserving hue and saturation relationships. |
| VideoBalanceVideoEffect | 🌍 Cross-platform | Cross-platform brightness, contrast, saturation, and hue adjustment. |

#### Contrast and Color

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectContrast | 🪟 Classic | Adjusts the difference between light and dark areas. Supports animated transitions. |
| GPUVideoEffectContrast | 🪟 Classic (GPU) | GPU-accelerated contrast adjustment. |
| VideoEffectSaturation | 🪟 Classic | Controls color intensity from grayscale (0) to full saturation (255). |
| GPUVideoEffectSaturation | 🪟 Classic (GPU) | GPU-accelerated saturation adjustment. |
| VideoBalanceVideoEffect | 🌍 Cross-platform | Provides contrast and saturation control (cross-platform). |
| GammaVideoEffect | 🌍 Cross-platform | Gamma correction for brightness curve adjustment. |

### Color Filters and Conversions

#### Grayscale and Monochrome

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectGrayscale | 🪟 Classic | Converts color video to black and white using perceptual luminance weights. |
| GPUVideoEffectGrayscale | 🪟 Classic (GPU) | GPU-accelerated grayscale conversion. |
| GPUVideoEffectMonoChrome | 🪟 Classic (GPU) | Creates monochrome effect with customizable tint color. |
| GrayscaleVideoEffect | 🌍 Cross-platform | Cross-platform grayscale conversion using videobalance element. |
| ColorEffectsVideoEffect | 🌍 Cross-platform | Various color presets including monochrome, sepia, heat map, and more. |

#### Color Inversion

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectInvert | 🪟 Classic | Inverts all RGB color values, creating photographic negative effect. |
| GPUVideoEffectInvert | 🪟 Classic (GPU) | GPU-accelerated color inversion. |

#### Color Channel Filters

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectRed | 🪟 Classic | Isolates red color channel, removing green and blue components. |
| VideoEffectGreen | 🪟 Classic | Isolates green color channel, removing red and blue components. |
| VideoEffectBlue | 🪟 Classic | Isolates blue color channel, removing red and green components. |
| VideoEffectFilterRed | 🪟 Classic | Applies red color filter effect with adjustable intensity. |
| VideoEffectFilterGreen | 🪟 Classic | Applies green color filter effect with adjustable intensity. |
| VideoEffectFilterBlue | 🪟 Classic | Applies blue color filter effect with adjustable intensity. |

#### Color Grading

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectLUT | 🪟 Classic | Look-up table color grading using 3D LUT files for professional color correction. |
| LUTVideoEffect | 🌍 Cross-platform | Cross-platform 3D LUT support with multiple interpolation modes. |
| VideoEffectPosterize | 🪟 Classic | Reduces number of colors, creating poster-like effect with discrete color levels. |
| VideoEffectSolorize | 🪟 Classic | Solarization effect that inverts colors above a threshold brightness level. |

### Image Enhancement

#### Sharpening and Blur

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectSharpen | 🪟 Classic | Enhances edges and fine details for crisper images. |
| GPUVideoEffectSharpen | 🪟 Classic (GPU) | GPU-accelerated sharpening. |
| VideoEffectBlur | 🪟 Classic | Applies smoothing filter, softening image and reducing detail. |
| GPUVideoEffectBlur | 🪟 Classic (GPU) | GPU-accelerated blur. |
| GPUVideoEffectDirectionalBlur | 🪟 Classic (GPU) | Blur with directional component for motion blur effects. |
| VideoEffectSmooth | 🪟 Classic | Softening filter for noise reduction and gentle image smoothing. |
| GaussianBlurVideoEffect | 🌍 Cross-platform | Cross-platform Gaussian blur with adjustable sigma. |
| SmoothVideoEffect | 🌍 Cross-platform | Cross-platform smoothing/softening filter. |

#### Noise Reduction

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectDenoiseAdaptive | 🪟 Classic | Adaptive noise reduction that preserves edges while removing noise. |
| VideoEffectDenoiseCAST | 🪟 Classic | CAST (Cellular Automata-based Spatio-Temporal) denoise algorithm with multiple parameters. |
| VideoEffectDenoiseMosquito | 🪟 Classic | Reduces mosquito noise artifacts common in compressed video. |
| GPUVideoEffectDenoise | 🪟 Classic (GPU) | GPU-accelerated general noise reduction. |

### Geometric Transformations

#### Rotation and Flipping

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectRotate | 🪟 Classic | Rotates video by any angle with options for stretching or preserving full frame. |
| FlipRotateVideoEffect | 🌍 Cross-platform | Cross-platform flip and rotation (90°, 180°, 270°, horizontal/vertical flip). |
| VideoEffectFlipHorizontal | 🪟 Classic | Flips video horizontally (left-right mirror). |
| VideoEffectFlipVertical | 🪟 Classic | Flips video vertically (top-bottom mirror). |
| VideoEffectMirrorHorizontal | 🪟 Classic | Creates horizontal mirror effect at center of frame. |
| VideoEffectMirrorVertical | 🪟 Classic | Creates vertical mirror effect at center of frame. |

#### Scaling and Transformation

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectZoom | 🪟 Classic | Zooms into specific region of video with pan and scale control. |
| VideoEffectPan | 🪟 Classic | Pan and crop effect for selecting specific video region. |
| ResizeVideoEffect | 🌍 Cross-platform | Cross-platform video scaling/resizing with multiple interpolation methods. |
| CropVideoEffect | 🌍 Cross-platform | Cross-platform video cropping to specific dimensions. |
| AspectRatioCropVideoEffect | 🌍 Cross-platform | Automatically crops video to target aspect ratio. |
| BoxVideoEffect | 🌍 Cross-platform | Adds letterboxing/pillarboxing with custom fill color. |

### Artistic and Stylistic Effects

#### Classic Film Effects

| Effect | SDK | Description |
| --- | --- | --- |
| GPUVideoEffectOldMovie | 🪟 Classic (GPU) | Vintage film effect with grain, scratches, and sepia tone. |
| GPUVideoEffectNightVision | 🪟 Classic (GPU) | Night vision camera simulation with green phosphor look. |
| AgingVideoEffect | 🌍 Cross-platform | Cross-platform aging/vintage film effect. |
| OpticalAnimationBWVideoEffect | 🌍 Cross-platform | Optical illusion animation effects in black and white. |

#### Edge and Texture Effects

| Effect | SDK | Description |
| --- | --- | --- |
| GPUVideoEffectEmboss | 🪟 Classic (GPU) | Creates embossed or raised relief effect highlighting edges. |
| GPUVideoEffectContour | 🪟 Classic (GPU) | Edge detection and contour enhancement. |
| GPUVideoEffectPixelate | 🪟 Classic (GPU) | Pixelation effect with adjustable block size. |
| VideoEffectMosaic | 🪟 Classic | Creates mosaic pattern with adjustable tile size. |
| EdgeVideoEffect | 🌍 Cross-platform | Cross-platform edge detection filter. |
| DiceVideoEffect | 🌍 Cross-platform | Creates dice/cubist effect by dividing image into rotated squares. |

#### Special Distortion Effects (Cross-platform only)

The following artistic effects are available exclusively in the cross-platform implementation:

| Effect | Description |
| --- | --- |
| FishEyeVideoEffect | Fish-eye lens distortion effect. |
| GLTwirlVideoEffect | Twirl/swirl distortion effect (OpenGL). |
| GLBulgeVideoEffect | Bulge/magnification distortion (OpenGL). |
| StretchVideoEffect | Stretch distortion effect. |
| GLLightTunnelVideoEffect | Tunnel perspective effect (OpenGL). |
| SquareVideoEffect | Square warping effect. |
| CircleVideoEffect | Circular warping effect. |
| KaleidoscopeVideoEffect | Kaleidoscope mirror effect. |
| MarbleVideoEffect | Marble texture effect. |
| Pseudo3DVideoEffect | Pseudo 3D stereo effect. |
| QuarkVideoEffect | Quark particle effect. |
| RippleVideoEffect | Water ripple effect. |
| WaterRippleVideoEffect | Enhanced water ripple with multiple modes. |
| WarpVideoEffect | General warp distortion effect. |
| MovingBlurVideoEffect | Motion blur with directional control. |
| MovingEchoVideoEffect | Motion echo/trail effect. |
| MovingZoomEchoVideoEffect | Combined zoom and echo effect. |
| SMPTEVideoEffect | SMPTE transition effects (wipes, fades). |
| SMPTEAlphaVideoEffect | SMPTE transitions with alpha channel. |

#### Special Effects

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectColorNoise | 🪟 Classic | Adds random color noise for grain or interference effects. |
| VideoEffectMonoNoise | 🪟 Classic | Adds monochrome (grayscale) noise. |
| VideoEffectSpray | 🪟 Classic | Spray paint or pointillist effect. |
| VideoEffectShakeDown | 🪟 Classic | Vertical shake effect for impact or earthquake simulation. |

### Deinterlacing

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectDeinterlaceBlend | 🪟 Classic | Blends interlaced fields for progressive output. |
| GPUVideoEffectDeinterlaceBlend | 🪟 Classic (GPU) | GPU-accelerated deinterlace blend. |
| VideoEffectDeinterlaceCAVT | 🪟 Classic | Content Adaptive Vertical Temporal deinterlacing. |
| VideoEffectDeinterlaceTriangle | 🪟 Classic | Triangle interpolation deinterlacing method. |
| DeinterlaceVideoEffect | 🌍 Cross-platform | Cross-platform deinterlacing with multiple methods (linear, greedy, vfir, yadif, etc.). |
| AutoDeinterlaceSettings | 🌍 Cross-platform | Automatic deinterlacing when interlaced content is detected. |
| InterlaceSettings | 🌍 Cross-platform | Creates interlaced output from progressive content. |

### Transition Effects

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectFadeIn | 🪟 Classic | Gradual fade from black to video content. |
| VideoEffectFadeOut | 🪟 Classic | Gradual fade from video content to black. |

### Overlays and Graphics

#### Text Overlays

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectTextLogo | 🪟 Classic | Flexible text overlay with extensive customization including fonts, colors, rotation, effects, and animated text. |
| VideoEffectScrollingTextLogo | 🪟 Classic | Scrolling text banner with direction and speed control. |
| TextOverlayVideoEffect | 🌍 Cross-platform | Cross-platform text overlay with advanced typography control. Supports timestamps, system time, and dynamic text. |
| OverlayManagerText | 🌍 Cross-platform | Advanced text overlay with shadows, gradients, and animations. A `TextProvider` callback can rebuild the text on every frame, and `StartTime`/`EndTime` bound when it is drawn. |
| OverlayManagerScrollingText | 🌍 Cross-platform | Scrolling text with full control over speed, direction, and appearance. |
| OverlayManagerDateTime | 🌍 Cross-platform | Date/time overlay with customizable formatting. |

See: [Text Overlay Guide](../text-overlay/)

#### Image Overlays

| Effect | SDK | Description |
| --- | --- | --- |
| VideoEffectImageLogo | 🪟 Classic | Image overlay supporting PNG, JPG, BMP, animated GIF, with transparency and positioning control. |
| ImageOverlayVideoEffect | 🌍 Cross-platform | Cross-platform image overlay with positioning and alpha blending. |
| ImageOverlayCairoVideoEffect | 🌍 Cross-platform | Advanced image overlay using Cairo graphics with transformations. |
| OverlayManagerImage | 🌍 Cross-platform | Professional image overlay with animations, transitions, and effects. |
| OverlayManagerGIF | 🌍 Cross-platform | Animated GIF overlay support. |
| SVGOverlayVideoEffect | 🌍 Cross-platform | SVG vector graphics overlay. |

See: [Image Overlay Guide](../image-overlay/)

#### Advanced Overlay Features (Cross-platform only)

| Feature | Description |
| --- | --- |
| OverlayManagerVideo | Video-in-video overlay (picture-in-picture). |
| OverlayManagerDecklinkVideo | Blackmagic Decklink video source overlay. |
| OverlayManagerNDIVideo | NDI video source overlay. |
| OverlayManagerGroup | Group multiple overlays together for synchronized control. |
| OverlayManagerPan | Pan overlay animation. |
| OverlayManagerZoom | Zoom overlay animation. |
| OverlayManagerFade | Fade in/out overlay animation. |
| OverlayManagerSqueezeback | Squeezeback effect (shrink main video to show background). |
| OverlayManagerBackgroundImage | Background image layer. |
| OverlayManagerBackgroundRectangle | Colored rectangle background. |
| OverlayManagerBackgroundSquare | Colored square background. |
| OverlayManagerBackgroundStar | Star-shaped background. |
| OverlayManagerBackgroundTriangle | Triangle-shaped background. |
| OverlayManagerCircle | Circular shape overlay. |
| OverlayManagerLine | Line drawing overlay. |
| OverlayManagerRectangle | Rectangle shape overlay. |
| OverlayManagerStar | Star shape overlay. |
| OverlayManagerTriangle | Triangle shape overlay. |

### Chroma Key (Cross-platform)

| Effect | Description |
| --- | --- |
| ChromaKeySettingsX | Green screen / blue screen keying for background removal (use with `MediaBlocksPipeline` + chroma-key filter block). |

### 360° Video and VR (Classic only)

| Effect | SDK | Description |
| --- | --- | --- |
| GPUVideoEffectEquirectangular360 | 🪟 Classic (GPU) | Processes equirectangular 360° video format. |
| GPUVideoEffectEquiangularCubemap360 | 🪟 Classic (GPU) | Converts between equiangular and cubemap projections for 360° video. |
| GPUVideoEffectVR360Base | 🪟 Classic (GPU) | Base class for VR 360° video effects. |

### AI-Powered Effects (NVIDIA Maxine - Classic only)

Requires NVIDIA RTX GPU with Maxine SDK support. For setup, code samples, and effect modes, see the [NVIDIA Maxine AI Video Enhancement](../nvidia-maxine/) guide.

#### Video Enhancement

| Effect | Description |
| --- | --- |
| MaxineDenoiseVideoEffect | AI-powered noise reduction that intelligently preserves details. |
| MaxineArtifactReductionVideoEffect | Reduces compression artifacts and video degradation using AI. |
| MaxineSuperResSettings | Settings POCO for AI super-resolution upscaling (wire into the Maxine effect pipeline). |

#### Content Effects

| Effect | Description |
| --- | --- |
| MaxineAIGSVideoEffect | AI-powered green screen/background removal without requiring actual green screen. |
| MaxineUpscaleSettings | Settings POCO for AI upscaling (wire into the Maxine effect pipeline). |

#### Special Effects

- **VideoEffectColorNoise** - Adds random color noise for grain or interference effects.
- **VideoEffectMonoNoise** - Adds monochrome (grayscale) noise.
- **VideoEffectSpray** - Spray paint or pointillist effect.
- **VideoEffectShakeDown** - Vertical shake effect for impact or earthquake simulation.

### Deinterlacing

- **VideoEffectDeinterlaceBlend** / **GPUVideoEffectDeinterlaceBlend** - Blends interlaced fields for progressive output.
- **VideoEffectDeinterlaceCAVT** - Content Adaptive Vertical Temporal deinterlacing.
- **VideoEffectDeinterlaceTriangle** - Triangle interpolation deinterlacing method.

### Transition Effects

#### Fade Effects

- **VideoEffectFadeIn** - Gradual fade from black to video content.
- **VideoEffectFadeOut** - Gradual fade from video content to black.

### Overlays and Graphics

#### Text Overlays

- **VideoEffectTextLogo** - Flexible text overlay with extensive customization including fonts, colors, rotation, effects, and animated text.
- **VideoEffectScrollingTextLogo** - Scrolling text banner with direction and speed control.

See: [Text Overlay Guide](../text-overlay/)

#### Image Overlays

- **VideoEffectImageLogo** - Image overlay supporting PNG, JPG, BMP, animated GIF, with transparency and positioning control.

See: [Image Overlay Guide](../image-overlay/)

### 360° Video and VR

- **GPUVideoEffectEquirectangular360** - Processes equirectangular 360° video format.
- **GPUVideoEffectEquiangularCubemap360** - Converts between equiangular and cubemap projections for 360° video.
- **GPUVideoEffectVR360Base** - Base class for VR 360° video effects.

### AI-Powered Effects (NVIDIA Maxine)

Requires NVIDIA RTX GPU with Maxine SDK support.

#### Video Enhancement

- **MaxineDenoiseVideoEffect** - AI-powered noise reduction that intelligently preserves details.
- **MaxineArtifactReductionVideoEffect** - Reduces compression artifacts and video degradation using AI.
- **MaxineSuperResSettings** - Settings POCO for AI super-resolution upscaling.

#### Content Effects

- **MaxineAIGSVideoEffect** - AI-powered green screen/background removal without requiring actual green screen.
- **MaxineUpscaleSettings** - Settings POCO for AI upscaling.

## Effect Parameters

### Common Parameters

All video effects support these standard parameters:

- **Enabled** - Whether the effect is active (can be toggled on/off)
- **Name** - Identifier for retrieving specific effect instances
- **StartTime** - When effect begins (TimeSpan.Zero = from start)
- **StopTime** - When effect ends (TimeSpan.Zero = until end)

### Classic Effects Value Ranges

Most Classic adjustment effects use 0-255 value ranges where: - **128** typically represents neutral/no change - **0** represents minimum (often darkest/weakest) - **255** represents maximum (often brightest/strongest)

### Animated Transitions (Classic Effects)

Many Classic effects support **ValueStop** parameter for smooth animation: - Set **Value** for starting value - Set **ValueStop** for ending value - Define **StartTime** and **StopTime** for animation duration

### Cross-platform Effects Parameters

Cross-platform effects use multimedia element properties with varying ranges. Refer to individual effect documentation for specific parameter details.

## SDK Comparison

### Classic Effects (VideoCaptureCore/MediaPlayerCore)

- **Platform**: Windows only (.NET Framework 4.7.2+ and .NET 6-10)
- **Processing Types**:
- CPU-based: `VideoEffect*` classes
- GPU-accelerated: `GPUVideoEffect*` classes (DirectX)
- AI-powered: `Maxine*` classes (NVIDIA RTX required)
- **Performance**: Optimized for Windows, DirectX GPU acceleration
- **Compatibility**: Desktop Windows only
- **Namespace**: `VisioForge.Core.Types.VideoEffects`

### Cross-platform Effects (VideoCaptureCoreX/Media Blocks)

- **Platform**: Cross-platform (Windows, Linux, macOS, Android, iOS)
- **Processing**: Cross-platform, hardware acceleration through multimedia plugins
- **Performance**: Good performance on all platforms, GPU acceleration varies by platform
- **Compatibility**: Universal - desktop and mobile
- **Namespace**: `VisioForge.Core.Types.X.VideoEffects`
- **Additional Features**:
- More artistic effects (distortions, warps)
- Advanced overlay system (OverlayManager)
- Chroma key / motion detection
- Better suited for mobile platforms

## Usage Examples

### Classic Effect Application

```
// CPU-based effect
var effect = new VideoEffectGrayscale(
    enabled: true,
    name: "BWEffect"
);
capture.Video_Effects_Add(effect);

// GPU-accelerated effect
var gpuEffect = new GPUVideoEffectBrightness(
    enabled: true,
    value: 180,
    name: "Brighten"
);
capture.Video_Effects_Add(gpuEffect);
```

### Cross-platform Effect Application

```
// Cross-platform grayscale
var grayscale = new GrayscaleVideoEffect("bw_effect");
await videoCapture.Video_Effects_AddOrUpdateAsync(grayscale);

// Cross-platform text overlay
var textOverlay = new TextOverlayVideoEffect
{
    Text = "Hello World",
    Font = new FontSettings("Arial", "Bold", 24),
    Color = SKColors.Yellow,
    HorizontalAlignment = TextOverlayHAlign.Left,
    VerticalAlignment = TextOverlayVAlign.Top
};
await videoCapture.Video_Effects_AddOrUpdateAsync(textOverlay);
```

### Animated Effect (Classic)

```
// Fade to black over 3 seconds
var fade = new VideoEffectDarkness(
    enabled: true,
    value: 128,        // Start normal
    valueStop: 255,    // End at maximum darkness
    name: "FadeOut",
    startTime: TimeSpan.FromSeconds(57),
    stopTime: TimeSpan.FromSeconds(60)
);
capture.Video_Effects_Add(fade);
```

### Time-Limited Effect (Both)

```
// Classic: Apply effect only during specific time range
var flashback = new VideoEffectGrayscale(
    enabled: true,
    name: "Flashback",
    startTime: TimeSpan.FromMinutes(2),
    stopTime: TimeSpan.FromMinutes(2.5)
);
player.Video_Effects_Add(flashback);

// Cross-platform: Time-limited effect
// Ctor: GaussianBlurVideoEffect(double sigma, string name = "gaussian_blur")
var blur = new GaussianBlurVideoEffect(5.0, "blur")
{
    StartTime = TimeSpan.FromSeconds(10),
    StopTime = TimeSpan.FromSeconds(15)
};
await player.Video_Effects_AddOrUpdateAsync(blur);
```

## Performance Considerations

### Classic Effects

1. **GPU Effects**: Best performance for high-resolution video on Windows
2. **Effect Stacking**: Minimize simultaneous effects for better performance
3. **Animated Effects**: Smooth animations add minimal overhead
4. **AI Effects**: Most resource-intensive, use on RTX GPUs
5. **Resolution Impact**: Higher resolutions significantly increase processing requirements

### Cross-platform Effects

1. **Hardware Acceleration**: Varies by platform and multimedia framework build
2. **Cross-Platform**: Generally good performance on all supported platforms
3. **Mobile Optimization**: Better suited for mobile than Classic effects
4. **Overlay System**: Efficient multi-overlay rendering
5. **Plugin Availability**: Some effects require specific multimedia plugins

## Platform Availability

### Classic Effects

| Platform | CPU Effects | GPU Effects | AI Maxine |
| --- | --- | --- | --- |
| Windows Desktop | ✅ Full | ✅ Full | ✅ RTX GPUs |
| Linux | ❌ | ❌ | ❌ |
| macOS | ❌ | ❌ | ❌ |
| Android | ❌ | ❌ | ❌ |
| iOS | ❌ | ❌ | ❌ |

### Cross-platform Effects

| Platform | Support | Hardware Acceleration |
| --- | --- | --- |
| Windows | ✅ Full | ✅ Via multimedia plugins |
| Linux | ✅ Full | ✅ VA-API, VDPAU, etc. |
| macOS | ✅ Full | ✅ VideoToolbox |
| Android | ✅ Full | ✅ Hardware codecs |
| iOS | ✅ Full | ✅ VideoToolbox |

## Choosing the Right Effect Type

### Use Classic Effects When:

- ✅ Targeting Windows desktop only
- ✅ Need maximum performance on Windows
- ✅ Using DirectX GPU acceleration
- ✅ Need NVIDIA Maxine AI features
- ✅ Working with VideoCaptureCore/MediaPlayerCore engines

### Use Cross-platform Effects When:

- ✅ Need cross-platform support
- ✅ Targeting mobile platforms (Android/iOS)
- ✅ Targeting Linux or macOS
- ✅ Using VideoCaptureCoreX/Media Blocks
- ✅ Need advanced overlay features
- ✅ Need chroma key or motion detection

## Additional Resources

- [Text Overlay Guide](../text-overlay/)
- [Image Overlay Guide](../image-overlay/)
- [Video Sample Grabber](../video-sample-grabber/)
- [How to Add Effects](../add/)

---

Visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) for complete code samples and implementation examples.

---END OF PAGE---


## Image Overlay on Video in .NET — PNG, GIF, and Bitmap
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-effects/image-overlay/
**Description:** Overlay images, animated GIFs, and transparent PNGs on video streams in .NET for watermarks, logos, and visual enhancements with transparency.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaPlayerCore, VideoCaptureCore, VideoEditCore, Windows, Capture, Playback, Editing, GIF, C#
**API:** VideoEffectImageLogo

# Image overlay

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

[VideoCaptureCore](#) [MediaPlayerCore](#) [VideoEditCore](#)

## Introduction

This example demonstrates how to overlay an image on a video stream.

JPG, PNG, BMP, and GIF images are supported.

## Sample code

Most simple image overlay with image added from a file with custom position:

```
 var effect = new VideoEffectImageLogo(true, "imageoverlay");
 effect.Filename = @"logo.png";
 effect.Left = 100;
 effect.Top = 100;

 VideoCapture1.Video_Effects_Add(effect);
```

### Transparent image overlay

SDK fully supports transparency in PNG images. If you want to set a custom transparency level, you can use the `TransparencyLevel` property with a range (0..255).

```
var effect = new VideoEffectImageLogo(true, "imageoverlay");
effect.Filename = @"logo.jpg";

effect.TransparencyLevel = 50;

VideoCapture1.Video_Effects_Add(effect);
```

### Animated GIF overlay

You can overlay an animated GIF image on a video stream. The SDK will play the GIF animation in the overlay.

```
var effect = new VideoEffectImageLogo(true, "imageoverlay");
effect.Filename = @"animated.gif";

effect.Animated = true;
effect.AnimationEnabled = true;

VideoCapture1.Video_Effects_Add(effect);
```

### Image overlay from `System.Drawing.Bitmap`

You can overlay an image from a `System.Drawing.Bitmap` object.

```
var effect = new VideoEffectImageLogo(true, "imageoverlay");
effect.MemoryBitmap = new Bitmap("logo.jpg");
VideoCapture1.Video_Effects_Add(effect);
```

### Image overlay from RGB/RGBA byte array

You can overlay an image from RGB/RGBA data.

```
// add image logo
var effect = new VideoEffectImageLogo(true, "imageoverlay");

// load image from JPG file
var bitmap = new Bitmap("logo.jpg");

// lock bitmap data and save to byte data (IntPtr)
var bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
var pixels = Marshal.AllocCoTaskMem(bitmapData.Stride * bitmapData.Height);
NativeAPI.CopyMemory(pixels, bitmapData.Scan0, bitmapData.Stride * bitmapData.Height);
bitmap.UnlockBits(bitmapData);

// set data to effect
effect.Bitmap = pixels;

// set bitmap properties
effect.BitmapWidth = bitmap.Width;
effect.BitmapHeight = bitmap.Height;
effect.BitmapDepth = 3; // RGB24

// free bitmap
bitmap.Dispose();

// add effect
VideoCapture1.Video_Effects_Add(effect);
```

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Video Effects SDK for .NET - Overlays and Processing
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-effects/
**Description:** Implement professional video effects, text/image overlays, and custom video processing with powerful visual enhancement tools for .NET apps.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Playback, Editing
**API:** VideoEffect, GPUVideoEffect, VideoBalanceVideoEffect, ColorEffectsVideoEffect, GrayscaleVideoEffect

# Video Effects and Processing for .Net Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction

Our .Net SDKs provide developers with two distinct implementations of video effects to match your platform and performance requirements:

### Classic Effects (Windows Only)

Available in **VideoCaptureCore**, **MediaPlayerCore**, and **VideoEditCore**: - CPU-based effects (`VideoEffect*`) - GPU-accelerated effects (`GPUVideoEffect*`) using DirectX - AI-powered effects (`Maxine*`) using NVIDIA technology - Windows-only, optimized for desktop performance

### Cross-Platform Effects

Available in **VideoCaptureCoreX**, **MediaPlayerCoreX**, **VideoEditCoreX**, and **Media Blocks SDK**: - Cross-platform implementation (`*VideoEffect` classes) - Works on Windows, Linux, macOS, Android, and iOS - Hardware acceleration through platform-specific multimedia plugins - Extended overlay system and advanced features - Better suited for mobile and cross-platform deployment

## Complete Effects Reference

**[View Complete Video Effects Reference →](effects-reference/)**

Our comprehensive effects reference provides detailed information on all 100+ available video effects across both implementations: - **Classic effects** for Windows-only applications - **Cross-platform effects** for universal compatibility - Effect parameters, usage examples, and SDK availability - Platform-specific features and capabilities

## Available Video Effect Categories

The following effect categories are available in both Classic and Cross-Platform implementations (where applicable):

### Color and Image Adjustment

- **Brightness, Darkness, Contrast** - Control luminance and tonal range
- Classic: `VideoEffect*` / `GPUVideoEffect*`
- Cross-platform: `VideoBalanceVideoEffect`, `GammaVideoEffect`
- **Saturation and Color Grading** - Adjust color intensity and apply color corrections
- Classic: `VideoEffectSaturation` / `GPUVideoEffectSaturation`
- Cross-platform: `VideoBalanceVideoEffect`, `ColorEffectsVideoEffect`, `LUTVideoEffect`
- **Lightness** - HSL-based brightness adjustment preserving color relationships
- Classic: `VideoEffectLightness`
- **Color Filters** - Isolate or enhance specific color channels (Red, Green, Blue)
- Classic: `VideoEffectRed/Green/Blue`, `VideoEffectFilterRed/Green/Blue`

### Creative and Artistic Effects

- **Grayscale and Monochrome** - Black and white conversions with optional tinting
- Classic: `VideoEffectGrayscale` / `GPUVideoEffectGrayscale`
- Cross-platform: `GrayscaleVideoEffect`, `ColorEffectsVideoEffect`
- **Invert and Solarize** - Photographic negative and partial inversion effects
- Classic: `VideoEffectInvert` / `GPUVideoEffectInvert`, `VideoEffectSolorize`
- **Old Movie and Night Vision** - Vintage film and surveillance camera simulations
- Classic: `GPUVideoEffectOldMovie`, `GPUVideoEffectNightVision`
- Cross-platform: `AgingVideoEffect`, `OpticalAnimationBWVideoEffect`
- **Emboss and Contour** - Edge detection and relief effects
- Classic: `GPUVideoEffectEmboss`, `GPUVideoEffectContour`
- Cross-platform: `EdgeVideoEffect`
- **Pixelate and Mosaic** - Stylized block and tile effects
- Classic: `GPUVideoEffectPixelate`, `VideoEffectMosaic`
- Cross-platform: Various distortion effects

### Image Enhancement

- **Sharpening** - Enhance edge definition and fine details
- Classic: `VideoEffectSharpen` / `GPUVideoEffectSharpen`
- **Blur and Smoothing** - Reduce detail, noise, and create soft-focus effects
- Classic: `VideoEffectBlur` / `GPUVideoEffectBlur`, `VideoEffectSmooth`
- Cross-platform: `GaussianBlurVideoEffect`, `SmoothVideoEffect`
- **Noise Reduction** - Adaptive, CAST, and mosquito noise removal algorithms
- Classic: `VideoEffectDenoiseAdaptive/CAST/Mosquito` / `GPUVideoEffectDenoise`
- **Deinterlacing** - Convert interlaced video to progressive (Blend, CAVT, Triangle methods)
- Classic: `VideoEffectDeinterlaceBlend/CAVT/Triangle` / `GPUVideoEffectDeinterlaceBlend`
- Cross-platform: `DeinterlaceVideoEffect`, `AutoDeinterlaceSettings`

### Geometric Transformations

- **Rotation** - Rotate by any angle with stretch or no-crop options
- Classic: `VideoEffectRotate`
- Cross-platform: `FlipRotateVideoEffect`
- **Flip and Mirror** - Horizontal and vertical flipping/mirroring
- Classic: `VideoEffectFlip*`, `VideoEffectMirror*`
- Cross-platform: `FlipRotateVideoEffect`
- **Zoom and Pan** - Focus on specific regions with scaling control
- Classic: `VideoEffectZoom`, `VideoEffectPan`
- Cross-platform: `ResizeVideoEffect`, `CropVideoEffect`, `AspectRatioCropVideoEffect`, `BoxVideoEffect`
- **360° Video Processing** - Equirectangular and cubemap projections for VR video
- Classic: `GPUVideoEffectEquirectangular360`, `GPUVideoEffectEquiangularCubemap360`

### Artistic Distortion Effects (Cross-platform Only)

The cross-platform implementation includes extensive artistic distortion effects not available in Classic:

- **Lens Effects** - Fish-eye, Sphere, Twirl, Bulge, Pinch
- **Pattern Effects** - Kaleidoscope, Marble, Quark, Dice
- **Motion Effects** - Moving Blur, Moving Echo, Moving Zoom Echo
- **Warp Effects** - Ripple, Water Ripple, Warp, Stretch, Tunnel
- **Perspective Effects** - Pseudo3D, Square, Circle, Perspective
- **SMPTE Transitions** - Professional broadcast-style wipes and transitions

### Transition Effects

- **Fade In/Out** - Smooth transitions to/from black
- Classic: `VideoEffectFadeIn`, `VideoEffectFadeOut`
- **Animated Transitions** - Time-based effect value interpolation for dynamic changes
- Classic: Supported via ValueStop parameter
- Cross-platform: Time-based with StartTime/StopTime

## Overlay Capabilities

- [**Text overlay**](text-overlay/) - Add customizable text with control over font, size, color, rotation, and animation
- Classic: `VideoEffectTextLogo`, `VideoEffectScrollingTextLogo`
- Cross-platform: `TextOverlayVideoEffect`, `OverlayManagerText`, `OverlayManagerScrollingText`, `OverlayManagerDateTime`
- `OverlayManagerText.TextProvider` rebuilds the text once per frame, for live readouts such as a sensor value, the frame number or the clock
- [**Image overlay**](image-overlay/) - Incorporate logos, watermarks, and graphic elements with transparency support
- Classic: `VideoEffectImageLogo`
- Cross-platform: `ImageOverlayVideoEffect`, `ImageOverlayCairoVideoEffect`, `OverlayManagerImage`, `OverlayManagerGIF`
- Support for PNG, JPG, BMP, animated GIF formats
- Transparency and alpha channel support
- Positioning and alignment control

### Advanced Overlay Features (Cross-platform Only)

The cross-platform implementation includes an extensive OverlayManager system:

- **Video Overlays** - Picture-in-picture, Decklink, NDI video sources
- **Shape Overlays** - Circles, rectangles, stars, triangles, lines
- **Background Layers** - Images, solid colors, geometric shapes
- **Animations** - Pan, zoom, fade, squeezeback effects
- **Group Management** - Synchronized control of multiple overlays
- **SVG Support** - Vector graphics overlays
- **QR Codes** - Generate and overlay QR codes

## Chroma Key and Motion Detection (Cross-platform Only)

- **ChromaKeySettings** - Green screen / blue screen keying for background removal
- **MotionDetectionProcessor** - Real-time motion detection with configurable sensitivity

## AI-Powered Video Enhancement (Classic Only)

NVIDIA Maxine AI effects (requires NVIDIA RTX GPU with Maxine SDK support):

- **AI Denoise** - Intelligent noise reduction preserving fine details
- **Artifact Reduction** - Remove compression artifacts and video degradation
- **Super Resolution** - AI upscaling for enhanced resolution
- **AI Green Screen** - Background removal without physical green screen
- **Upscaling** - Advanced quality improvement through AI

## Video Processing Features

### Real-time Processing

- Apply effects during video capture, playback, or editing
- Chain multiple effects for complex processing pipelines
- GPU acceleration for real-time high-resolution processing (Classic)
- Hardware acceleration for cross-platform performance (Cross-platform)
- CPU fallback for universal compatibility

### Advanced Processing

- Timeline-based effect application (start/stop times)
- Animated effect transitions (interpolation between values - Classic)
- Dynamic effect control during playback
- [**Video sample grabber**](video-sample-grabber/) - Extract frames and process video data in real-time

## Performance Optimization

### Classic Effects (Windows Only)

- **GPU Effects** (`GPUVideoEffect*`): Best performance for high-resolution video on Windows
- **CPU Effects** (`VideoEffect*`): Universal Windows compatibility, moderate performance
- **AI Effects** (`Maxine*`): State-of-the-art quality, requires NVIDIA RTX GPU
- Use GPU-accelerated effects for real-time HD/4K processing
- DirectX hardware acceleration for optimal Windows performance

### Cross-platform Effects (Cross-Platform)

- **Hardware Acceleration**: Varies by platform via multimedia plugins
- Windows: DirectX, DXVA
- Linux: VA-API, VDPAU, OpenGL
- macOS: VideoToolbox, Metal
- Android/iOS: Hardware codecs
- **Performance**: Generally good across all platforms
- **Mobile Optimization**: Better suited for mobile than Classic effects
- **Overlay System**: Efficient multi-overlay rendering

### Best Practices

- Choose GPU/accelerated effects for high-resolution video
- Consider effect combinations and their performance impact
- Apply time-limited effects where appropriate to reduce processing overhead
- Test performance on target hardware configurations
- Use Cross-platform effects for cross-platform deployment

## Platform Support

### Classic Effects

| Platform | CPU Effects | GPU Effects | AI Maxine | SDK |
| --- | --- | --- | --- | --- |
| Windows Desktop | ✅ Full | ✅ Full | ✅ RTX GPUs | VideoCaptureCore MediaPlayerCore VideoEditCore |
| Linux | ❌ | ❌ | ❌ | N/A |
| macOS | ❌ | ❌ | ❌ | N/A |
| Android | ❌ | ❌ | ❌ | N/A |
| iOS | ❌ | ❌ | ❌ | N/A |

### Cross-platform Effects

| Platform | Support | Hardware Acceleration | SDK |
| --- | --- | --- | --- |
| Windows | ✅ Full | ✅ DirectX, DXVA | VideoCaptureCoreX MediaPlayerCoreX VideoEditCoreX Media Blocks SDK |
| Linux | ✅ Full | ✅ VA-API, VDPAU, OpenGL | ✓ |
| macOS | ✅ Full | ✅ VideoToolbox, Metal | ✓ |
| Android | ✅ Full | ✅ Hardware codecs | ✓ |
| iOS | ✅ Full | ✅ VideoToolbox | ✓ |

## Integration Methods

Our SDKs provide two distinct APIs for video effects integration based on the SDK engine you're using.

### Basic Usage Example (Classic Effects)

```
// Windows-only: CPU-based effect
var bwEffect = new VideoEffectGrayscale(
    enabled: true,
    name: "BlackAndWhite"
);
videoCapture.Video_Effects_Add(bwEffect);

// Windows-only: GPU-accelerated effect
var brighten = new GPUVideoEffectBrightness(
    enabled: true,
    value: 180,
    name: "Brighten"
);
videoCapture.Video_Effects_Add(brighten);
```

### Basic Usage Example (Cross-platform Effects)

```
// Cross-platform: Grayscale effect
var grayscale = new GrayscaleVideoEffect("bw_effect");
await videoCaptureX.Video_Effects_AddOrUpdateAsync(grayscale);

// Cross-platform: Video balance (brightness, contrast, saturation)
var balance = new VideoBalanceVideoEffect("color_adjust")
{
    Brightness = 0.2,    // Range: -1.0 to 1.0
    Contrast = 1.2,      // Range: 0.0 to 2.0
    Saturation = 1.5,    // Range: 0.0 to 2.0
    Hue = 0.0            // Range: -1.0 to 1.0
};
await videoCaptureX.Video_Effects_AddOrUpdateAsync(balance);
```

### Animated Effect Example (Classic)

```
// Fade to black over 3 seconds (Windows only)
var fadeOut = new VideoEffectDarkness(
    enabled: true,
    value: 128,        // Start at normal
    valueStop: 255,    // End at black
    name: "FadeOut",
    startTime: TimeSpan.FromSeconds(57),
    stopTime: TimeSpan.FromSeconds(60)
);
mediaPlayer.Video_Effects_Add(fadeOut);
```

### Time-Limited Effect Example (Cross-platform)

```
// Apply Gaussian blur for specific time range (Cross-platform)
// Ctor: GaussianBlurVideoEffect(double sigma, string name = "gaussian_blur")
var blur = new GaussianBlurVideoEffect(5.0, "scene_blur")
{
    StartTime = TimeSpan.FromSeconds(10),
    StopTime = TimeSpan.FromSeconds(15)
};
await mediaPlayerX.Video_Effects_AddOrUpdateAsync(blur);
```

### Advanced Overlay Example (Cross-platform)

```
// Complex text overlay with a drop shadow (Cross-platform)
var textOverlay = new OverlayManagerText
{
    Text = "Breaking News",
    Font = new FontSettings
    {
        Name = "Arial",
        Size = 48,
        Weight = FontWeight.Bold
    },
    Color = SKColors.Yellow,
    X = 50,
    Y = 100,
    Shadow = new OverlayManagerShadowSettings
    {
        Enabled = true,
        Color = SKColors.Black,
        BlurRadius = 5
    }
};
videoCaptureX.Video_Overlay_Add(textOverlay);
```

## Documentation Resources

- **[Complete Effects Reference](effects-reference/)** - Comprehensive guide to all available effects
- **[Text Overlay Guide](text-overlay/)** - Detailed text overlay implementation
- **[Image Overlay Guide](image-overlay/)** - Image and logo overlay techniques
- **[Video Sample Grabber](video-sample-grabber/)** - Frame extraction and processing
- **[How to Add Effects](add/)** - General guide to applying effects

## More Information

Numerous additional video effects and processing features are available in the SDKs. Please refer to the [Complete Effects Reference](effects-reference/) for detailed information on all effects, or visit the documentation for the specific SDK you are using for implementation examples and API references.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to access more code samples and implementation examples.

---END OF PAGE---


## NVIDIA Maxine AI Video Enhancement & Upscaling in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-effects/nvidia-maxine/
**Description:** Enhance video with NVIDIA Maxine AI in C# .NET — super resolution, upscaling, denoise, and artifact reduction on RTX GPUs with the VisioForge SDK.
**Tags:** Video Capture SDK, Media Player SDK, .NET, NVIDIA Maxine, AI, Super Resolution, Windows
**API:** MaxineDenoiseVideoEffect, MaxineArtifactReductionVideoEffect, MaxineSuperResSettings, MaxineUpscaleSettings

# NVIDIA Maxine AI Video Enhancement in C# .NET

NVIDIA Maxine brings GPU-accelerated, AI-powered video enhancement to the VisioForge classic engines (`VideoCaptureCore` and `MediaPlayerCore`). The effects run on the NVIDIA Maxine SDK and require an **NVIDIA RTX GPU** (Tensor cores). They are Windows-only.

| Effect | API type | Applied via |
| --- | --- | --- |
| Denoise | `MaxineDenoiseVideoEffect` | `Video_Effects_Add` |
| Artifact reduction | `MaxineArtifactReductionVideoEffect` | `Video_Effects_Add` |
| Super resolution | `MaxineSuperResSettings` | `Video_Resize` |
| Upscale | `MaxineUpscaleSettings` | `Video_Resize` |

## Requirements

- NVIDIA RTX GPU (GeForce RTX 2060 or higher) with current drivers.
- The NVIDIA Maxine SDK with its **models directory** on disk — most constructors take the path to it.
- Windows 10/11. These effects target the DirectShow-backed `VideoCaptureCore` / `MediaPlayerCore` engines.

The denoise/artifact effect classes live in `VisioForge.Core.Types.VideoEffects` (denoise in `VisioForge.Core.Types.VideoEffects.NvidiaMaxine`); the super-resolution and upscale settings live in `VisioForge.Core.Types`.

Enable the effect pipeline

Filter effects added with `Video_Effects_Add` only run when the effect pipeline is enabled. Set `Video_Effects_Enabled = true` once before adding effects — it is `false` by default.

## Denoise

Removes camera/sensor noise while preserving detail. `Strength` ranges 0.0–1.0 (default 0.7).

```
using VisioForge.Core.Types.VideoEffects.NvidiaMaxine;

VideoCapture1.Video_Effects_Enabled = true; // effects are off by default

var denoise = new MaxineDenoiseVideoEffect(modelsDir, strength: 0.7f);
VideoCapture1.Video_Effects_Add(denoise);
```

## Artifact reduction

Removes compression artifacts (blocking, ringing, banding). Pick the mode to match the source bitrate.

```
using VisioForge.Core.Types.VideoEffects;

VideoCapture1.Video_Effects_Enabled = true;

var artifactReduction = new MaxineArtifactReductionVideoEffect(
    modelsDir,
    mode: MaxineArtifactReductionEffectMode.LowBitrate);
VideoCapture1.Video_Effects_Add(artifactReduction);
```

| `MaxineArtifactReductionEffectMode` | Use for |
| --- | --- |
| `HighBitrate` | 10+ Mbps sources; gentler, preserves gradients and fine detail. |
| `LowBitrate` | Below ~5 Mbps; aggressive removal of strong artifacts (default). |

## Super resolution

AI upscaling to a target height. Assign the settings to `Video_Resize` and enable resize/crop. Width is computed to preserve the aspect ratio.

```
using VisioForge.Core.Types;

VideoCapture1.Video_Resize = new MaxineSuperResSettings(modelsDir, height: 2160)
{
    Mode = MaxineSuperResolutionEffectMode.HQSource,
};
VideoCapture1.Video_ResizeOrCrop_Enabled = true;
```

| `MaxineSuperResolutionEffectMode` | Use for |
| --- | --- |
| `HQSource` | High-quality/high-bitrate sources; prioritizes artifact removal (default). |
| `LQSource` | Heavily compressed sources; prioritizes detail enhancement. |

## Upscale

A lighter-weight upscaler (vs. super resolution) with a tunable `Strength` (0.0–1.0, default 0.4).

```
using VisioForge.Core.Types;

VideoCapture1.Video_Resize = new MaxineUpscaleSettings(modelsDir, height: 1080, strength: 0.4f);
VideoCapture1.Video_ResizeOrCrop_Enabled = true;
```

## Media Player engine

The same effects apply to the `MediaPlayerCore` engine for AI enhancement during playback. Set `MediaPlayer1.Video_Effects_Enabled = true`, then use `MediaPlayer1.Video_Effects_Add(...)` for denoise/artifact, and assign `MediaPlayer1.Video_Resize` for super resolution/upscale. The player has no `Video_ResizeOrCrop_Enabled` flag — set `Video_Resize` before starting playback; it is applied when the playback graph is built (changing it during active playback only takes effect on the next start).

## Demos

- **Nvidia Maxine Demo** (Video Capture, WPF) — [Nvidia Maxine Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/WPF/CSharp/Nvidia%20Maxine%20Demo).
- **Nvidia Maxine Player** (Media Player, WPF) — [Nvidia Maxine Player](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK/WPF/CSharp/Nvidia%20Maxine%20Player).

## See also

- [Effects Reference](../effects-reference/) — full catalog of CPU, GPU, and AI effects.
- [Adding Effects](../add/)

---END OF PAGE---


## Add Text Overlay to Video in C# with Custom Fonts and Fade
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-effects/text-overlay/
**Description:** Create dynamic text overlays with font, color, position, rotation, and animation control for timestamps, captions, and branding in .NET video.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaPlayerCoreX, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Playback, Editing, Effects, C#
**API:** TextOverlayVideoEffect, OverlayManagerText, FontSettings, VideoEffectTextLogo

# Implementing Text Overlays in Video Streams

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

[VideoCaptureCore](#) [MediaPlayerCore](#) [VideoEditCore](#)

## Introduction

Text overlays provide a powerful way to enhance video streams with dynamic information, branding, captions, or timestamps. This guide explores how to implement fully customizable text overlays with precise control over appearance, positioning, and animations.

## Classic Engine Implementation

Our classic engines (VideoCaptureCore, MediaPlayerCore, VideoEditCore) offer a straightforward API for adding text to video streams.

### Basic Text Overlay Implementation

The following example demonstrates a simple text overlay with custom positioning:

```
var effect = new VideoEffectTextLogo(true, "textoverlay");

// set position
effect.Left = 20;
effect.Top = 20;

// set Font (System.Drawing.Font)
effect.Font = new Font("Arial", 40);

// set text
effect.Text = "Hello, world!";

// set text color
effect.FontColor = Color.Yellow;

MediaPlayer1.Video_Effects_Add(effect);
```

### Dynamic Information Display Options

#### Timestamp and Date Display

You can automatically display current date, time, or video timestamp information using specialized modes:

```
// set mode and mask
effect.Mode = TextLogoMode.DateTime;
effect.DateTimeMask = "yyyy-MM-dd. hh:mm:ss";
```

The SDK supports custom formatting masks for timestamps and dates, allowing precise control over the displayed information format. Frame number display requires no additional configuration.

### Animation and Transition Effects

#### Implementing Fade Effects

Create smooth text appearances and disappearances with customizable fade effects:

```
// add the fade-in
effect.FadeIn = true;
effect.FadeInDuration = TimeSpan.FromMilliseconds(5000);

// add the fade-out
effect.FadeOut = true;
effect.FadeOutDuration = TimeSpan.FromMilliseconds(5000);
```

### Text Rotation Options

Rotate your text overlay to match your design requirements:

```
// set rotation mode
effect.RotationMode = TextRotationMode.Rm90;
```

### Text Flip Transformations

Apply mirror effects to your text for creative presentations:

```
// set flip mode
effect.FlipMode = TextFlipMode.XAndY;
```

## X-Engine Implementation

Our newer X-engines (VideoCaptureCoreX, MediaPlayerCoreX, VideoEditCoreX) provide an enhanced API with additional features.

### Basic X-Engine Text Overlay

```
// text overlay
var textOverlay = new TextOverlayVideoEffect() { Text = "Hello World!" };

// set position
textOverlay.XPad = 20;
textOverlay.YPad = 20;

textOverlay.HorizontalAlignment = TextOverlayHAlign.Left;
textOverlay.VerticalAlignment = TextOverlayVAlign.Top;

// set Font - using object initializer
textOverlay.Font = new FontSettings
{
    Name = "Arial",
    Size = 24,
    Weight = FontWeight.Bold
};

// Alternative: using constructor with font face string
// textOverlay.Font = new FontSettings("Arial", "Bold", 24);

// set text
textOverlay.Text = "Hello, world!";

// set text color
textOverlay.Color = SKColors.Yellow;

// add the effect
await videoCapture1.Video_Effects_AddOrUpdateAsync(textOverlay);
```

### Advanced Dynamic Content Display

#### Video Timestamp Integration

Display the current position within the video:

```
// text overlay
var textOverlay = new TextOverlayVideoEffect();

// set text
textOverlay.Text = "Timestamp: ";

// set Timestamp mode
textOverlay.Mode = TextOverlayMode.Timestamp;

// add the effect
await videoCapture1.Video_Effects_AddOrUpdateAsync(textOverlay);
```

#### System Time Integration

Show the current system time alongside your video content:

```
// text overlay
var textOverlay = new TextOverlayVideoEffect();

// set text
textOverlay.Text = "Time: ";

// set System Time mode
textOverlay.Mode = TextOverlayMode.SystemTime;

// add the effect
await videoCapture1.Video_Effects_AddOrUpdateAsync(textOverlay);
```

### Text That Changes on Every Frame

`TextOverlayVideoEffect` is built for text that rarely changes, and it has no time window. For a live readout - a sensor value, the frame number, the clock - use `OverlayManagerText` through `Video_Overlay_Add` and give it a `TextProvider`. It is asked for the text once per frame:

```
// The overlay manager is only inserted into the pipeline when this is true,
// and it must be set before Start/StartAsync.
videoCapture1.Video_Overlay_Enabled = true;

var text = new OverlayManagerText(string.Empty, x: 40, y: 40);
text.Color = SKColors.Yellow;
text.Font.Size = 28;

// Called once per frame on the streaming thread. The argument is the frame
// timestamp, counted from the start of the pipeline.
text.TextProvider = ts => "Camera 1\nOperator: demo\nREC\n"
    + $"Sensor {_sensorValue:F1}   {DateTime.Now:HH:mm:ss}   {ts:hh\\:mm\\:ss}";

videoCapture1.Video_Overlay_Add(text);
```

Static and dynamic lines live in one string, so a caption block with a single live line still costs one callback per frame. Returning the same string as last time is cheap: the text layout is only re-measured when the string actually differs.

The callback runs on the streaming thread, under the same lock `Video_Overlay_Add` and `Video_Overlay_Remove` take. Keep it short and do not block in it - calling `Dispatcher.Invoke` from inside it to read a UI value can deadlock, not merely drop a frame. Read a field the UI thread has already written instead. A callback that throws is logged once and then not called again, and the element falls back to its `Text`; assigning `TextProvider` again re-enables it.

`OverlayManagerText` also honours `StartTime` and `EndTime`. Either bound works on its own - a zero `StartTime` means "from the beginning" and a zero `EndTime` means "no end" - and both are compared against the frame timestamp, not the wall clock.

See the [OverlayManagerBlock page](../../../mediablocks/VideoProcessing/OverlayManagerBlock/) for the full list of overlay elements.

`X` and `Y` are the top-left corner of the text, in pixels. `(0, 0)` is the top-left of the frame and the first line of a multiline string is fully visible there.

### Preview-only overlays in MediaPlayerCoreX

The same `Video_Overlay_*` API is available on `MediaPlayerCoreX`. Set `Video_Overlay_Enabled` before `OpenAsync` / `PlayAsync`. The overlay is inserted on the renderer branch only, after the sample grabber and after any custom video outputs, so the file on disk, snapshots and exports are not modified. Elements added with `Video_Overlay_Add` survive `Stop` and opening another file:

```
mediaPlayer1.Video_Overlay_Enabled = true;

var text = new OverlayManagerText(string.Empty, x: 0, y: 0);
text.TextProvider = ts => $"T {ts:hh\\:mm\\:ss}";
mediaPlayer1.Video_Overlay_Add(text);
```

## Best Practices for Text Overlays

- Consider readability against different backgrounds
- Use appropriate font sizes for the target display resolution
- Implement fade effects for less intrusive overlays
- Test performance impact with complex text effects

---

For more code examples and implementation details, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Video Sample Grabber — Extract RAW Frames in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-effects/video-sample-grabber/
**Description:** Extract RAW video frames from Video Capture, Media Player, and Video Edit SDKs with managed memory access and bitmap conversion in C#.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS, Editing, C#, NuGet
**API:** VideoSampleGrabberBlock, VideoFrameXBufferEventArgs, VideoFrameBitmapEventArgs, VideoFrameSKBitmapEventArgs, VideoFrameBufferEventArgs

# Video sample grabber usage

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Getting RAW video frames as unmanaged memory pointer inside the structure

X-enginesClassic enginesMedia Blocks SDK

```
// Subscribe to the video frame buffer event
VideoCapture1.OnVideoFrameBuffer += OnVideoFrameBuffer;

private void OnVideoFrameBuffer(object sender, VideoFrameXBufferEventArgs e)
{
    // Process the VideoFrameX object
    ProcessFrame(e.Frame);

    // If you've modified the frame and want to update the video stream
    e.UpdateData = true;
}

// Example of processing a VideoFrameX frame - adjusting brightness
private void ProcessFrame(VideoFrameX frame)
{
    // Only process RGB/BGR/RGBA/BGRA formats
    if (frame.Format != VideoFormatX.RGB &&
        frame.Format != VideoFormatX.BGR &&
        frame.Format != VideoFormatX.RGBA &&
        frame.Format != VideoFormatX.BGRA)
    {
        return;
    }

    // Get the data as a byte array for manipulation
    byte[] data = frame.ToArray();

    // Determine the pixel size based on format
    int pixelSize = (frame.Format == VideoFormatX.RGB || frame.Format == VideoFormatX.BGR) ? 3 : 4;

    // Brightness factor (1.2 = 20% brighter, 0.8 = 20% darker)
    float brightnessFactor = 1.2f;

    // Process each pixel
    for (int i = 0; i < data.Length; i += pixelSize)
    {
        // Adjust R, G, B channels
        for (int j = 0; j < 3; j++)
        {
            int newValue = (int)(data[i + j] * brightnessFactor);
            data[i + j] = (byte)Math.Min(255, newValue);
        }
    }

    // Copy the modified data back to the frame
    Marshal.Copy(data, 0, frame.Data, data.Length);
}
```

```
// Subscribe to the video frame buffer event
VideoCapture1.OnVideoFrameBuffer += OnVideoFrameBuffer;

private void OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    // Process the VideoFrame structure
    ProcessFrame(e.Frame);

    // If you've modified the frame and want to update the video stream
    e.UpdateData = true;
}

// Example of processing a VideoFrame - adjusting brightness
private void ProcessFrame(VideoFrame frame)
{
    // Only process RGB format for this example
    if (frame.Info.Colorspace != RAWVideoColorSpace.RGB24)
    {
        return;
    }

    // Get the data as a byte array for manipulation
    byte[] data = frame.ToArray();

    // Brightness factor (1.2 = 20% brighter, 0.8 = 20% darker)
    float brightnessFactor = 1.2f;

    // Process each pixel (RGB24 format = 3 bytes per pixel)
    for (int i = 0; i < data.Length; i += 3)
    {
        // Adjust R, G, B channels
        for (int j = 0; j < 3; j++)
        {
            int newValue = (int)(data[i + j] * brightnessFactor);
            data[i + j] = (byte)Math.Min(255, newValue);
        }
    }

    // Copy the modified data back to the frame
    Marshal.Copy(data, 0, frame.Data, data.Length);
}
```

```
// Create and set up video sample grabber block
var videoSampleGrabberBlock = new VideoSampleGrabberBlock(VideoFormatX.RGB);
videoSampleGrabberBlock.OnVideoFrameBuffer += OnVideoFrameBuffer;

private void OnVideoFrameBuffer(object sender, VideoFrameXBufferEventArgs e)
{
    // Process the VideoFrameX object
    ProcessFrame(e.Frame);

    // If you've modified the frame and want to update the video stream
    e.UpdateData = true;
}

// Example of processing a VideoFrameX frame - adjusting brightness
private void ProcessFrame(VideoFrameX frame)
{
    if (frame.Format != VideoFormatX.RGB)
    {
        return;
    }

    // Get the data as a byte array for manipulation
    byte[] data = frame.ToArray();

    // Brightness factor (1.2 = 20% brighter, 0.8 = 20% darker)
    float brightnessFactor = 1.2f;

    // Process each pixel (RGB format = 3 bytes per pixel)
    for (int i = 0; i < data.Length; i += 3)
    {
        // Adjust R, G, B channels
        for (int j = 0; j < 3; j++)
        {
            int newValue = (int)(data[i + j] * brightnessFactor);
            data[i + j] = (byte)Math.Min(255, newValue);
        }
    }

    // Copy the modified data back to the frame
    Marshal.Copy(data, 0, frame.Data, data.Length);
}
```

## Working with bitmap frames

If you need to work with managed Bitmap objects instead of raw memory pointers, you can use the `OnVideoFrameBitmap` event of the `core` classes or the SampleGrabberBlock:

```
// Subscribe to the bitmap frame event
VideoCapture1.OnVideoFrameBitmap += OnVideoFrameBitmap;

private void OnVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    // Process the Bitmap object
    ProcessBitmap(e.Frame);

    // If you've modified the bitmap and want to update the video stream
    e.UpdateData = true;
}

// Example of processing a Bitmap - adjusting brightness
private void ProcessBitmap(Bitmap bitmap)
{
    // Use Bitmap methods or Graphics to manipulate the image
    // This example uses ColorMatrix for brightness adjustment

    // Create a graphics object from the bitmap
    using (Graphics g = Graphics.FromImage(bitmap))
    {
        // Create a color matrix for brightness adjustment
        float brightnessFactor = 1.2f; // 1.0 = no change, >1.0 = brighter, <1.0 = darker
        ColorMatrix colorMatrix = new ColorMatrix(new float[][]
        {
            new float[] {brightnessFactor, 0, 0, 0, 0},
            new float[] {0, brightnessFactor, 0, 0, 0},
            new float[] {0, 0, brightnessFactor, 0, 0},
            new float[] {0, 0, 0, 1, 0},
            new float[] {0, 0, 0, 0, 1}
        });

        // Create an ImageAttributes object and set the color matrix
        using (ImageAttributes attributes = new ImageAttributes())
        {
            attributes.SetColorMatrix(colorMatrix);

            // Draw the image with the brightness adjustment
            g.DrawImage(bitmap,
                new Rectangle(0, 0, bitmap.Width, bitmap.Height),
                0, 0, bitmap.Width, bitmap.Height,
                GraphicsUnit.Pixel, attributes);
        }
    }
}
```

## Working with SkiaSharp for cross-platform applications

For cross-platform applications, the VideoSampleGrabberBlock provides the ability to work with SkiaSharp, a high-performance 2D graphics API for .NET. This is especially useful for applications targeting multiple platforms including mobile and web.

### Using the OnVideoFrameSKBitmap event

```
// First, add the SkiaSharp NuGet package to your project
// Install-Package SkiaSharp

// Import necessary namespaces
using SkiaSharp;
using VisioForge.Core.MediaBlocks.VideoProcessing;
using VisioForge.Core.Types.X.Events;

// Create a VideoSampleGrabberBlock with RGBA or BGRA format
// Note: OnVideoFrameSKBitmap event works only with RGBA or BGRA formats
var videoSampleGrabberBlock = new VideoSampleGrabberBlock(VideoFormatX.BGRA);

// Enable the SaveLastFrame property if you want to take snapshots later
videoSampleGrabberBlock.SaveLastFrame = true;

// Subscribe to the SkiaSharp bitmap event
videoSampleGrabberBlock.OnVideoFrameSKBitmap += OnVideoFrameSKBitmap;

// Event handler for SkiaSharp bitmap frames
private void OnVideoFrameSKBitmap(object sender, VideoFrameSKBitmapEventArgs e)
{
    // Process the SKBitmap
    ProcessSKBitmap(e.Frame);

    // Note: Unlike VideoFrameBitmapEventArgs, VideoFrameSKBitmapEventArgs does not have
    // an UpdateData property as it's designed for frame viewing/analysis only
}

// Example of processing an SKBitmap - adjusting brightness
private void ProcessSKBitmap(SKBitmap bitmap)
{
    // Create a new bitmap to hold the processed image
    using (var surface = SKSurface.Create(new SKImageInfo(bitmap.Width, bitmap.Height)))
    {
        var canvas = surface.Canvas;

        // Set up a paint with a color filter for brightness adjustment
        using (var paint = new SKPaint())
        {
            // Create a brightness filter (1.2 = 20% brighter)
            float brightnessFactor = 1.2f;
            var colorMatrix = new float[]
            {
                brightnessFactor, 0, 0, 0, 0,
                0, brightnessFactor, 0, 0, 0,
                0, 0, brightnessFactor, 0, 0,
                0, 0, 0, 1, 0
            };

            paint.ColorFilter = SKColorFilter.CreateColorMatrix(colorMatrix);

            // Draw the original bitmap with the brightness filter applied
            canvas.DrawBitmap(bitmap, 0, 0, paint);

            // If you need to get the result as a new SKBitmap:
            var processedImage = surface.Snapshot();
            using (var processedBitmap = SKBitmap.FromImage(processedImage))
            {
                // Use processedBitmap for further operations or display
                // For example, display it in a SkiaSharp view
                // mySkiaView.SKBitmap = processedBitmap.Copy();
            }
        }
    }
}
```

### Taking snapshots with SkiaSharp

```
// Create a method to capture and save a snapshot
private void CaptureSnapshot(string filePath)
{
    // Make sure SaveLastFrame was enabled on the VideoSampleGrabberBlock
    if (videoSampleGrabberBlock.SaveLastFrame)
    {
        // Get the last frame as an SKBitmap
        using (var bitmap = videoSampleGrabberBlock.GetLastFrameAsSKBitmap())
        {
            if (bitmap != null)
            {
                // Save the bitmap to a file
                using (var image = SKImage.FromBitmap(bitmap))
                using (var data = image.Encode(SKEncodedImageFormat.Png, 100))
                using (var stream = File.OpenWrite(filePath))
                {
                    data.SaveTo(stream);
                }
            }
        }
    }
}
```

### Advantages of using SkiaSharp

1. **Cross-platform compatibility**: Works on Windows, macOS, Linux, iOS, Android, and WebAssembly
2. **Performance**: Provides high-performance graphics processing
3. **Modern API**: Offers a comprehensive set of drawing, filtering, and transformation functions
4. **Memory efficiency**: More efficient memory management compared to System.Drawing
5. **No platform dependencies**: No dependency on platform-specific imaging libraries

## Frame processing information

You can get video frames from live sources or files using the `OnVideoFrameBuffer` and `OnVideoFrameBitmap` events.

The `OnVideoFrameBuffer` event is faster and provides the unmanaged memory pointer for the decoded frame. The `OnVideoFrameBitmap` event is slower, but you get the decoded frame as the `Bitmap` class object.

### Understanding the frame objects

- **VideoFrameX** (X-engines): Contains frame data, dimensions, format, timestamp, and methods for manipulating raw video data
- **VideoFrame** (Classic engines): Similar structure but with a different memory layout
- **Common properties**:
- Width/Height: Frame dimensions
- Format/Colorspace: Pixel format (RGB, BGR, RGBA, etc.)
- Stride: Number of bytes per scan line
- Timestamp: Frame's position in the video timeline
- Data: Pointer to unmanaged memory with pixel data

### Important considerations

1. The frame's pixel format affects how you process the data:
2. RGB/BGR: 3 bytes per pixel
3. RGBA/BGRA/ARGB: 4 bytes per pixel (with alpha channel)
4. YUV formats: Different component arrangements
5. Set `e.UpdateData = true` if you've modified the frame data and want the changes to be visible in the video stream.
6. For processing that requires multiple frames or complex operations, consider using a buffer or queue to store frames.
7. When using `OnVideoFrameSKBitmap`, select either RGBA or BGRA as the frame format when creating the VideoSampleGrabberBlock.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## AV1 Video Encoding in C# .NET - Configuration Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-encoders/av1/
**Description:** Configure AV1 encoders for cross-platform video capture, editing, and media pipelines. Next-gen compression with VisioForge SDK C# code examples.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, Capture, Streaming, Encoding, Editing, Conversion, AV1, C#
**API:** VideoCaptureCoreX, VideoEditCoreX, AMFAV1EncoderSettings, NVENCAV1EncoderSettings, QSVAV1EncoderSettings

# AV1 Encoders

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

VisioForge supports multiple AV1 encoder implementations, each with its own unique features and capabilities. This document covers the available encoders and their configuration options.

Currently, AV1 encoder are supported in the cross-platform engines: `VideoCaptureCoreX`, `VideoEditCoreX`, and `Media Blocks SDK`.

Not available on iOS

AV1 encoding is not available on iOS. Apple ships no AV1 hardware encoder on any chip, and the software AV1 encoders are not part of the iOS redistributable. AV1 *decoding* works on iOS - through VideoToolbox on A17 Pro and later, and through the software `dav1d` decoder everywhere else.

## Available Encoders

1. [AMD AMF AV1 Encoder (AMF)](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.VideoEncoders.AMFAV1EncoderSettings.html)
2. [NVIDIA NVENC AV1 Encoder (NVENC)](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.VideoEncoders.NVENCAV1EncoderSettings.html)
3. [Intel QuickSync AV1 Encoder (QSV)](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.VideoEncoders.QSVAV1EncoderSettings.html)
4. [AOM AV1 Encoder](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.VideoEncoders.AOMAV1EncoderSettings.html)
5. [RAV1E Encoder](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.VideoEncoders.RAV1EEncoderSettings.html)
6. [SVT-AV1 Encoder](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.VideoEncoders.SVTAV1EncoderSettings.html)

The SVT-AV1 encoder is delivered in the additional runtime package for your platform - the `VisioForge.CrossPlatform.Core.Windows.Adds.*` package for your architecture, `VisioForge.CrossPlatform.Core.macOS.Adds` (2026.8.25 or newer) or `VisioForge.CrossPlatform.Core.macCatalyst.Adds` (2026.8.26 or newer) - which is referenced beside the core package. Without it `AV1EncoderBlock.IsAvailable(new SVTAV1EncoderSettings())` returns `false`.

The AOM AV1 encoder is available on macOS, macCatalyst, and Linux. It is a quality-first software encoder intended for offline encoding; for the usual software AV1 workflow, prefer SVT-AV1 because it is substantially faster and scales better across CPU cores.

The `VisioForge.CrossPlatform.Core.macOS.Adds` and `VisioForge.CrossPlatform.Core.macCatalyst.Adds` packages include the required AOM runtime from 2026.8.30 onwards. On Linux, install a GStreamer runtime that provides the `av1enc` element; use `AOMAV1EncoderSettings.IsAvailable()` to check the active runtime.

You can use AV1 encoder with [WebM output](../../output-formats/webm/) or for network streaming.

## AMD AMF AV1 Encoder

The AMD AMF AV1 encoder provides hardware-accelerated encoding using AMD graphics cards.

### Features

- Multiple quality presets
- Variable bitrate control modes
- GOP size control
- QP (Quantization Parameter) control
- Smart Access Video support

### Rate Control Modes

- `Default`: Depends on Usage
- `CQP`: Constant QP
- `LCVBR`: Latency Constrained VBR
- `VBR`: Peak Constrained VBR
- `CBR`: Constant Bitrate

### Sample Usage

```
var encoderSettings = new AMFAV1EncoderSettings
{
    Bitrate = 3000,                              // 3 Mbps
    GOPSize = 30,                                // GOP size of 30 frames
    Preset = AMFAV1EncoderPreset.Quality,        // Quality preset
    RateControl = AMFAV1RateControlMode.VBR,     // Variable Bitrate mode
    Usage = AMFAV1EncoderUsage.Transcoding,      // Transcoding usage
    MaxBitrate = 5000,                           // 5 Mbps max bitrate
    QpI = 26,                                    // I-frame QP
    QpP = 26,                                    // P-frame QP
    RefFrames = 1,                               // Number of reference frames
    SmartAccessVideo = false                     // Smart Access Video disabled
};
```

## NVIDIA NVENC AV1 Encoder

NVIDIA's NVENC AV1 encoder provides hardware-accelerated encoding using NVIDIA GPUs.

### Features

- Multiple encoding presets
- Adaptive B-frame support
- Temporal AQ (Adaptive Quantization)
- VBV (Video Buffering Verifier) buffer control
- Spatial AQ support

### Rate Control Modes

- `Default`: Default mode
- `ConstQP`: Constant Quantization Parameter
- `CBR`: Constant Bitrate
- `VBR`: Variable Bitrate
- `CBR_LD_HQ`: Low-delay CBR, high quality
- `CBR_HQ`: CBR, high quality (slower)
- `VBR_HQ`: VBR, high quality (slower)

### Sample Usage

```
var encoderSettings = new NVENCAV1EncoderSettings
{
    Bitrate = 3000,                          // 3 Mbps
    Preset = NVENCPreset.HighQuality,        // High quality preset
    RateControl = NVENCRateControl.VBR,      // Variable Bitrate mode
    GOPSize = 75,                            // GOP size of 75 frames
    MaxBitrate = 5000,                       // 5 Mbps max bitrate
    BFrames = 2,                             // 2 B-frames between I and P
    RCLookahead = 8,                         // 8 frames lookahead
    TemporalAQ = true,                       // Enable temporal AQ
    Tune = NVENCTune.HighQuality,            // High quality tuning
    VBVBufferSize = 6000                     // 6000k VBV buffer
};
```

## Intel QuickSync AV1 Encoder

Intel's QuickSync AV1 encoder provides hardware-accelerated encoding using Intel GPUs.

### Features

- Low latency mode support
- Configurable target usage
- Reference frame control
- Flexible GOP size settings

### Rate Control Modes

- `CBR`: Constant Bitrate
- `VBR`: Variable Bitrate
- `CQP`: Constant Quantizer

### Sample Usage

```
var encoderSettings = new QSVAV1EncoderSettings
{
    Bitrate = 2000,                              // 2 Mbps
    LowLatency = false,                          // Standard latency mode
    TargetUsage = 4,                             // Balanced quality/speed
    GOPSize = 30,                                // GOP size of 30 frames
    MaxBitrate = 4000,                           // 4 Mbps max bitrate
    QPI = 26,                                    // I-frame QP
    QPP = 28,                                    // P-frame QP
    RateControl = QSVAV1EncRateControl.VBR,      // Variable Bitrate mode
    RefFrames = 1                                // Number of reference frames
};
```

## AOM AV1 Encoder

The Alliance for Open Media (AOM) AV1 encoder is a software-based reference implementation. It prioritizes compression efficiency and detailed AV1 controls over encoding speed, so it is best suited to offline output rather than live capture or streaming.

### Features

- Buffer control settings
- CPU usage optimization
- Frame dropping support
- Multi-threading capabilities
- Super-resolution support

### Rate Control Modes

- `VBR`: Variable Bit Rate Mode
- `CBR`: Constant Bit Rate Mode
- `CQ`: Constrained Quality Mode
- `Q`: Constant Quality Mode

Rate control only works while `MaxQuantizer` leaves the encoder room to spend fewer bits. It defaults to 63, the highest quantizer AV1 has; lowering it puts a quality floor under the stream, and at 0 the encoder ignores `TargetBitrate` and every buffer and overshoot setting. `TargetBitrate` defaults to 0, which means the encoder scales its own default to the frame size (256 Kbps at 320x240, about 6900 Kbps at 1920x1080); set it in kilobits per second to pin it instead.

### Sample Usage

```
var encoderSettings = new AOMAV1EncoderSettings
{
    BufferInitialSize = TimeSpan.FromMilliseconds(4000),
    BufferOptimalSize = TimeSpan.FromMilliseconds(5000),
    BufferSize = TimeSpan.FromMilliseconds(6000),
    CPUUsed = 4,                                   // CPU usage level, 0-9
    DropFrame = 0,                                 // Disable frame dropping
    RateControl = AOMAV1EncoderEndUsageMode.VBR,   // Variable Bitrate mode
    MaxQuantizer = 63,                             // Quantizer ceiling - keep at 63 for rate control
    TargetBitrate = 0,                             // 0 = scale the encoder default to the frame size
    Threads = 0,                                   // Auto thread count
    UseRowMT = true,                               // Enable row-based threading
    SuperResMode = AOMAV1SuperResolutionMode.None  // No super-resolution
};
```

## RAV1E Encoder

RAV1E is a fast and safe AV1 encoder written in Rust.

`Tiles` is what lets it use more than one core: a single tile encodes at the same speed on 4 cores and on 32. The default of 16 encodes 8 seconds of 720p30 in about 29 seconds against 84 seconds untiled, for roughly 1% more bitrate. Set it to 0 to encode the frame as a single tile.

### Features

- Speed preset control
- Quantizer settings
- Key frame interval control
- Low latency mode
- Tile-based multi-core encoding
- Psychovisual tuning

### Sample Usage

```
var encoderSettings = new RAV1EEncoderSettings
{
    Bitrate = 3000,                               // 3 Mbps
    LowLatency = false,                           // Standard latency mode
    MaxKeyFrameInterval = 240,                    // Maximum keyframe interval
    MinKeyFrameInterval = 12,                     // Minimum keyframe interval
    MinQuantizer = 0,                             // Minimum quantizer value
    Quantizer = 100,                              // Base quantizer value
    SpeedPreset = 10,                             // Speed preset (0-10)
    Tiles = 16,                                   // Tiles the frame is split into (0 - one tile)
    Tune = RAV1EEncoderTune.Psychovisual          // Psychovisual tuning
};
```

## SVT-AV1 Encoder

SVT-AV1 (Scalable Video Technology for AV1) is a high-performance software AV1 encoder that scales across CPU cores. It is considerably faster than RAV1E at comparable quality.

### Features

- Speed/quality preset control (0-13)
- Three mutually exclusive rate-control modes: CQP, CRF, and CBR/VBR by bitrate
- Intra frame period and tiling control
- Explicit logical-core count

### Rate Control Modes

Set exactly one of the three - the settings are applied in this order and the first one present wins:

1. `CQP` - constant quantization parameter (1-63)
2. `TargetBitrate` (with the optional `MaxBitrate` ceiling for VBR) - both in kbits/sec
3. `CRF` - constant rate factor (1-63, default 35), used when neither of the above is set

### Sample Usage

```
var encoderSettings = new SVTAV1EncoderSettings
{
    TargetBitrate = 3000,                         // 3 Mbps (kbits/sec), enables CBR/VBR
    MaxBitrate = 4500,                            // VBR ceiling (kbits/sec)
    Preset = 8,                                   // Speed preset (0-13), lower is slower and better
    IntraPeriodLength = 240,                      // Intra frame period, -2 for automatic
    TileColumns = 1,                              // log2: two tile columns
    TileRows = 1                                  // log2: two tile rows
};
```

## General Usage Notes

1. All encoders implement the `IAV1EncoderSettings` interface, providing a consistent way to create encoder blocks.
2. Each encoder has its own specific set of optimizations and trade-offs.
3. Hardware encoders (AMF, NVENC, QSV) generally provide better performance but may have specific hardware requirements.
4. Software encoders (AOM, RAV1E, SVT-AV1) offer more flexibility but may require more CPU resources.

## Recommendations

- For AMD GPUs: Use AMF encoder
- For NVIDIA GPUs: Use NVENC encoder
- For Intel GPUs: Use QSV encoder
- For maximum quality: Use AOM encoder
- For CPU-efficient encoding: Use RAV1E encoder
- For fast software encoding: Use SVT-AV1 encoder

## Best Practices

1. Always check encoder availability before using it
2. Set appropriate bitrates based on your target resolution and framerate
3. Use appropriate GOP sizes based on your content type
4. Consider the trade-off between quality and encoding speed
5. Test different rate control modes to find the best fit for your use case

---END OF PAGE---


## H264 Encoders for .NET — Hardware and Software Options
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-encoders/h264/
**Description:** Implement H264 video encoding with software and hardware acceleration, rate control options, and cross-platform support in .NET SDKs.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, H.264, C#
**API:** H264EncoderBlock, AndroidH264EncoderSettings, OpenH264EncoderSettings, AMFH264EncoderSettings, NVENCH264EncoderSettings, AppleMediaH264EncoderSettings

# H264 Encoders

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

This document provides detailed information about available H264 encoders, their features, rate control options, and usage examples.

For Windows-only engines check the [MP4 output](../../output-formats/mp4/) page.

## Overview

The following H264 encoders are available:

1. AMD AMF H264 Encoder (GPU-accelerated)
2. NVIDIA NVENC H264 Encoder (GPU-accelerated)
3. Intel QSV H264 Encoder (GPU-accelerated)
4. OpenH264 Encoder (Software)
5. Apple Media H264 Encoder (Hardware-accelerated for Apple devices)
6. VAAPI H264 Encoder (Linux hardware acceleration)
7. Android Hardware H264 Encoder (MediaCodec, auto-selects best SoC encoder)

## AMD AMF H264 Encoder

AMD's Advanced Media Framework (AMF) provides hardware-accelerated encoding on AMD GPUs.

### Key Features

- Hardware-accelerated encoding
- Multiple preset options (Balanced, Speed, Quality)
- Configurable GOP size
- CABAC entropy coding support
- Various rate control methods

### Rate Control Options

```
public enum AMFH264EncoderRateControl
{
    Default = -1,     // Default, depends on usage
    CQP = 0,         // Constant QP
    CBR = 1,         // Constant bitrate
    VBR = 2,         // Peak constrained VBR
    LCVBR = 3        // Latency Constrained VBR
}
```

### Sample Usage

```
var settings = new AMFH264EncoderSettings
{
    Bitrate = 5000,              // 5 Mbps
    CABAC = true,
    RateControl = AMFH264EncoderRateControl.CBR,
    Preset = AMFH264EncoderPreset.Quality,
    Profile = AMFH264EncoderProfile.Main,
    Level = AMFH264EncoderLevel.Level4_2,
    GOPSize = 30
};

var encoder = new H264EncoderBlock(settings);
```

## NVIDIA NVENC H264 Encoder

NVIDIA's hardware-based video encoder provides efficient H264 encoding on NVIDIA GPUs.

### Key Features

- Hardware-accelerated encoding
- B-frame support
- Adaptive quantization
- Multiple reference frames
- Weighted prediction
- Look-ahead support

### Rate Control Options

Inherited from NVENCBaseEncoderSettings with additional H264-specific options:

- Constant Bitrate (CBR)
- Variable Bitrate (VBR)
- Constant QP (CQP)
- Quality-based VBR

### Sample Usage

```
var settings = new NVENCH264EncoderSettings
{
    Bitrate = 5000,
    MaxBitrate = 8000,
    RCLookahead = 20,
    BFrames = 2,
    Profile = NVENCH264Profile.High,
    Level = NVENCH264Level.Level4_2,
    TemporalAQ = true
};

var encoder = new H264EncoderBlock(settings);
```

## Intel Quick Sync Video (QSV) H264 Encoder

Intel's hardware-based video encoder available on Intel processors with integrated graphics.

### Key Features

- Hardware-accelerated encoding
- Low latency mode
- Multiple rate control methods
- B-frame support
- Intelligent rate control options

### Rate Control Options

```
public enum QSVH264EncRateControl
{
    CBR = 1,         // Constant Bitrate
    VBR = 2,         // Variable Bitrate
    CQP = 3,         // Constant Quantizer
    AVBR = 4,        // Average Variable Bitrate
    LA_VBR = 8,      // Look Ahead VBR
    ICQ = 9,         // Intelligent CQP
    VCM = 10,        // Video Conferencing Mode
    LA_ICQ = 11,     // Look Ahead ICQ
    LA_HRD = 13,     // HRD compliant LA
    QVBR = 14        // Quality-defined VBR
}
```

### Sample Usage

```
var settings = new QSVH264EncoderSettings
{
    Bitrate = 5000,
    MaxBitrate = 8000,
    RateControl = QSVH264EncRateControl.VBR,
    Profile = QSVH264EncProfile.High,
    Level = QSVH264EncLevel.Level4_2,
    LowLatency = true,
    BFrames = 2
};

var encoder = new H264EncoderBlock(settings);
```

## OpenH264 Encoder

Cisco's open-source H264 software encoder.

### Key Features

- Software-based encoding
- Multiple complexity levels
- Scene change detection
- Adaptive quantization
- Denoising support

### Rate Control Options

```
public enum OpenH264RCMode
{
    Quality = 0,     // Quality mode
    Bitrate = 1,     // Bitrate mode
    Buffer = 2,      // Buffer based
    Off = -1         // Rate control off
}
```

### Sample Usage

```
var settings = new OpenH264EncoderSettings
{
    Bitrate = 5000,
    RateControl = OpenH264RCMode.Bitrate,
    Profile = OpenH264Profile.Main,
    Level = OpenH264Level.Level4_2,
    Complexity = OpenH264Complexity.Medium,
    EnableDenoise = true,
    SceneChangeDetection = true
};

var encoder = new H264EncoderBlock(settings);
```

## Apple Media H264 Encoder

Hardware-accelerated encoder for Apple platforms.

### Key Features

- Hardware acceleration on Apple devices
- Real-time encoding support
- Frame reordering options (off by default: B-frames make the encoder emit timestamps that MPEG-TS outputs and MP4 recordings cannot use)
- Quality-based encoding
- Rate control: `ABR` (default) or `CBR`; in `ABR` mode, a data rate ceiling averaged over a sliding window

### Sample Usage

```
var settings = new AppleMediaH264EncoderSettings
{
    Bitrate = 5000,
    AllowFrameReordering = false,
    Quality = 0.8,
    Realtime = true,

    // Constant bitrate for a fixed-bandwidth endpoint.
    RateControl = AppleMediaRateControl.CBR
};

var encoder = new H264EncoderBlock(settings);
```

Or an average bitrate with a hard ceiling — 5 Mbps target, never more than 7 Mbps averaged over any one second:

```
var settings = new AppleMediaH264EncoderSettings
{
    Bitrate = 5000,
    RateControl = AppleMediaRateControl.ABR,   // the default
    DataRateLimitBitrate = 7000,
    DataRateLimitDuration = 1.0
};
```

#### CBR and the data rate limits are alternatives

Do not set both. With `CBR` selected the encoder ignores the data rate limits outright and says so in its log (`Ignoring data-rate-limits property, CBR mode is enabled`) — constant bitrate is already a ceiling. The limits apply in `ABR` mode.

#### CBR is not constant everywhere

True constant bitrate is a VideoToolbox capability, not an SDK one: it requires macOS 13+ or iOS 16+ on Apple Silicon. On older systems and on Intel Macs, VideoToolbox emulates CBR through the data rate limits and reports it in its own log (`CBR is unsupported on your system, emulating with custom data rate limits`), using limits of its own derived from `Bitrate`. The encoded output is then near-constant rather than constant.

Rate control also needs the GStreamer 1.28.6 runtime, which every Apple package now ships — macOS, Mac Catalyst and iOS alike.

`ForceHWUsage` has no effect on iOS: every VideoToolbox encoder there is hardware, so GStreamer registers no separate hardware-only element and the request is already satisfied.

## VAAPI H264 Encoder

Video Acceleration API encoder for Linux systems.

### Key Features

- Hardware acceleration on Linux
- Multiple profile support
- Trellis quantization
- B-frame support
- Various rate control methods

### Rate Control Options

```
public enum VAAPIH264RateControl
{
    CQP = 1,                 // Constant QP
    CBR = 2,                 // Constant bitrate
    VBR = 4,                 // Variable bitrate
    VBRConstrained = 5,      // Constrained VBR
    ICQ = 7,                 // Intelligent CQP
    QVBR = 8                 // Quality-defined VBR
}
```

### Sample Usage

```
var settings = new VAAPIH264EncoderSettings
{
    Bitrate = 5000,
    RateControl = VAAPIH264RateControl.CBR,
    Profile = VAAPIH264EncoderProfile.Main,
    MaxBFrames = 2,
    Trellis = true,
    CABAC = true
};

var encoder = new H264EncoderBlock(settings);
```

## Android Hardware H264 Encoder

On Android (API 21+), use `AndroidH264EncoderSettings`. It wraps the Android `MediaCodec` API via GStreamer's `amcvidenc-*` element family, auto-detecting the best hardware encoder on the device (Qualcomm, Exynos, MediaTek, etc.) — so a single settings class covers every Android SoC.

### Sample usage

```
// Build is Android-only (this type is gated by the __ANDROID__ preprocessor).
var settings = new AndroidH264EncoderSettings
{
    Bitrate = 8_000,                           // kbit/s (so 8000 = 8 Mbps)
    IFrameInterval = TimeSpan.FromSeconds(2),  // Keyframe cadence
    ParseStream = true,                        // Leave true unless you are piping raw frames into SRT
};

// Optional: pin a specific encoder element name, bypassing auto-detection.
// settings.CodecName = "amcvidenc-c2qtiavcencoder";  // Qualcomm Codec2 path, for example

var encoder = new H264EncoderBlock(settings);
```

### Key characteristics

- Single settings class for every Android SoC — no per-vendor types
- `Bitrate` in kbit/s (the GStreamer element receives bits/sec internally)
- `IFrameInterval` is a `TimeSpan` — on Android 25+ fractional seconds work (`i-frame-interval-float`); older versions truncate to whole seconds
- `CodecName` overrides auto-detection when you know which `amcvidenc-*` element you want

### Properties bag

Only `CustomH264EncoderSettings` and `AndroidH264EncoderSettings` expose a `Properties` dictionary for forwarding raw GStreamer element properties that don't have first-class C# wrappers. The standard implementations (OpenH264, NVENCH264, QSVH264, AMFH264, AppleMediaH264, VAAPIH264) do **not** — their tuning knobs are exposed as typed C# properties on the settings class.

```
// Custom or Android settings only
var settings = new CustomH264EncoderSettings("x264enc");
settings.Properties["bitrate-mode"] = "constant";
settings.Properties["complexity"] = "max";
```

## Best Practices

1. **Encoder Selection**
2. Use hardware encoders (AMD, NVIDIA, Intel) when available for better performance
3. Fall back to OpenH264 when hardware encoding is not available
4. Use platform-specific encoders (Apple Media, VAAPI, Android hardware) when targeting specific platforms
5. **Rate Control Selection**
6. Use CBR for streaming applications where consistent bitrate is important
7. Use VBR for offline encoding where quality is more important than bitrate consistency
8. Use CQP for highest quality when bitrate is not a concern
9. Consider using look-ahead options for better quality when latency is not critical
10. **Performance Optimization**
11. Adjust GOP size based on content type (smaller for high motion, larger for static content)
12. Enable CABAC for better compression efficiency when latency is not critical
13. Use appropriate profile and level for target devices
14. Consider B-frames for better compression but be aware of latency impact
15. **Platform Detection** — use the `IsAvailable()` static on each settings class to pick a concrete encoder at runtime:

```
if (NVENCH264EncoderSettings.IsAvailable())
{
    encoder = new H264EncoderBlock(new NVENCH264EncoderSettings { Bitrate = 6_000 });
}
else if (QSVH264EncoderSettings.IsAvailable())
{
    encoder = new H264EncoderBlock(new QSVH264EncoderSettings { Bitrate = 6_000 });
}
else if (AMFH264EncoderSettings.IsAvailable())
{
    encoder = new H264EncoderBlock(new AMFH264EncoderSettings { Bitrate = 6_000 });
}
else
{
    // Software fallback
    encoder = new H264EncoderBlock(new OpenH264EncoderSettings { Bitrate = 6_000 });
}
```

---END OF PAGE---


## HEVC Hardware Encoding on AMD, NVIDIA, Intel and Apple
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-encoders/hevc/
**Description:** Hardware-accelerated HEVC (H.265) encoding with AMD, NVIDIA and Intel GPUs and Apple VideoToolbox, including 10-bit and alpha, in .NET.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, Conversion, Webcam, H.265, C#
**API:** AMFHEVCEncoderSettings, NVENCHEVCEncoderSettings, QSVHEVCEncoderSettings, AppleMediaHEVCEncoderSettings, IHEVCEncoderSettings, SVTHEVCEncoderSettings

# HEVC Hardware Encoding in .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

This guide explores hardware-accelerated HEVC (H.265) encoding options available in VisioForge .NET SDKs. We'll cover implementation details for AMD, NVIDIA, and Intel GPU encoders plus Apple VideoToolbox, helping you choose the right solution for your video processing needs.

For Windows-specific output formats, refer to our [MP4 output documentation](../../output-formats/mp4/).

## Hardware HEVC Encoders Overview

Modern GPUs offer powerful hardware encoding capabilities that significantly outperform software-based solutions. VisioForge SDKs support four hardware HEVC encoders:

- **AMD AMF** - For AMD Radeon GPUs
- **NVIDIA NVENC** - For NVIDIA GeForce and professional GPUs
- **Intel QuickSync** - For Intel CPUs with integrated graphics
- **Apple VideoToolbox** - For macOS, Mac Catalyst and iOS

Each encoder provides unique features and optimization options. Let's explore their capabilities and implementation details.

## AMD AMF HEVC Encoder

AMD's Advanced Media Framework (AMF) delivers hardware-accelerated HEVC encoding on compatible Radeon GPUs. It balances encoding speed, quality, and efficiency for various scenarios.

### Key Features and Settings

- **Rate Control Methods**:
- `CQP` (Constant QP) for fixed quality settings
- `LCVBR` (Latency Constrained VBR) for streaming
- `VBR` (Variable Bitrate) for offline encoding
- `CBR` (Constant Bitrate) for reliable bandwidth usage
- **Usage Profiles**:
- Transcoding (highest quality)
- Ultra Low Latency (for real-time applications)
- Low Latency (for interactive streaming)
- Web Camera (optimized for webcam sources)
- **Quality Presets**: Balance between encoding speed and output quality

### Implementation Example

```
var encoder = new AMFHEVCEncoderSettings
{
    Bitrate = 3000, // 3 Mbps target bitrate
    MaxBitrate = 5000, // 5 Mbps peak bitrate
    RateControl = AMFHEVCEncoderRateControl.CBR,

    // Quality optimization
    Preset = AMFHEVCEncoderPreset.Quality,
    Usage = AMFHEVCEncoderUsage.Transcoding,

    // GOP and frame settings
    GOPSize = 30, // Keyframe interval
    QP_I = 22, // I-frame quantization parameter
    QP_P = 22, // P-frame quantization parameter

    RefFrames = 1 // Reference frames count
};
```

## NVIDIA NVENC HEVC Encoder

NVIDIA's NVENC technology provides dedicated encoding hardware on GeForce and professional GPUs, offering excellent performance and quality across various bitrates.

### Key Capabilities

- **Multiple Profile Support**:
- Main (8-bit)
- Main10 (10-bit HDR)
- Main444 (high color precision)
- Extended bit depth options (12-bit)
- **Advanced Encoding Features**:
- B-frame support with adaptive placement
- Temporal Adaptive Quantization
- Weighted Prediction
- Look-ahead rate control
- **Performance Presets**: From quality-focused to ultra-fast encoding

### Implementation Example

```
var encoder = new NVENCHEVCEncoderSettings
{
    // Bitrate configuration
    Bitrate = 3000, // 3 Mbps target
    MaxBitrate = 5000, // 5 Mbps maximum

    // Profile settings
    Profile = NVENCHEVCProfile.Main,
    Level = NVENCHEVCLevel.Level5_1,

    // Quality enhancement options
    BFrames = 2, // Number of B-frames
    BAdaptive = true, // Adaptive B-frame placement
    TemporalAQ = true, // Temporal adaptive quantization
    WeightedPrediction = true, // Improves quality for fades
    RCLookahead = 20, // Frames to analyze for rate control

    // Buffer settings
    VBVBufferSize = 0 // Use default buffer size
};
```

## Intel QuickSync HEVC Encoder

Intel QuickSync leverages the integrated GPU present in modern Intel processors for efficient hardware encoding, making it accessible without a dedicated graphics card.

### Key Features

- **Versatile Rate Control Options**:
- `CBR` (Constant Bitrate)
- `VBR` (Variable Bitrate)
- `CQP` (Constant Quantizer)
- `ICQ` (Intelligent Constant Quality)
- `VCM` (Video Conferencing Mode)
- `QVBR` (Quality-defined VBR)
- **Optimization Settings**:
- Target Usage parameter (quality vs speed balance)
- Low-latency mode for streaming
- HDR conformance controls
- Closed caption insertion options
- **Profile Support**:
- Main (8-bit)
- Main10 (10-bit HDR)

### Implementation Example

```
var encoder = new QSVHEVCEncoderSettings
{
    // Bitrate settings
    Bitrate = 3000, // 3 Mbps target
    MaxBitrate = 5000, // 5 Mbps peak
    RateControl = QSVHEVCEncRateControl.VBR,

    // Quality tuning
    TargetUsage = 4, // 1=Best quality, 7=Fastest encoding

    // Stream structure
    GOPSize = 30, // Keyframe interval
    RefFrames = 2, // Reference frames

    // Feature configuration
    Profile = QSVHEVCEncProfile.Main,
    LowLatency = false, // Enable for streaming

    // Advanced options
    CCInsertMode = QSVHEVCEncSEIInsertMode.Insert,
    DisableHRDConformance = false
};
```

## Apple VideoToolbox HEVC Encoder

VideoToolbox is the hardware encoder on macOS, Mac Catalyst and iOS. It is available on Apple Silicon and on Intel Macs with QuickSync-capable graphics.

### Key Features

- **Rate Control**:
- `ABR` (Average Bitrate, the default)
- `CBR` (Constant Bitrate)
- Data rate limits - a bitrate ceiling averaged over a sliding window, in `ABR` mode
- **Profile Support**:
- Main (8-bit)
- Main10 (10-bit)
- **Alpha channel** - `PreserveAlpha` switches to the alpha-capable encoder

### Implementation Example

```
// Constant bitrate, for a fixed-bandwidth endpoint.
var cbr = new AppleMediaHEVCEncoderSettings
{
    Bitrate = 3000,                              // 3 Mbps
    RateControl = AppleMediaRateControl.CBR,
    Profile = AppleMediaHEVCProfile.Main,
    Realtime = true,
    Quality = 0.5
};

// Average bitrate with a hard ceiling: 3 Mbps target, never more than 4.5 Mbps
// averaged over any one second.
var cappedAbr = new AppleMediaHEVCEncoderSettings
{
    Bitrate = 3000,
    RateControl = AppleMediaRateControl.ABR,     // the default
    DataRateLimitBitrate = 4500,
    DataRateLimitDuration = 1.0,
    Profile = AppleMediaHEVCProfile.Main
};
```

### CBR and the data rate limits are alternatives

Do not set both. With `CBR` selected the encoder ignores the data rate limits outright and says so in its log (`Ignoring data-rate-limits property, CBR mode is enabled`) — constant bitrate is already a ceiling. The limits apply in `ABR` mode, where they turn "aim for this bitrate" into "aim for this bitrate and never exceed that one over any window of this length".

### CBR is not constant everywhere

True constant bitrate is a VideoToolbox capability, not an SDK one: it requires macOS 13+ or iOS 16+ on Apple Silicon. On older systems and on Intel Macs, VideoToolbox emulates CBR through data rate limits of its own, derived from `Bitrate`, and reports it in its own log (`CBR is unsupported on your system, emulating with custom data rate limits`). The encoded output is then near-constant rather than constant, which matters if you are sizing a fixed transport budget around it.

### Platform notes

- **10-bit** (`AppleMediaHEVCProfile.Main10`), the **alpha** encoder and rate control all need the GStreamer 1.28.6 runtime, which every Apple package now ships — macOS, Mac Catalyst and iOS alike. Whether the device's VideoToolbox actually encodes 10-bit is still a per-chip question.
- `ForceHWUsage` pins the encoder to the hardware-only element, failing rather than falling back to a software implementation. It has no effect on iOS: every VideoToolbox encoder there is hardware, so GStreamer registers no separate hardware-only element.
- On the MediaBlocks pipeline path the SDK always inserts `h265parse` after this encoder: VideoToolbox emits `hvc1` only, while the MPEG-TS muxer behind SRT/UDP/RIST output accepts byte-stream only. The RTSP path needs no parser — `rtph265pay` takes `hvc1` directly.

## Quality Presets for Simplified Configuration

The AMD, NVIDIA and Intel encoders support standardized quality presets through the `VideoQuality` enum, providing a simplified configuration approach:

- **Low**: 1 Mbps target, 2 Mbps max (for basic streaming)
- **Normal**: 3 Mbps target, 5 Mbps max (for standard content)
- **High**: 6 Mbps target, 10 Mbps max (for detailed content)
- **Very High**: 15 Mbps target, 25 Mbps max (for premium quality)

`AppleMediaHEVCEncoderSettings` has no `VideoQuality` constructor — set `Bitrate` and `Quality` on it directly, as the VideoToolbox example above does.

### Using Quality Presets

```
// For AMD AMF
var amfEncoder = new AMFHEVCEncoderSettings(VideoQuality.High);

// For NVIDIA NVENC
var nvencEncoder = new NVENCHEVCEncoderSettings(VideoQuality.High);

// For Intel QuickSync
var qsvEncoder = new QSVHEVCEncoderSettings(VideoQuality.High);
```

## Hardware Detection and Fallback Strategy

A robust implementation should check for encoder availability and implement appropriate fallbacks:

```
// Create the most appropriate encoder for the current system
IHEVCEncoderSettings GetOptimalHEVCEncoder()
{
    if (AMFHEVCEncoderSettings.IsAvailable())
    {
        return new AMFHEVCEncoderSettings(VideoQuality.High);
    }
    else if (NVENCHEVCEncoderSettings.IsAvailable())
    {
        return new NVENCHEVCEncoderSettings(VideoQuality.High);
    }
    else if (QSVHEVCEncoderSettings.IsAvailable())
    {
        return new QSVHEVCEncoderSettings(VideoQuality.High);
    }
    else
    {
#if __MACOS__ || __MACCATALYST__ || __IOS__
        // Apple VideoToolbox.
        return new AppleMediaHEVCEncoderSettings { Bitrate = 6000 };
#elif NET_LINUX
        // Fall back to the SVT-HEVC software encoder on Linux (Linux-only — see SVTHEVCEncoderSettings).
        return new SVTHEVCEncoderSettings();
#else
        // The X engine does NOT ship a typed IHEVCEncoderSettings software fallback for Windows.
        // Let the caller decide: keep H.264 output, install a GPU driver enabling QSV/NVENC/AMF, or
        // use the classic engine's FFMPEG-EXE pipeline.
        throw new NotSupportedException("No HEVC encoder available on this platform. Install a GPU driver or switch to H.264.");
#endif
    }
}
```

## Best Practices for HEVC Encoding

### 1. Encoder Selection

- **AMD GPUs**: Best for applications where you know users have AMD hardware
- **NVIDIA GPUs**: Provides consistent quality across generations, ideal for professional applications
- **Intel QuickSync**: Great universal option when a dedicated GPU isn't guaranteed
- **Apple VideoToolbox**: The only hardware HEVC encoder on macOS, Mac Catalyst and iOS

### 2. Rate Control Selection

- **Streaming**: Use CBR for consistent bandwidth utilization
- **VoD Content**: VBR provides better quality at the same file size
- **Archival**: CQP ensures consistent quality regardless of content complexity

### 3. Performance Optimization

- Lower the reference frames count for faster encoding
- Adjust GOP size based on content type (smaller for high motion, larger for static scenes)
- Consider disabling B-frames for ultra-low latency applications

### 4. Quality Enhancement

- Enable adaptive quantization features for content with varying complexity
- Use weighted prediction for content with fades or gradual transitions
- Implement look-ahead when encoding quality is more important than latency

## Common Troubleshooting

1. **Encoder unavailability**: Ensure GPU drivers are up-to-date
2. **Lower than expected quality**: Check if quality presets match your content type
3. **Performance issues**: Monitor GPU utilization and adjust settings accordingly
4. **Compatibility problems**: Verify target devices support the selected HEVC profile

## Conclusion

Hardware-accelerated HEVC encoding offers significant performance advantages for .NET applications dealing with video processing. By leveraging AMD AMF, NVIDIA NVENC, or Intel QuickSync through VisioForge SDKs, you can achieve optimal balance between quality, speed, and efficiency.

Choose the right encoder and settings based on your specific requirements, target audience, and content type to deliver the best possible experience in your applications.

Start by detecting available hardware encoders, implementing appropriate quality settings, and testing across various content types to ensure optimal results.

---END OF PAGE---


## Video Encoders for VisioForge .NET — H264, HEVC, AV1
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-encoders/
**Description:** Comprehensive overview of video encoders with hardware acceleration, codec features, and performance optimization for .NET video applications.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming
**API:** NVENCH264EncoderSettings, NVENCHEVCEncoderSettings, AMFH264EncoderSettings, AMFHEVCEncoderSettings, QSVH264EncoderSettings, QSVHEVCEncoderSettings, OpenH264EncoderSettings, AOMAV1EncoderSettings

# Video Encoders for VisioForge .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to Video Encoders

Video encoders are essential components in multimedia processing applications, responsible for compressing video data while maintaining optimal quality. VisioForge .NET SDKs incorporate multiple advanced encoders to meet diverse development requirements across different platforms and use cases.

This guide provides detailed information about each encoder's capabilities, performance characteristics, and implementation details to help .NET developers make informed decisions for their multimedia applications.

## Hardware vs. Software Encoding

When developing video processing applications, choosing between hardware and software encoders significantly impacts application performance and user experience.

### Hardware-Accelerated Encoders

Hardware encoders utilize dedicated processing units (GPUs or specialized hardware):

- **Advantages**: Lower CPU usage, higher encoding speeds, improved battery efficiency
- **Use cases**: Real-time streaming, live video processing, mobile applications
- **Examples in our SDK**: NVIDIA NVENC, AMD AMF, Intel QuickSync

### Software Encoders

Software encoders run on the CPU without specialized hardware:

- **Advantages**: Greater compatibility, more quality control options, platform independence
- **Use cases**: High-quality offline encoding, environments without compatible hardware
- **Examples in our SDK**: OpenH264, Software MJPEG encoder

## Available Video Encoders

Our SDKs provide extensive encoder options to accommodate various project requirements:

### H.264 (AVC) Encoders

H.264 remains one of the most widely used video codecs, offering excellent compression efficiency and broad compatibility.

#### Key Features:

- Multiple profile support (Baseline, Main, High)
- Adjustable bitrate controls (CBR, VBR, CQP)
- B-frame and reference frame configuration
- Hardware acceleration options from major vendors

[Learn more about H.264 encoders →](h264/)

### HEVC (H.265) Encoders

HEVC delivers superior compression efficiency compared to H.264, enabling higher quality video at the same bitrate or comparable quality at lower bitrates.

#### Key Features:

- Approximately 50% better compression than H.264
- 8-bit and 10-bit color depth support
- Multiple hardware acceleration options
- Advanced rate control mechanisms

[Learn more about HEVC encoders →](hevc/)

### AV1 Encoder

AV1 represents the next generation of video codecs, offering superior compression efficiency particularly suited for web streaming.

#### Key Features:

- Royalty-free open standard
- Better compression than HEVC
- Increasing browser and device support
- Optimized for web content delivery

[Learn more about AV1 encoder →](av1/)

### MJPEG Encoders

Motion JPEG provides frame-by-frame JPEG compression, useful for specific applications where individual frame access is important.

#### Key Features:

- Simple implementation
- Low encoding latency
- Independent frame access
- Hardware and software implementations

[Learn more about MJPEG encoders →](mjpeg/)

### VP8 and VP9 Encoders

These open codecs developed by Google offer royalty-free alternatives with good compression efficiency.

#### Key Features:

- Open-source implementation
- Competitive quality-to-bitrate ratio
- Wide web browser support
- Suitable for WebM container format

[Learn more about VP8/VP9 encoders →](vp8-vp9/)

### Windows Media Video Encoder

The WMV encoder provides compatibility with Windows ecosystem and legacy applications.

#### Key Features:

- Native Windows integration
- Multiple profile options
- Compatible with Windows Media framework
- Efficient for Windows-centric deployments

[Learn more about WMV encoder →](../output-formats/wmv/)

## Encoder Selection Guidelines

Selecting the optimal encoder depends on various factors:

### Platform Compatibility

- **Windows**: All encoders supported
- **macOS**: Apple Media encoders, OpenH264, AV1
- **Linux**: VAAPI, OpenH264, software implementations

### Hardware Requirements

When using hardware-accelerated encoders, verify system compatibility:

Hardware-encoder availability checks live on the codec-specific settings classes (there is no shared `NVENCEncoderSettings` / `AMFEncoderSettings` / `QSVEncoderSettings` base type — instantiate `NVENCH264EncoderSettings`, `AMFHEVCEncoderSettings`, `QSVH264EncoderSettings`, etc., depending on the codec you need):

```
// Probe H.264 hardware encoders in priority order.
if (NVENCH264EncoderSettings.IsAvailable())
{
    // NVIDIA GPU available — use NVENC H.264.
    var settings = new NVENCH264EncoderSettings();
}
else if (QSVH264EncoderSettings.IsAvailable())
{
    // Intel CPU with Quick Sync available.
    var settings = new QSVH264EncoderSettings();
}
else if (AMFH264EncoderSettings.IsAvailable())
{
    // AMD GPU available — use AMF H.264.
    var settings = new AMFH264EncoderSettings();
}
else
{
    // Fallback to software encoder (cross-platform).
    var settings = new OpenH264EncoderSettings();
}
```

### Quality vs. Performance Tradeoffs

Different encoders offer varying balances between quality and encoding speed:

| Encoder Type | Quality | Performance | CPU Usage |
| --- | --- | --- | --- |
| NVENC H.264 | Good | Excellent | Very Low |
| NVENC HEVC | Very Good | Very Good | Very Low |
| AMF H.264 | Good | Very Good | Very Low |
| QSV H.264 | Good | Excellent | Very Low |
| OpenH264 | Good-Excellent | Moderate | High |
| AV1 | Excellent | Poor-Moderate | Very High |

### Encoding Scenarios

- **Live streaming**: Prefer hardware encoders with CBR rate control
- **Video recording**: Hardware encoders with VBR for better quality/size balance
- **Offline processing**: Quality-focused encoders with VBR or CQP
- **Low-latency applications**: Hardware encoders with low-latency presets

## Performance Optimization

Maximize encoder efficiency with these best practices:

1. **Match output resolution to content requirements** - Avoid unnecessary upscaling
2. **Select appropriate bitrates** - Higher isn't always better; target your delivery medium
3. **Choose encoder presets wisely** - Faster presets use less CPU but may reduce quality
4. **Enable scene detection** for improved quality at scene changes
5. **Use hardware acceleration** when available for real-time applications

## Conclusion

VisioForge .NET SDKs provide a comprehensive set of video encoders to meet diverse requirements across different platforms and use cases. By understanding the strengths and configurations of each encoder, developers can create high-performance video applications with optimal quality and efficiency.

For specific encoder configuration details, refer to the dedicated documentation pages for each encoder type linked throughout this guide.

---END OF PAGE---


## Motion JPEG (MJPEG) Encoders in VisioForge .NET SDKs
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-encoders/mjpeg/
**Description:** Implement MJPEG video encoders in .NET with CPU and GPU acceleration for frame-by-frame compression and streaming applications.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, MJPEG, C#
**API:** QSVMJPEGEncoderSettings, MJPEGEncoderSettings, IMJPEGEncoderSettings

# Motion JPEG (MJPEG) Video Encoders for .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

## Introduction to MJPEG Encoding in VisioForge

The VisioForge .NET SDK suite provides robust Motion JPEG (MJPEG) encoder implementations designed for efficient video processing in your applications. MJPEG remains a popular choice for many video applications due to its simplicity, compatibility, and specific use cases where frame-by-frame compression is advantageous.

This documentation provides a detailed exploration of the two MJPEG encoder options available in the VisioForge library:

1. CPU-based MJPEG encoder - The default implementation utilizing processor resources
2. GPU-accelerated Intel QuickSync MJPEG encoder - Hardware-accelerated option for compatible systems

Both implementations offer developers flexible configuration options while maintaining the core MJPEG functionality through the unified `IMJPEGEncoderSettings` interface.

## What is MJPEG and Why Use It?

Motion JPEG (MJPEG) is a video compression format where each video frame is compressed separately as a JPEG image. Unlike more modern codecs such as H.264 or H.265 that use temporal compression across frames, MJPEG treats each frame independently.

### Key Advantages of MJPEG

- **Frame-by-frame processing**: Each frame maintains independent quality without temporal artifacts
- **Lower latency**: Minimal processing delay makes it suitable for real-time applications
- **Editing friendly**: Individual frame access simplifies non-linear editing workflows
- **Resilience to motion**: Maintains quality during scenes with significant movement
- **Universal compatibility**: Works across platforms without specialized hardware decoders
- **Simplified development**: Straightforward implementation in various programming environments

### Common Use Cases

MJPEG encoding is particularly valuable in scenarios such as:

- **Security and surveillance systems**: Where frame quality and reliability are critical
- **Video capture applications**: Real-time video recording with minimal latency
- **Medical imaging**: When individual frame fidelity is essential
- **Industrial vision systems**: For consistent frame-by-frame analysis
- **Multimedia editing software**: Where rapid seeking and frame extraction is required
- **Streaming in bandwidth-limited environments**: Where consistent quality is preferred over file size

## MJPEG Implementation in VisioForge

Both MJPEG encoder implementations in VisioForge SDKs derive from the `IMJPEGEncoderSettings` interface, ensuring a consistent approach regardless of which encoder you choose. This design allows for easy switching between implementations based on performance requirements and hardware availability.

### Core Interface and Common Properties

The shared interface exposes essential properties and methods:

- **Quality**: Integer value from 10-100 controlling compression level
- **CreateBlock()**: Factory method to generate the encoder processing block
- **IsAvailable()**: Static method to verify encoder support on the current system

## CPU-based MJPEG Encoder

The CPU-based encoder serves as the default implementation, providing reliable encoding across virtually all system configurations. It performs all encoding operations using the CPU, making it a universally compatible choice for MJPEG encoding.

### Features and Specifications

- **Processing method**: Pure CPU-based encoding
- **Quality range**: 10-100 (higher values = better quality, larger files)
- **Default quality**: 85 (balances quality and file size)
- **Performance characteristics**: Scales with CPU cores and processing power
- **Memory usage**: Moderate, dependent on frame resolution and processing settings
- **Compatibility**: Works on any system supporting the .NET runtime
- **Specialized hardware**: None required

### Detailed Implementation Example

```
// Import the necessary VisioForge namespaces
using VisioForge.Core.Types.Output;

// Create a new instance of the CPU-based encoder settings
var mjpegSettings = new MJPEGEncoderSettings();

// Configure quality (10-100)
mjpegSettings.Quality = 85; // Default balanced quality

// Optional: Verify encoder availability
if (MJPEGEncoderSettings.IsAvailable())
{
    // Create the encoder processing block
    var encoderBlock = mjpegSettings.CreateBlock();

    // Add the encoder block to your processing pipeline
    pipeline.AddBlock(encoderBlock);

    // Additional pipeline configuration
    // ...

    // Start the encoding process
    await pipeline.StartAsync();
}
else
{
    // Handle encoder unavailability
    Console.WriteLine("CPU-based MJPEG encoder is not available on this system.");
}
```

### Quality-to-Size Relationship

The quality setting directly affects both the visual quality and resulting file size:

| Quality Setting | Visual Quality | File Size | Recommended Use Case |
| --- | --- | --- | --- |
| 10-30 | Very Low | Smallest | Archival, minimal bandwidth |
| 31-60 | Low | Small | Web previews, thumbnails |
| 61-80 | Medium | Moderate | Standard recording |
| 81-95 | High | Large | Professional applications |
| 96-100 | Maximum | Largest | Critical visual analysis |

## Intel QuickSync MJPEG Encoder

For systems with compatible Intel hardware, the QuickSync MJPEG encoder offers GPU-accelerated encoding performance. This implementation leverages Intel's QuickSync Video technology to offload encoding operations from the CPU to dedicated media processing hardware.

### Hardware Requirements

- Intel CPU with integrated graphics supporting QuickSync Video
- Supported processor families:
- Intel Core i3/i5/i7/i9 (6th generation or newer recommended)
- Intel Xeon with compatible graphics
- Select Intel Pentium and Celeron processors with HD Graphics

### Features and Advantages

- **Hardware acceleration**: Dedicated media processing engines
- **Quality range**: 10-100 (same as CPU-based encoder)
- **Default quality**: 85
- **Preset profiles**: Four predefined quality configurations
- **Reduced CPU load**: Frees processor resources for other tasks
- **Power efficiency**: Lower energy consumption during encoding
- **Performance gain**: Up to 3x faster than CPU-based encoding (hardware dependent)

### Implementation Examples

#### Basic Implementation

```
// Import required namespaces
using VisioForge.Core.Types.Output;

// Create QuickSync MJPEG encoder with default settings
var qsvEncoder = new QSVMJPEGEncoderSettings();

// Verify hardware support
if (QSVMJPEGEncoderSettings.IsAvailable())
{
    // Set custom quality value
    qsvEncoder.Quality = 90; // Higher quality setting

    // Create and add encoder block
    var encoderBlock = qsvEncoder.CreateBlock();
    pipeline.AddBlock(encoderBlock);

    // Continue pipeline setup
}
else
{
    // Fall back to CPU-based encoder
    Console.WriteLine("QuickSync hardware not detected. Falling back to CPU encoder.");
    var cpuEncoder = new MJPEGEncoderSettings();
    pipeline.AddBlock(cpuEncoder.CreateBlock());
}
```

#### Using Preset Quality Profiles

```
// Create encoder with preset quality profile
var highQualityEncoder = new QSVMJPEGEncoderSettings(VideoQuality.High);

// Or select other preset profiles
var lowQualityEncoder = new QSVMJPEGEncoderSettings(VideoQuality.Low);
var normalQualityEncoder = new QSVMJPEGEncoderSettings(VideoQuality.Normal);
var veryHighQualityEncoder = new QSVMJPEGEncoderSettings(VideoQuality.VeryHigh);

// Check availability and create encoder block
if (QSVMJPEGEncoderSettings.IsAvailable())
{
    var encoderBlock = highQualityEncoder.CreateBlock();
    // Use encoder in pipeline
}
```

### Quality Preset Mapping

The QuickSync implementation provides convenient preset quality profiles that map to specific quality values:

| Preset Profile | Quality Value | Suitable Applications |
| --- | --- | --- |
| Low | 60 | Surveillance, monitoring, archiving |
| Normal | 75 | Standard recording, web content |
| High | 85 | Default for most applications |
| VeryHigh | 95 | Professional video production |

## Performance Optimization Guidelines

Achieving optimal MJPEG encoding performance requires careful consideration of several factors:

### System Configuration Recommendations

1. **Memory allocation**: Ensure sufficient RAM for frame buffering (minimum 8GB recommended)
2. **Storage throughput**: Use SSD storage for best write performance during encoding
3. **CPU considerations**: Multi-core processors benefit the CPU-based encoder
4. **GPU drivers**: Keep Intel graphics drivers updated for QuickSync performance
5. **Background processes**: Minimize competing system processes during encoding

### Code-Level Optimization Techniques

1. **Frame size selection**: Consider downscaling before encoding for better performance
2. **Quality selection**: Balance visual requirements against performance needs
3. **Pipeline design**: Minimize unnecessary processing stages before encoding
4. **Error handling**: Implement graceful fallback between encoder types
5. **Threading model**: Respect the threading model of the VisioForge pipeline

## Best Practices for MJPEG Implementation

To ensure reliable and efficient MJPEG encoding in your applications:

1. **Always check availability**: Use the `IsAvailable()` method before creating encoder instances
2. **Implement encoder fallback**: Have CPU-based encoding as a backup when QuickSync is unavailable
3. **Quality testing**: Test different quality settings with your specific video content
4. **Performance monitoring**: Monitor CPU/GPU usage during encoding to identify bottlenecks
5. **Exception handling**: Handle potential encoder initialization failures gracefully
6. **Version compatibility**: Ensure SDK version compatibility with your development environment
7. **License validation**: Verify proper licensing for your production environment

## Troubleshooting Common Issues

### QuickSync Availability Problems

- Ensure Intel drivers are up-to-date
- Verify BIOS settings haven't disabled integrated graphics
- Check for competing GPU-accelerated applications

### Performance Issues

- Monitor system resource usage during encoding
- Reduce input frame resolution or frame rate if necessary
- Consider quality setting adjustments

### Quality Problems

- Increase quality settings for better visual results
- Examine source material for pre-existing quality issues
- Consider frame pre-processing for problematic source material

## Conclusion

The VisioForge .NET SDK provides flexible MJPEG encoding options suitable for a wide range of development scenarios. By understanding the characteristics and configuration options of both the CPU-based and QuickSync implementations, developers can make informed decisions about which encoder best fits their application requirements.

Whether prioritizing universal compatibility with the CPU-based encoder or leveraging hardware acceleration with the QuickSync implementation, the consistent interface and comprehensive feature set enable efficient video processing while maintaining the frame-independent nature of MJPEG encoding that makes it valuable for specific video processing applications.

---END OF PAGE---


## VP8 and VP9 Video Encoding — Configuration and Tuning
**URL:** https://www.visioforge.com/help/docs/dotnet/general/video-encoders/vp8-vp9/
**Description:** Configure VP8 and VP9 video encoders for optimal streaming, recording, and processing performance in VisioForge .NET applications.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, Editing, WebM, VP8, VP9, C#
**API:** VP9EncoderSettings, VP8EncoderSettings, WebMOutput, QSVVP9EncoderSettings, WebMVideoEncoder

# VP8 and VP9 Encoders in VisioForge .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

This guide shows you how to implement VP8 and VP9 video encoding in VisioForge .NET SDKs. You'll learn about the available encoder options and how to optimize them for your specific application needs.

## Encoder Options Overview

VisioForge SDK provides multiple encoder implementations based on your platform requirements:

### Windows Platform Encoders

[VideoCaptureCore](#) [VideoEditCore](#)

- Software-based VP8 and VP9 encoders configured through the [WebMOutput](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.Output.WebMOutput.html) class

### Cross-Platform X-Engine Options

[VideoCaptureCoreX](#) [VideoEditCoreX](#) [MediaBlocksPipeline](#)

- VP8 software encoder via [VP8EncoderSettings](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.VideoEncoders.VP8EncoderSettings.html)
- VP9 software encoder via [VP9EncoderSettings](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.VideoEncoders.VP9EncoderSettings.html)
- Hardware-accelerated Intel GPU VP9 encoder via [QSVVP9EncoderSettings](https://api.visioforge.org/dotnet/api/VisioForge.Core.Types.X.VideoEncoders.QSVVP9EncoderSettings.html) for integrated GPUs

## Bitrate Control Strategies

All VP8 and VP9 encoders support different bitrate control modes to match your application requirements:

### Constant Bitrate (CBR)

CBR maintains consistent bitrate throughout the encoding process, making it ideal for:

- Live streaming applications
- Scenarios with bandwidth limitations
- Real-time video communication

**Implementation Examples:**

With `WebMOutput` (Windows):

```
var webmOutput = new WebMOutput();
webmOutput.Video_EndUsage = VP8EndUsageMode.CBR;
webmOutput.Video_Encoder = WebMVideoEncoder.VP8;
webmOutput.Video_Bitrate = 2000;  // 2 Mbps
```

With `VP8EncoderSettings`:

```
var vp8 = new VP8EncoderSettings();
vp8.RateControl = VPXRateControl.CBR;
vp8.TargetBitrate = 2000;  // 2 Mbps
```

With `VP9EncoderSettings`:

```
var vp9 = new VP9EncoderSettings();
vp9.RateControl = VPXRateControl.CBR;
vp9.TargetBitrate = 2000;  // 2 Mbps
```

With Intel GPU encoder:

```
var vp9qsv = new QSVVP9EncoderSettings();
vp9qsv.RateControl = QSVVP9EncRateControl.CBR;
vp9qsv.Bitrate = 2000;  // 2 Mbps
```

### Variable Bitrate (VBR)

VBR dynamically adjusts bitrate based on content complexity, best for:

- Non-live video encoding
- Scenarios prioritizing visual quality over file size
- Content with varying visual complexity

**Implementation Examples:**

With `WebMOutput` (Windows):

```
var webmOutput = new WebMOutput();
webmOutput.Video_EndUsage = VP8EndUsageMode.VBR;
webmOutput.Video_Encoder = WebMVideoEncoder.VP8;
webmOutput.Video_Bitrate = 3000;  // 3 Mbps target
```

With `VP8EncoderSettings`:

```
var vp8 = new VP8EncoderSettings();
vp8.RateControl = VPXRateControl.VBR;
vp8.TargetBitrate = 3000;
```

With `VP9EncoderSettings`:

```
var vp9 = new VP9EncoderSettings();
vp9.RateControl = VPXRateControl.VBR;
vp9.TargetBitrate = 3000;
```

With Intel GPU encoder:

```
var vp9qsv = new QSVVP9EncoderSettings();
vp9qsv.RateControl = QSVVP9EncRateControl.VBR;
vp9qsv.Bitrate = 3000;
```

## Quality-Focused Encoding Modes

These modes prioritize consistent visual quality over specific bitrate targets:

### Constant Quality (CQ) Mode

Available for software VP8 and VP9 encoders:

```
var vp8 = new VP8EncoderSettings();
vp8.RateControl = VPXRateControl.CQ;
vp8.CQLevel = 20;  // Quality level (0-63, lower values = better quality)
```

```
var vp9 = new VP9EncoderSettings();
vp9.RateControl = VPXRateControl.CQ;
vp9.CQLevel = 20;
```

### Intel QSV Quality Modes

Intel's hardware encoder supports two quality-focused modes:

**Intelligent Constant Quality (ICQ):**

```
var vp9qsv = new QSVVP9EncoderSettings();
vp9qsv.RateControl = QSVVP9EncRateControl.ICQ;
vp9qsv.ICQQuality = 25;  // 20-27 recommended for balanced quality
```

**Constant Quantization Parameter (CQP):**

```
var vp9qsv = new QSVVP9EncoderSettings();
vp9qsv.RateControl = QSVVP9EncRateControl.CQP;
vp9qsv.QPI = 26;  // I-frame QP
vp9qsv.QPP = 28;  // P-frame QP
```

## VP9 Performance Optimization

VP9 encoders offer additional features for enhanced performance:

### Adaptive Quantization

Improves visual quality by allocating more bits to complex areas:

```
var vp9 = new VP9EncoderSettings();
vp9.AQMode = VPXAdaptiveQuantizationMode.Variance;  // Enable variance-based AQ
```

### Parallel Processing

Speeds up encoding through multi-threading and tile-based processing:

```
var vp9 = new VP9EncoderSettings();
vp9.FrameParallelDecoding = true;  // Enable parallel frame processing
vp9.RowMultithread = true;         // Enable row-based multithreading
vp9.TileColumns = 6;               // Set number of tile columns (log2)
vp9.TileRows = 0;                  // Set number of tile rows (log2)
```

## Error Resilience Settings

Both VP8 and VP9 support error resilience for robust streaming over unreliable networks:

Using `WebMOutput` (Windows):

```
var webmOutput = new WebMOutput();
webmOutput.Video_ErrorResilient = true;  // Enable error resilience
```

Using software encoders:

```
var vpx = new VP8EncoderSettings();  // or VP9EncoderSettings
vpx.ErrorResilient = VPXErrorResilientFlags.Default | VPXErrorResilientFlags.Partitions;
```

## Performance Tuning Options

Optimize encoding performance with these settings:

```
var vpx = new VP8EncoderSettings();  // or VP9EncoderSettings
vpx.CPUUsed = 0;           // Range: -16 to 16, higher values favor speed over quality
vpx.NumOfThreads = 4;      // Specify number of encoding threads
vpx.TokenPartitions = VPXTokenPartitions.Eight;  // Enable parallel token processing
```

## Best Practices for VP8/VP9 Encoding

### Rate Control Selection

Choose the appropriate rate control mode based on your application:

- **CBR** for live streaming and real-time communication
- **VBR** for offline encoding where quality is the priority
- **Quality-based modes** (CQ, ICQ, CQP) for highest possible quality regardless of bitrate

### Performance Optimization

- Adjust `CPUUsed` to balance quality and encoding speed
- Enable multithreading for faster encoding on multi-core systems
- Use tile-based parallelism in VP9 for better hardware utilization

### Error Recovery

- Enable error resilience when streaming over unreliable networks
- Configure token partitioning for improved error recovery
- Consider frame reordering limitations for low-latency applications

### Quality Optimization

- Use adaptive quantization in VP9 for better quality distribution
- Consider two-pass encoding for offline encoding scenarios
- Adjust quantizer settings based on content type and target quality

By following this guide, you'll be able to effectively implement and configure VP8 and VP9 encoders in your VisioForge .NET applications for optimal performance and quality.

---END OF PAGE---


## VisioForge .NET SDKs — Video Capture, Editing & Playback
**URL:** https://www.visioforge.com/help/docs/dotnet/
**Description:** .NET SDKs for video capture, editing, playback, and processing. Cross-platform support for Windows, macOS, Linux, Android, and iOS.
**Tags:** .NET, Streaming, Editing

# .NET SDKs for Professional Media Development

## Introduction to Our .NET SDKs

Our powerful .NET SDKs empower developers to seamlessly integrate advanced video capture, sophisticated video editing, smooth playback, and efficient media processing capabilities into their software applications. These professionally engineered tools provide a complete solution for all your multimedia development needs.

## Multi-Platform Compatibility

All our .NET SDKs are designed with cross-platform functionality in mind, providing robust support across:

- Windows desktop environments
- Linux distributions
- macOS systems
- Android mobile devices
- iOS applications

This versatility ensures your media applications can reach users on virtually any platform without compromising functionality.

## Hardware Acceleration Technologies

Our SDKs leverage cutting-edge GPU-accelerated encoding and decoding technologies to maximize performance:

### Desktop Platforms

- Intel Quick Sync Video for efficient hardware acceleration
- NVIDIA NVENC for superior encoding performance
- AMD VCE (Video Coding Engine) for optimized processing

### Mobile Platforms

- Native hardware encoding and decoding capabilities
- Performance-optimized implementations for battery efficiency

## Getting Started Resources

### SDK Usage Tutorials

- [Installation Guide](install/) - Step-by-step setup instructions
- [SDK Initialization](init/) - Proper initialization procedures
- [System Requirements](system-requirements/) - Detailed compatibility information

## Available SDK Products

### [Video Capture SDK .NET](videocapture/)

Efficiently capture high-quality video from multiple sources including:

- Webcams and USB cameras
- Network IP cameras — [browse supported brands](camera-brands/)
- HDMI capture devices
- Screen recording
- Custom video sources

### [Video Edit SDK .NET](videoedit/)

Professional video editing capabilities including:

- Timeline-based video editing
- Filter and effect application
- Video montage creation
- Format conversion
- Frame-accurate editing

### [Media Player SDK .NET](mediaplayer/)

Feature-rich media playback functionality:

- Multi-format video and audio playback
- Real-time effect application
- Customizable player interfaces
- Streaming support
- Advanced control options

### [Media Blocks SDK .NET](mediablocks/)

Modular building blocks for creating:

- Custom multimedia applications
- Specialized media processing tools
- Cross-platform media solutions
- Integrated workflow systems

## Additional Developer Resources

- [Migration Guide: v15 to v2026](migration-from-v15/) - Step-by-step upgrade instructions
- [Changelog](changelog/) - Detailed version history and updates
- [Feature and Platform Matrix](platform-matrix/) - Compatibility overview
- [API Reference Documentation](https://api.visioforge.org/dotnet/api/index.html) - Complete API specifications

---END OF PAGE---


## Initialize and Configure VisioForge .NET Video SDKs
**URL:** https://www.visioforge.com/help/docs/dotnet/init/
**Description:** Initialize and deinitialize .NET SDKs for video capture, editing, and playback with DirectShow and cross-platform X-engines.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, DirectShow, MediaPlayerCoreX, MediaBlocksPipeline, VideoCaptureCoreX, VideoEditCoreX, Windows, macOS, Linux, Android, iOS, Capture, Playback, Editing

# Initialization

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Type of SDK engines

All SDKs contain Windows-only DirectShow-based engines and cross-platform X-engines.

### Windows-only engines

- VideoCaptureCore
- VideoEditCore
- MediaPlayerCore

### X-engines

- VideoCaptureCoreX
- VideoEditCoreX
- MediaPlayerCoreX
- MediaBlocksPipeline

X-engines require additional initialization and de-initialization steps.

## SDK initialization and de-initialization for X-engines

All X-engines (`VideoCaptureCoreX`, `VideoEditCoreX`, `MediaPlayerCoreX`, `MediaBlocksPipeline`) use one shared initialization step. You must initialize the SDK before any SDK class usage and de-initialize the SDK before the application exits. The Windows-only DirectShow cores (`VideoCaptureCore`, `VideoEditCore`, `MediaPlayerCore`) need no initialization step.

### Calling InitSDKAsync

The recommended way is asynchronous, so a cold GStreamer startup (native library resolution, plugin registry scan) does not freeze the calling thread:

```
await VisioForge.Core.VisioForgeX.InitSDKAsync();
```

The blocking form is equivalent and may be called from any thread. Use it directly when initialization must run on a specific thread (see the note below):

```
VisioForge.Core.VisioForgeX.InitSDK();
```

`InitSDKAsync` offloads `InitSDK` to a thread-pool thread via `Task.Run`. GStreamer / GLib unhandled-exception handlers are bound to whichever thread first triggered initialization, so if your application relies on init running on a particular thread (for thread-static GLib state), call `InitSDK()` on that thread directly.

### De-initialization

```
VisioForge.Core.VisioForgeX.DestroySDK();
```

`DestroySDK` has no asynchronous variant and may be called from any thread.

If the SDK is not properly deinitialized, the application may experience a hang-on exit due to the inability to finalize one of its threads. This issue arises because the SDK continues to operate, preventing the application from closing smoothly. To ensure a clean exit, it is crucial to deinitialize the SDK appropriately based on the UI framework you are using.

For applications developed using different UI frameworks, you can deinitialize the SDK in the `FormClosing` event or another relevant event handler. This approach ensures that the SDK is properly destroyed before the application closes, allowing for all threads to terminate correctly.

Moreover, the SDK can be destroyed from any thread, providing flexibility in how you manage the deinitialization process. Because `DestroySDK` is synchronous, if you want to keep the user interface responsive call it on a background thread (for example via `Task.Run`) — there is no asynchronous `DestroySDK` overload.

Implementing these practices ensures that your application exits smoothly without hanging, providing a seamless experience for the users. Properly managing the SDK deinitialization is crucial for maintaining the stability and performance of your application.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Install VisioForge Media SDKs in Avalonia .NET Apps
**URL:** https://www.visioforge.com/help/docs/dotnet/install/avalonia/
**Description:** Build cross-platform Avalonia apps with multimedia capabilities for Windows, macOS, Linux, Android, and iOS using VisioForge video SDKs.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, C++, Windows, macOS, Linux, Android, iOS, Avalonia, C#, NuGet
**API:** VideoView

# Building Media-Rich Avalonia Applications with VisioForge

## Framework Overview

Avalonia UI stands out as a versatile, truly cross-platform .NET UI framework with support spanning desktop environments (Windows, macOS, Linux) and mobile platforms (iOS and Android). VisioForge enhances this ecosystem through the specialized `VisioForge.DotNet.Core.UI.Avalonia` package, which delivers high-performance multimedia controls tailored for Avalonia's architecture.

Our suite of SDKs empowers Avalonia developers with extensive multimedia capabilities:

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Setup and Configuration

### Essential Package Installation

Creating an Avalonia application with VisioForge multimedia capabilities requires installing several key NuGet components:

1. Avalonia-specific UI layer: `VisioForge.DotNet.Core.UI.Avalonia`
2. Core functionality package: `VisioForge.DotNet.Core` (or specialized SDK variant)
3. Platform-specific native bindings (covered in detail in later sections)

Add these to your project manifest (`.csproj`):

```
<ItemGroup>
  <PackageReference Include="VisioForge.DotNet.Core.UI.Avalonia" Version="2026.*" />
  <PackageReference Include="VisioForge.DotNet.Core" Version="2026.*" />
  <!-- Platform-specific packages will be added in conditional ItemGroups -->
</ItemGroup>
```

### Avalonia Initialization Architecture

A key advantage of VisioForge's Avalonia integration is its seamless initialization model. Unlike some frameworks requiring explicit global setup, the Avalonia controls become available immediately once the core package is referenced.

Your standard Avalonia bootstrap code in `Program.cs` remains unchanged:

```
using Avalonia;
using System;

namespace YourAppNamespace;

class Program
{
    [STAThread]
    public static void Main(string[] args) => BuildAvaloniaApp()
        .StartWithClassicDesktopLifetime(args);

    public static AppBuilder BuildAvaloniaApp()
        => AppBuilder.Configure<App>()
            .UsePlatformDetect()
            .LogToTrace();
}
```

### Implementing the VideoView Component

The `VideoView` control serves as the central rendering element. Integrate it into your `.axaml` files using:

1. First, declare the VisioForge namespace:

```
xmlns:vf="clr-namespace:VisioForge.Core.UI.Avalonia;assembly=VisioForge.Core.UI.Avalonia"
```

1. Then, implement the control in your layout structure:

```
<vf:VideoView
    Grid.Row="0"
    HorizontalAlignment="Stretch"
    VerticalAlignment="Stretch"
    x:Name="videoView"
    Background="Black"/>
```

This control adapts automatically to the platform-specific rendering pipeline while maintaining a consistent API surface.

## Desktop Platform Integration

### Windows Implementation Guide

Windows deployment requires specific native components packaged as NuGet references.

#### Core Windows Components

Add the following Windows-specific packages to your desktop project:

```
<ItemGroup Condition="$([MSBuild]::IsOsPlatform('Windows'))">
  <PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.*" />
</ItemGroup>
```

#### Advanced Media Format Support

For extended codec compatibility, include the size-optimized UPX variant of the libAV libraries:

```
<ItemGroup Condition="$([MSBuild]::IsOsPlatform('Windows'))">
  <PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64.UPX" Version="2026.*" />
</ItemGroup>
```

The UPX variant delivers significant size optimization while maintaining full codec compatibility.

### macOS Integration

For macOS deployment:

#### Native Binding Package

Include the macOS-specific native components:

```
<ItemGroup Condition="$([MSBuild]::IsOsPlatform('OSX'))">
  <PackageReference Include="VisioForge.CrossPlatform.Core.macOS" Version="2026.*" />
</ItemGroup>
```

#### Framework Configuration

Configure your project with the appropriate macOS framework target:

```
<PropertyGroup Condition="$([MSBuild]::IsOsPlatform('OSX'))">
  <TargetFramework>net10.0-macos</TargetFramework>
  <OutputType>Exe</OutputType>
</PropertyGroup>
```

### Linux Deployment

Linux support includes:

#### Framework Configuration

Set up the appropriate target framework for Linux environments:

```
<PropertyGroup Condition="$([MSBuild]::IsOsPlatform('Linux'))">
  <TargetFramework>net10.0</TargetFramework>
  <OutputType>Exe</OutputType>
</PropertyGroup>
```

#### System Dependencies

For Linux deployment, ensure required system libraries are available on the target system. Unlike Windows and macOS which use NuGet packages, Linux may require system-level dependencies. Consult the VisioForge Linux documentation for specific platform requirements.

## Mobile Development

### Android Configuration

Android implementation requires additional steps unique to Avalonia's Android integration model:

#### Java Interoperability Layer

The VisioForge Android implementation requires a binding bridge between .NET and Android native APIs:

1. Obtain the Java binding project from the [VisioForge samples repository](https://github.com/visioforge/.Net-SDK-s-samples) in the `AndroidDependency` directory
2. Pick the binding project that matches the .NET target you build against - the folder ships one `VisioForge.Core.Android.X{N}.csproj` per supported .NET version (e.g., `VisioForge.Core.Android.X9.csproj` for .NET 9, `VisioForge.Core.Android.X10.csproj` for .NET 10). If your .NET target isn't listed, pick the closest supported one.
3. Reference this project in your Android head project:

```
<ItemGroup>
  <ProjectReference Include="..\..\path\to\VisioForge.Core.Android.X10.csproj" />
</ItemGroup>
```

#### Android-Specific Package

Add the Android redistributable package:

```
<ItemGroup>
  <PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.*" />
</ItemGroup>
```

#### Runtime Permissions

Configure the `AndroidManifest.xml` with appropriate permissions:

- `android.permission.CAMERA`
- `android.permission.RECORD_AUDIO`
- `android.permission.READ_EXTERNAL_STORAGE`
- `android.permission.WRITE_EXTERNAL_STORAGE`
- `android.permission.INTERNET`

### iOS Development

iOS integration with Avalonia requires:

#### Native Components

Add the iOS-specific redistributable to your iOS head project:

```
<ItemGroup>
  <!-- The iOS redist version trails the SDK version on purpose - it tracks the
       GStreamer-iOS rebuild cadence, not the wrapper release. Do not bump it to
       match VisioForge.DotNet.*; there is no 2026.x on nuget.org. -->
  <PackageReference Include="VisioForge.CrossPlatform.Core.iOS" Version="2025.12.0" />
</ItemGroup>
```

#### Important Implementation Notes

- Physical device testing is essential, as simulator support is limited
- Update your `Info.plist` with privacy descriptions:
- `NSCameraUsageDescription` for camera access
- `NSMicrophoneUsageDescription` for audio recording

## Performance Engineering

Maximize application performance with these Avalonia-specific optimizations:

1. Enable hardware acceleration when supported by the underlying platform
2. Implement adaptive resolution scaling based on device capabilities
3. Optimize memory usage patterns, especially for mobile targets
4. Utilize Avalonia's compositing model effectively by minimizing visual tree complexity around the `VideoView`

## Troubleshooting Guide

### Media Format Problems

- **Playback failures**:
- Ensure all platform packages are correctly referenced
- Verify codec availability for the target media format
- Check for platform-specific format restrictions

### Performance Concerns

- **Slow playback or rendering**:
- Enable hardware acceleration where available
- Reduce processing resolution when appropriate
- Utilize Avalonia's threading model correctly

### Deployment Challenges

- **Platform-specific runtime errors**:
- Validate target framework specifications
- Verify native dependency availability
- Ensure proper provisioning for mobile targets

## Multi-Platform Project Architecture

VisioForge's Avalonia integration excels with a specialized multi-headed project structure. The `SimplePlayerMVVM` sample demonstrates this architecture:

- **Core shared project** (`SimplePlayerMVVM.csproj`): Contains cross-platform views, view models, and shared logic with conditional multi-targeting:

  ```
  <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
      <Nullable>enable</Nullable>
      <LangVersion>latest</LangVersion>
      <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
    </PropertyGroup>
    <ItemGroup>
      <AvaloniaResource Include="Assets\**" />
    </ItemGroup>
    <PropertyGroup Condition="$([MSBuild]::IsOsPlatform('Windows'))">
      <TargetFrameworks>net10.0-android;net10.0-ios;net10.0-windows</TargetFrameworks>
    </PropertyGroup>
    <PropertyGroup Condition="$([MSBuild]::IsOsPlatform('OSX'))">
      <TargetFrameworks>net10.0-android;net10.0-ios;net10.0-macos</TargetFrameworks>
    </PropertyGroup>
    <PropertyGroup Condition="$([MSBuild]::IsOsPlatform('Linux'))">
      <TargetFrameworks>net10.0-android;net10.0</TargetFrameworks>
    </PropertyGroup>
    <ItemGroup>
      <PackageReference Include="Avalonia" Version="12.0.5" />
      <!-- Additional Avalonia references -->
    </ItemGroup>
    <ItemGroup>
      <PackageReference Include="VisioForge.DotNet.MediaPlayer" Version="2026.*" />
      <PackageReference Include="VisioForge.DotNet.Core.UI.Avalonia" Version="2026.*" />
    </ItemGroup>
  </Project>
  ```
- **Platform-specific head projects**:
- `SimplePlayerMVVM.Android.csproj`: Contains Android-specific configuration and binding references
- `SimplePlayerMVVM.iOS.csproj`: Handles iOS initialization and dependencies
- `SimplePlayerMVVM.Desktop.csproj`: Manages desktop platform detection and appropriate redistributable loading

For simpler desktop-only applications, `SimpleVideoCaptureA.csproj` provides a streamlined model with platform detection occurring within a single project file.

## Conclusion

VisioForge's Avalonia integration offers a sophisticated approach to cross-platform multimedia development that leverages Avalonia's unique architectural advantages. Through carefully structured platform-specific components and a unified API, developers can build rich media applications that span desktop and mobile platforms without compromising on performance or capabilities.

For complete code examples and sample applications, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples), which contains specialized Avalonia demonstrations in the Video Capture SDK X and Media Player SDK X sections.

---END OF PAGE---


## Install VisioForge .NET SDKs — NuGet, Visual Studio, Rider
**URL:** https://www.visioforge.com/help/docs/dotnet/install/
**Description:** Setup files or NuGet packages. Target frameworks for Windows, macOS, iOS, Android, and Linux. SDK initialization, VideoView controls, and native dependencies.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, DirectShow, Windows, macOS, Linux, Android, iOS, Capture, Streaming
**API:** VideoView, VideoCaptureCore, VideoCaptureCoreX

# VisioForge .NET SDKs Installation Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

VisioForge offers powerful multimedia SDKs for .NET developers that enable advanced video capture, editing, playback, and media processing capabilities in your applications. This guide covers everything you need to know to properly install and configure our SDKs in your development environment.

## Available .NET SDKs

VisioForge provides several specialized SDKs to address different multimedia needs:

- [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) - For capturing video from cameras, screen recording, and streaming
- [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) - For video editing, processing, and format conversion
- [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) - For building custom media processing pipelines
- [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) - For creating custom media players with advanced features

## Installation Methods

You can install our SDKs using two primary methods:

### Using Setup Files

The setup file installation method is recommended for Windows development environments. This approach:

1. Automatically installs all required dependencies
2. Configures Visual Studio integration
3. Includes sample projects to help you get started quickly
4. Provides documentation and additional resources

Setup files can be downloaded from the respective SDK product pages on our website.

### Using NuGet Packages

For cross-platform development or CI/CD pipelines, our NuGet packages offer flexibility and easy integration.

Install the package for the SDK you bought — each one pulls `VisioForge.DotNet.Core` in as a dependency, so you never reference `Core` directly:

```
Install-Package VisioForge.DotNet.VideoCapture   # Video Capture SDK .Net
Install-Package VisioForge.DotNet.VideoEdit      # Video Edit SDK .Net
Install-Package VisioForge.DotNet.MediaPlayer    # Media Player SDK .Net
Install-Package VisioForge.DotNet.MediaBlocks    # Media Blocks SDK .Net
```

Additional UI-specific packages may be required depending on your target platform:

```
Install-Package VisioForge.DotNet.Core.UI.MAUI
Install-Package VisioForge.DotNet.Core.UI.WinUI
Install-Package VisioForge.DotNet.Core.UI.Avalonia
Install-Package VisioForge.DotNet.Core.UI.Uno
```

## IDE Integration and Setup

Our SDKs seamlessly integrate with popular .NET development environments:

### Visual Studio Integration

[Visual Studio](visual-studio/) offers the most complete experience with our SDKs:

- Full IntelliSense support for SDK components
- Built-in debugging for media processing components
- Designer support for visual controls
- NuGet package management

For detailed Visual Studio setup instructions, see our [Visual Studio integration guide](visual-studio/).

### JetBrains Rider Integration

[Rider](rider/) provides excellent cross-platform development support:

- Full code completion for SDK APIs
- Smart navigation features for exploring SDK classes
- Integrated NuGet package management
- Cross-platform debugging capabilities

For Rider-specific instructions, visit our [Rider integration documentation](rider/).

### Visual Studio for Mac

[Visual Studio for Mac](visual-studio-mac/) users can develop applications for macOS, iOS, and Android:

- Built-in NuGet package manager for installing SDK components
- Project templates for quick setup
- Integrated debugging tools

Learn more in our [Visual Studio for Mac setup guide](visual-studio-mac/).

## Platform-Specific Configuration

### Target Framework Configuration

Each operating system requires specific target framework settings for optimal compatibility:

#### Windows Applications

Windows applications must use the `-windows` target framework suffix:

```
<TargetFramework>net8.0-windows</TargetFramework>
```

This enables access to Windows-specific APIs and UI frameworks like WPF and Windows Forms.

#### Android Development

Android projects require the `-android` framework suffix:

```
<TargetFramework>net8.0-android</TargetFramework>
```

Ensure that Android workloads are installed in your development environment:

```
dotnet workload install android
```

#### iOS Development

iOS applications must use the `-ios` target framework:

```
<TargetFramework>net8.0-ios</TargetFramework>
```

iOS development requires a Mac with Xcode installed, even when using Visual Studio on Windows.

#### macOS Applications

macOS native applications use either the `-macos` or `-maccatalyst` framework:

```
<TargetFramework>net8.0-macos</TargetFramework>
```

For .NET MAUI applications targeting macOS, use:

```
<TargetFramework>net8.0-maccatalyst</TargetFramework>
```

#### Linux Development

Linux applications use the standard target framework without a platform suffix:

```
<TargetFramework>net8.0</TargetFramework>
```

Ensure required .NET workloads are installed:

```
dotnet workload install linux
```

## Special Framework Support

### .NET MAUI Applications

[MAUI projects](maui/) require special configuration:

- Add the `VisioForge.DotNet.Core.UI.MAUI` NuGet package
- Configure platform-specific permissions in your project
- Use MAUI-specific video view controls

See our [detailed MAUI guide](maui/) for complete instructions.

### Avalonia UI Framework

[Avalonia projects](avalonia/) provide a cross-platform UI alternative:

- Install the `VisioForge.DotNet.Core.UI.Avalonia` package
- Use Avalonia-specific video rendering controls
- Configure platform-specific dependencies

Our [Avalonia integration guide](avalonia/) provides complete setup instructions.

### Uno Platform Applications

[Uno Platform projects](uno/) enable building applications for Windows, Android, iOS, macOS, and Linux from a single codebase:

- Add the `VisioForge.DotNet.Core.UI.Uno` NuGet package
- Use Uno Platform-specific video view controls
- Configure platform-specific redistributables

See our [Uno Platform guide](uno/) for complete setup instructions.

### Unity

[Unity](unity/) integration uses a ready-to-import `.unitypackage` instead of NuGet:

- Self-contained for Unity 6 on Windows x64 — managed SDK, native runtime, and sample scenes
- No source build, no NuGet, and no external dependencies
- Video renders into a Unity `RawImage` via the bundled scripts

See our [Unity installation guide](unity/) for the step-by-step setup.

## SDK Initialization for Cross-Platform Engines

Our SDKs include both Windows-specific DirectShow engines (like `VideoCaptureCore`) and cross-platform X-engines (like `VideoCaptureCoreX`). The X-engines require explicit initialization and cleanup.

### Initializing the SDK

Before using any X-engine components, initialize the SDK:

```
// Initialize at application startup
VisioForge.Core.VisioForgeX.InitSDK();

// Or use the async version
await VisioForge.Core.VisioForgeX.InitSDKAsync();
```

### Cleaning Up Resources

When your application exits, properly release resources:

```
// Clean up at application exit (sync — DestroySDK has no async variant)
VisioForge.Core.VisioForgeX.DestroySDK();
```

Failing to initialize or clean up properly may result in memory leaks or unstable behavior.

## Video Rendering Controls

Each UI framework requires specific video view controls to display media content:

### Windows Forms

```
// Add reference to VisioForge.DotNet.Core
using VisioForge.Core.UI.WinForms;

// In your form
videoView = new VideoView();
this.Controls.Add(videoView);
```

### WPF Applications

```
// Add reference to VisioForge.DotNet.Core
using VisioForge.Core.UI.WPF;

// In your XAML
<vf:VideoView x:Name="videoView" />
```

### MAUI Applications

```
// Add reference to VisioForge.DotNet.Core.UI.MAUI
using VisioForge.Core.UI.MAUI;

// In your XAML
<vf:VideoView x:Name="videoView" />
```

### Avalonia UI

```
// Add reference to VisioForge.DotNet.Core.UI.Avalonia
using VisioForge.Core.UI.Avalonia;

// In your XAML
<vf:VideoView Name="videoView" />
```

## Native Dependencies Management

Our SDKs leverage native libraries for optimal performance. These dependencies must be properly managed for deployment:

- Windows: Included automatically with setup installation or NuGet packages
- macOS/iOS: Bundled with NuGet packages but require proper app signing
- Android: Included in NuGet packages with proper architecture support
- Linux: May require additional system packages depending on distribution

For detailed deployment instructions, see our [deployment guide](../deployment-x/).

## Troubleshooting Common Installation Issues

If you encounter issues during installation:

1. Verify target framework compatibility with your project type
2. Ensure all required workloads are installed (`dotnet workload list`)
3. Check for dependency conflicts in your project
4. Confirm proper SDK initialization for X-engines
5. Review platform-specific requirements in our documentation

## Sample Code and Resources

We maintain an extensive collection of sample applications on our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) to help you get started quickly with our SDKs.

These examples cover common scenarios like:

- Video capture from cameras and screens
- Media playback with custom controls
- Video editing and processing
- Cross-platform development

Visit our repository for the latest code examples and best practices for using our SDKs.

---

For additional support or questions, please contact our technical support team or visit our documentation portal.

---END OF PAGE---


## Install VisioForge .NET SDKs in MAUI Apps via NuGet
**URL:** https://www.visioforge.com/help/docs/dotnet/install/maui/
**Description:** Add video capture, playback, and editing to .NET MAUI apps. NuGet setup for Windows, Android, iOS, and macOS with VisioForge VideoView controls.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, C++, MediaPlayerCoreX, Windows, macOS, Android, iOS, MAUI, Playback, C#, NuGet
**API:** VideoView, MediaPlayerCoreX

# Integrating VisioForge SDKs with .NET MAUI Applications

## Overview

.NET Multi-platform App UI (MAUI) enables developers to build cross-platform applications for mobile and desktop from a single codebase. VisioForge provides comprehensive support for MAUI applications through the `VisioForge.DotNet.Core.UI.MAUI` NuGet package (namespace: `VisioForge.Core.UI.MAUI`), which contains specialized UI controls designed specifically for the .NET MAUI platform.

Our SDKs enable powerful multimedia capabilities across all MAUI-supported platforms:

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

Looking for a working tutorial?

Once the packages are installed, walk through the [.NET MAUI Video Player Guide](../../mediaplayer/guides/maui-player/) — a full `VideoView` + `MediaPlayerCoreX` implementation with file picker, seek, and volume that runs on iOS, Android, macOS, and Windows from one codebase.

## Getting Started

### Installation

To begin using VisioForge with your MAUI project, install the required NuGet packages:

1. The SDK package for the product you are using - one of:
2. `VisioForge.DotNet.VideoCapture` - camera, screen and IP camera capture (`VideoCaptureCoreX`)
3. `VisioForge.DotNet.MediaPlayer` - file and network playback (`MediaPlayerCoreX`)
4. `VisioForge.DotNet.VideoEdit` - timeline editing and rendering (`VideoEditCoreX`)
5. `VisioForge.DotNet.MediaBlocks` - custom pipelines (`MediaBlocksPipeline`)
6. The core UI package: `VisioForge.DotNet.Core.UI.MAUI` - the `VideoView` control
7. Platform-specific redistributable (detailed in platform sections below)

```
<ItemGroup>
  <!-- Replace with the SDK package your app uses. -->
  <PackageReference Include="VisioForge.DotNet.MediaPlayer" Version="2026.*" />
  <PackageReference Include="VisioForge.DotNet.Core.UI.MAUI" Version="2026.*" />
</ItemGroup>
```

`VisioForge.DotNet.Core.UI.MAUI` only supplies the `VideoView` control. On its own it cannot compile `VideoCaptureCoreX`, `MediaPlayerCoreX` or `VideoEditCoreX` - the SDK package above is what brings those in.

### SDK Initialization

Proper initialization is essential for the VisioForge SDKs to function correctly within your MAUI application. This process must be completed in your `MauiProgram.cs` file.

```
using SkiaSharp.Views.Maui.Controls.Hosting;
using VisioForge.Core.UI.MAUI;

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
          .UseMauiApp<App>()
          // Initialize the SkiaSharp package by adding the below line of code
          .UseSkiaSharp()
          // Initialize the VisioForge MAUI package by adding the below line of code
          .ConfigureMauiHandlers(handlers => handlers.AddVisioForgeHandlers())
          // After initializing the VisioForge MAUI package, optionally add additional fonts
          .ConfigureFonts(fonts =>
          {
              fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
              fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
          });

        // Continue initializing your .NET MAUI App here
        return builder.Build();
    }
}
```

`AddVisioForgeHandlers` registers the `VideoView` handler. It does not load the native stack - that is a separate call, and it must run before the first `VideoCaptureCoreX`, `MediaPlayerCoreX`, `VideoEditCoreX` or `MediaBlocksPipeline` is constructed. Without it the constructor throws `DllNotFoundException` on a clean machine:

```
using VisioForge.Core;

// Async initialization (recommended - the first call builds the GStreamer registry
// and can take hundreds of milliseconds, which would freeze the UI thread).
await VisioForgeX.InitSDKAsync();

// Or synchronous initialization.
VisioForgeX.InitSDK();
```

Release the SDK when the page or the application shuts down:

```
VisioForgeX.DestroySDK();
```

## Using VisioForge Controls in XAML

The `VideoView` control is the primary interface for displaying video content in your MAUI application. To use VisioForge controls in your XAML files:

1. Add the VisioForge namespace to your XAML file:

```
xmlns:vf="clr-namespace:VisioForge.Core.UI.MAUI;assembly=VisioForge.Core.UI.MAUI"
```

1. Add the VideoView control to your layout:

```
<vf:VideoView Grid.Row="0"
                HorizontalOptions="FillAndExpand"
                VerticalOptions="FillAndExpand"
                x:Name="videoView"
                Background="Black"/>
```

The VideoView control adapts to the native rendering capabilities of each platform while providing a consistent API for your application code.

## Platform-Specific Configuration

### Android Implementation

Android requires additional configuration steps to ensure proper operation:

#### 1. Add Java Bindings Library

The VisioForge SDK relies on native Android functionality that requires a custom Java bindings library:

1. Clone the binding library from our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/AndroidDependency)
2. Pick the binding project that matches the .NET target you build against - the folder ships one `VisioForge.Core.Android.X{N}.csproj` per supported .NET version (e.g., `VisioForge.Core.Android.X9.csproj` for .NET 9, `VisioForge.Core.Android.X10.csproj` for .NET 10). If your .NET target isn't listed, pick the closest supported one.
3. Add the reference to your project file:

```
<ItemGroup Condition="$(TargetFramework.Contains('-android'))">
  <ProjectReference Include="..\..\..\AndroidDependency\VisioForge.Core.Android.X10.csproj" />
</ItemGroup>
```

#### 2. Add Android Redistributable Package

Include the Android-specific redistributable package:

```
<ItemGroup Condition="$(TargetFramework.Contains('-android'))">
  <PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.*" />
</ItemGroup>
```

#### 3. Android Permissions

Ensure your AndroidManifest.xml includes the necessary permissions for camera, microphone, and storage access depending on your application's functionality. Common required permissions include:

- `android.permission.CAMERA`
- `android.permission.RECORD_AUDIO`
- `android.permission.READ_EXTERNAL_STORAGE`
- `android.permission.WRITE_EXTERNAL_STORAGE`

### iOS Configuration

iOS integration requires fewer steps but has some important considerations:

#### 1. Add iOS Redistributable

Add the iOS-specific package to your project:

```
<ItemGroup Condition="$(TargetFramework.Contains('-ios'))">
  <!-- The iOS redist version trails the SDK version on purpose - it tracks the
       GStreamer-iOS rebuild cadence, not the wrapper release. Do not bump it to
       match VisioForge.DotNet.*; there is no 2026.x on nuget.org. -->
  <PackageReference Include="VisioForge.CrossPlatform.Core.iOS" Version="2025.12.0" />
</ItemGroup>
```

#### 2. Important Notes for iOS Development

- **Use physical devices**: The SDK requires testing on physical iOS devices rather than simulators for full functionality.
- **Privacy descriptions**: Add the necessary usage description strings in your Info.plist file for camera and microphone access:
- `NSCameraUsageDescription`
- `NSMicrophoneUsageDescription`

### macOS Configuration

For macOS Catalyst applications:

#### 1. Configure Runtime Identifiers

To ensure your application works correctly on both Intel and Apple Silicon Macs, specify the appropriate runtime identifiers:

```
<PropertyGroup Condition="$([MSBuild]::IsOSPlatform('osx')) AND '$([System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture)' == 'X64' AND $(TargetFramework.Contains('-maccatalyst'))">
  <RuntimeIdentifier>maccatalyst-x64</RuntimeIdentifier>
</PropertyGroup>
<PropertyGroup Condition="$([MSBuild]::IsOSPlatform('osx')) AND '$([System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture)' == 'Arm64' AND $(TargetFramework.Contains('-maccatalyst'))">
  <RuntimeIdentifier>maccatalyst-arm64</RuntimeIdentifier>
</PropertyGroup>
```

#### 2. Enable Trimming

For optimal performance on macOS, enable the PublishTrimmed option:

```
<PublishTrimmed Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'maccatalyst'">true</PublishTrimmed>
```

For more detailed information about macOS deployment, refer to our [macOS](../../deployment-x/macOS/) documentation page.

### Windows Configuration

For Windows applications, you need to include several redistributable packages:

#### 1. Add Base Windows Redistributables

Include the core Windows packages:

```
<ItemGroup Condition="$(TargetFramework.Contains('-windows'))">
  <PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.*" />
</ItemGroup>
```

#### 2. Add Extended Codec Support (Optional but Recommended)

For enhanced media format support, include the libAV (FFMPEG) package:

```
<ItemGroup Condition="$(TargetFramework.Contains('-windows'))">
  <PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.*" />
</ItemGroup>
```

### Performance Optimization

For optimal performance across platforms:

1. Use hardware acceleration when available
2. Adjust video resolution based on the target device capabilities
3. Consider memory constraints on mobile devices when processing large media files

## Troubleshooting Common Issues

- **Blank video display**: Ensure proper permissions are granted on mobile platforms
- **Missing codecs**: Verify all platform-specific redistributable packages are correctly installed
- **Performance issues**: Check that hardware acceleration is enabled when available
- **Deployment errors**: Confirm runtime identifiers are correctly specified for the target platform

## Conclusion

The VisioForge SDK provides a comprehensive solution for adding powerful multimedia capabilities to your .NET MAUI applications. By following the platform-specific setup instructions and best practices outlined in this guide, you can create rich cross-platform applications with advanced video and audio features.

For additional examples and sample code, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

## Next Steps

- [.NET MAUI Video Player Guide](../../mediaplayer/guides/maui-player/) — complete `VideoView` tutorial with seek, volume, and file picker
- [Avalonia Player Guide](../../mediaplayer/guides/avalonia-player/) — desktop-first cross-platform alternative (includes Linux)
- [Android Player Guide](../../mediaplayer/guides/android-player/) — Android-only deployment details

---END OF PAGE---


## Install VisioForge SDK in JetBrains Rider — NuGet Setup
**URL:** https://www.visioforge.com/help/docs/dotnet/install/rider/
**Description:** Add VisioForge .NET SDKs to Rider projects via NuGet. .NET 6/7/8/9, macOS/Windows/Linux. Package references, native dependencies, troubleshooting.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS, WPF, Avalonia, NuGet
**API:** VideoView

# .Net SDKs Integration with JetBrains Rider

## Introduction

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

This comprehensive guide walks you through the process of installing and configuring VisioForge .Net SDKs within JetBrains Rider, a powerful cross-platform IDE for .NET development. While we'll use a Windows application with WPF as our primary example, these installation steps can be readily adapted for macOS, iOS, or Android applications as well. JetBrains Rider provides a consistent development experience across Windows, macOS, and Linux platforms, making it an excellent choice for cross-platform .NET development.

## Creating Your Project

### Setting Up a Modern Project Structure

Begin by launching JetBrains Rider and creating a new project. For this tutorial, we'll use WPF (Windows Presentation Foundation) as our framework. It's crucial to utilize the modern project format, which provides enhanced compatibility with VisioForge SDKs and offers a more streamlined development experience.

1. Open JetBrains Rider
2. Select "Create New Solution" from the welcome screen
3. Choose "WPF Application" from the available templates
4. Configure your project settings, ensuring you select the modern project format
5. Click "Create" to generate your project structure

## Adding Required NuGet Packages

### Installing the Main SDK Package

Each VisioForge SDK has a corresponding main package that provides core functionality. You'll need to select the appropriate package based on which SDK you're working with.

1. Right-click on your project in the Solution Explorer
2. Select the "Manage NuGet Packages" menu item
3. In the NuGet Package Manager, search for the VisioForge package that corresponds to your desired SDK
4. Select the latest stable version and click "Install"

### Available Main SDK Packages

Choose from the following main packages based on your development needs:

- [VisioForge.DotNet.VideoCapture](https://www.nuget.org/packages/VisioForge.DotNet.VideoCapture) - For applications requiring video capture functionality
- [VisioForge.DotNet.VideoEdit](https://www.nuget.org/packages/VisioForge.DotNet.VideoEdit) - For video editing and processing applications
- [VisioForge.DotNet.MediaPlayer](https://www.nuget.org/packages/VisioForge.DotNet.MediaPlayer) - For media playback applications
- [VisioForge.DotNet.MediaBlocks](https://www.nuget.org/packages/VisioForge.DotNet.MediaBlocks) - For applications requiring modular media processing capabilities

### Adding the UI Package, if needed

Main SDK package contains the core UI components for WinForms, WPF, Android, and Apple.

For other platforms, you'll need to install the appropriate UI package that corresponds to your chosen UI framework.

### Available UI Packages

Depending on your target platform and UI framework, choose from these UI packages:

- Core package contains the core UI components For WinForms, WPF, and Apple
- [VisioForge.DotNet.Core.UI.WinUI](https://www.nuget.org/packages/VisioForge.DotNet.Core.UI.WinUI) - For Windows applications using the modern WinUI framework
- [VisioForge.DotNet.Core.UI.MAUI](https://www.nuget.org/packages/VisioForge.DotNet.Core.UI.MAUI) - For cross-platform applications using .NET MAUI
- [VisioForge.DotNet.Core.UI.Avalonia](https://www.nuget.org/packages/VisioForge.DotNet.Core.UI.Avalonia) - For cross-platform applications using Avalonia UI

## Integrating VideoView Control (Optional)

### Adding Video Preview Capabilities

If your application requires video preview functionality, you'll need to add the VideoView control to your user interface. This can be accomplished either through XAML markup or programmatically in your code-behind file. Below, we'll demonstrate how to add it via XAML.

#### Step 1: Add the WPF Namespace

First, add the necessary namespace reference to your XAML file:

```
xmlns:wpf="clr-namespace:VisioForge.Core.UI.WPF;assembly=VisioForge.Core"
```

#### Step 2: Add the VideoView Control

Then, add the VideoView control to your layout:

```
<wpf:VideoView
    Width="640"
    Height="480"
    Margin="10,10,0,0"
    HorizontalAlignment="Left"
    VerticalAlignment="Top"/>
```

This control provides a canvas where video content can be displayed in real-time, essential for applications that involve video capture, editing, or playback.

## Adding Required Redistribution Packages

### Platform-Specific Dependencies

Depending on your target platform, chosen product, and the specific engine you're utilizing, additional redistribution packages may be needed to ensure proper functionality across all deployment environments.

For comprehensive information about which redistribution packages are required for your specific scenario, please consult the Deployment documentation page for your selected VisioForge product. These resources provide detailed guidance on:

- Required system dependencies
- Platform-specific considerations
- Deployment optimization strategies
- Runtime requirements

Following these deployment guidelines will ensure your application functions correctly on end-user systems without missing dependencies or runtime errors.

## Additional Resources

For more examples and detailed implementation guides, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples), which contains numerous code samples demonstrating various features and integration scenarios.

Our documentation portal also offers comprehensive API references, detailed tutorials, and best practice guides to help you make the most of VisioForge SDKs in your JetBrains Rider projects.

## Conclusion

By following this installation guide, you've successfully integrated VisioForge .Net SDKs with JetBrains Rider, setting the foundation for developing powerful media applications. The combination of VisioForge's robust media processing capabilities and JetBrains Rider's intelligent development environment provides an ideal platform for creating sophisticated media applications across multiple platforms.

---END OF PAGE---


## Install VisioForge media SDKs in Unity 6 — Setup Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/install/unity/
**Description:** Set up VisioForge media SDKs in Unity 6 — one cumulative .unitypackage for video playback, capture and editing on Windows, Android, macOS, iOS.
**Tags:** Media Blocks SDK, Media Player SDK, Video Capture SDK, Video Edit SDK, .NET, Unity, Windows, Android, macOS, iOS, RTSP, C#
**API:** VisioForgeEnvironment, MediaBlocksPipeline, MediaPlayerCoreX, VideoCaptureCoreX, VideoEditCoreX

# Install VisioForge media SDKs in Unity

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net)

This guide walks through installing the VisioForge **media SDKs** in **Unity 6**. A single, fully self-contained **`.unitypackage`** brings four products into Unity at once — the **Media Blocks SDK .NET** pipeline plus the high-level **Media Player SDK .NET** (`MediaPlayerCoreX`), **Video Capture SDK .NET** (`VideoCaptureCoreX`), and **Video Edit SDK .NET** (`VideoEditCoreX`) engines. The package bundles every supported native runtime in one file — Windows x64, Android, macOS Standalone, and iOS Standalone — and lets Unity pick the right one per Build Target at build time. You do not build anything from source, you do not need NuGet, and there are no external dependencies to install.

The package targets **`netstandard2.1`** managed assemblies. For projects pinned to the older Mono Unity LTS, a legacy `net48` Windows-only flavor is still published — see the spoiler at the bottom of this page.

For what's inside and how to use it, see **[Using VisioForge in Unity](../../general/unity/)** — the overview with the full product and sample catalog. For the five-step shortcut, see the **[Quickstart](../../general/unity/getting-started/)**.

## Requirements

|  |  |
| --- | --- |
| Unity | **6 (6000.x)** — verified on `6000.4.6f1` |
| Build targets shipped | **Windows x64**, **Android arm64**, **macOS Universal arm64+x86\_64**, **iOS device arm64** |
| Managed TFM | **`netstandard2.1`** |
| Mandatory Editor settings | `Api Compatibility Level = .NET Standard 2.1` |

Use a short path on NTFS — not a Dev Drive / ReFS volume

Importing the package writes thousands of small native files, and Unity's import/compile is heavy small-file I/O. On a Dev Drive (ReFS) that is **dramatically slower** (a cold import can take many minutes instead of seconds) and is more prone to the `EPERM rename` race. Keep the project on a plain **NTFS** drive with a short root path, e.g. `C:\unity\MyApp`. Unity's package cache also produces deep paths that can overflow Windows' 260-character `MAX_PATH`.

## Download

Download the latest cumulative package — Windows + Android + macOS + iOS in one file:

[**VisioForge.MediaBlocks.Unity.unitypackage**](https://files.visioforge.com/unity/VisioForge.MediaBlocks.Unity.unitypackage)

```
https://files.visioforge.com/unity/VisioForge.MediaBlocks.Unity.unitypackage
```

## Step 1 — Create or open a Unity project

Use an existing Unity 6 project or create a new one (any template). Keep the project root on a short NTFS path (see the warning above).

The sample scenes render video into a uGUI `RawImage`, so the project needs the **uGUI** package (`com.unity.ugui`) — every Unity Hub template ships it, but a hand-trimmed project may not. No render pipeline is required: the scenes work on Built-in, URP and HDRP alike.

## Step 2 — Import the package

In the Editor: **Assets → Import Package → Custom Package…**, select the downloaded `.unitypackage`, and click **Import** (keep all items checked).

The package adds:

| Content | Location | Purpose |
| --- | --- | --- |
| Managed SDK (`netstandard2.1`) + dependencies | `Assets/Plugins/` (+ `Android/`, `macOS/`, `iOS/Managed/` subfolders) | the Media Blocks SDK .NET assemblies, per platform |
| Windows native runtime | `Assets/StreamingAssets/VisioForge/x64/` | Windows GStreamer libs and plugins |
| Android native runtime | `Assets/Plugins/Android/libs/arm64-v8a/` | monolithic `libgstreamer_android.so` + Java AAR |
| macOS native runtime | `Assets/Plugins/macOS/` | universal dylibs (arm64+x86\_64) |
| iOS native runtime | `Assets/Plugins/iOS/GStreamerX.framework/` | embedded framework (device arm64) |
| IL2CPP preservation | `Assets/VisioForge/link.xml` | type / member preservation for Android & iOS |
| Reusable scripts | `Assets/Scripts/` | `VisioForgeEnvironment` and `VisioForgeVideoView` helpers plus the six sample scripts |
| Six sample scenes | `Assets/Scenes/` | `SimplePlayer`, `RTSPViewer`, `MediaPlayerX`, `IPCameraX`, `VideoCaptureX`, `VideoEditX` — see the [samples overview](../../general/unity/#samples) |
| One-time setup helper | `Assets/VisioForge/Editor/` | applies the two required project settings |

Per-flavor `PluginImporter` metadata on every native file tells Unity which Build Target each binary belongs to — switching the Build Target in Build Profiles automatically picks the right slot at build time.

## Step 3 — Apply the required project settings

On first import the setup helper shows a dialog asking to apply the required project setting. Click **Apply** — the setting is configured for you.

This setting is **mandatory** — the SDK will not work without it:

- **Api Compatibility Level = .NET Standard 2.1** — the SDK ships as `netstandard2.1` assemblies; the legacy `.NET Framework` setting cannot load them.

Unity's default **Enter Play Mode** behavior (Domain + Scene Reload) is fully supported — you do **not** need to disable Domain Reload. The SDK survives the Editor's Play/Stop reloads.

For mobile targets, also switch **Scripting Backend** to **IL2CPP** — Mono is not supported on Android or iOS by Unity itself. See [Build for Android](../../general/unity/android/) and [Build for iOS](../../general/unity/ios/) for the per-target Build Profile checklists.

## Step 4 — Set the setting manually (only if you clicked Skip)

If you clicked **Skip**, set it by hand:

1. **Api Compatibility Level = .NET Standard 2.1** *Edit → Project Settings → Player → Other Settings → Configuration → Api Compatibility Level*.

## Step 5 — Run a sample scene

In the **Project** window open `Assets/Scenes/SimplePlayer.unity` (double-click it — do not stay on the empty default scene), select the **RawImage** GameObject, set its **File Path** in the Inspector, and press **▶ Play**. Video renders in the Game view and audio plays through the system default device.

The RawImage looks empty until you press Play

The video texture is created at runtime, so the `RawImage` is blank (white) in edit mode.

Next, read the usage guides:

- [Quickstart](../../general/unity/getting-started/) — the five-step path from import to playback.
- [Using VisioForge in Unity](../../general/unity/) — the overview with the full product and sample catalog: file playback, RTSP / IP camera, webcam capture, and timeline editing.

## Build for a target platform

The cumulative `.unitypackage` contains every supported platform, but each Build Target has its own settings and gotchas. Read the matching page:

- [Build for Windows](../../general/unity/windows/) — x86\_64 Editor + Standalone Player.
- [Build for Android](../../general/unity/android/) — IL2CPP arm64, AndroidManifest permissions.
- [Build for macOS](../../general/unity/macos/) — Universal arm64+x86\_64, code-signing.
- [Build for iOS](../../general/unity/ios/) — Xcode export workflow, Info.plist permissions.

## Uninstalling or upgrading the package

A `.unitypackage` has no uninstaller — remove the files manually.

1. **Close the Unity Editor** first — it locks the native DLLs and the `Library/` cache.
2. Delete the VisioForge content from `Assets/`:
3. `Assets/StreamingAssets/VisioForge/` — the Windows native runtime.
4. `Assets/Plugins/Android/libs/arm64-v8a/libgstreamer_android.so`, `libVisioForge_Core.so`, and `Assets/Plugins/Android/visioforge-gstreamer.aar` — the Android runtime.
5. `Assets/Plugins/macOS/*.dylib` and `Assets/Plugins/macOS/ca-certificates.crt` — the macOS runtime.
6. `Assets/Plugins/iOS/GStreamerX.framework/` and `Assets/Plugins/iOS/libVisioForge_Core.a` — the iOS runtime.
7. `Assets/Plugins/` (with `Android/`, `macOS/`, `iOS/Managed/` subfolders) — the managed assemblies, per platform.
8. `Assets/VisioForge/` — the one-time setup helper and `link.xml`.
9. The scripts in `Assets/Scripts/`: the `VisioForgeEnvironment.cs` and `VisioForgeVideoView.cs` helpers plus the six sample scripts — `MediaBlocksPlayer.cs`, `RTSPViewerPlayer.cs`, `MediaPlayerXPlayer.cs`, `IPCameraXViewer.cs`, `VideoCaptureXRecorder.cs`, `VideoEditXRenderer.cs` (plus their `.meta`) — keep any scripts of your own that live in the same folder.
10. The sample scenes in `Assets/Scenes/`: `SimplePlayer.unity`, `RTSPViewer.unity`, `MediaPlayerX.unity`, `IPCameraX.unity`, `VideoCaptureX.unity`, `VideoEditX.unity`.
11. Delete the project's `Library/` folder (next to `Assets/`) to clear the cached import state. Unity regenerates it on the next open (the first launch is slower).

**Upgrading:** import the new `.unitypackage` over the old one — the managed-plugin GUIDs are deterministic, so Unity overwrites the existing assets in place and references are preserved. If you are coming from a much older package or see duplicated DLLs in `Assets/Plugins/`, do a clean removal (steps above) first, then import the new package.

## Troubleshooting

| Symptom | Cause | Fix |
| --- | --- | --- |
| `TypeLoadException` on play | Api Compatibility Level is `.NET Framework`, not `.NET Standard 2.1` | Set it to `.NET Standard 2.1`, or re-import and click **Apply** |
| Editor hangs on "Reloading domain" on Play/Stop | An SDK build older than this release, before the Editor reload guard was added | Update to the latest SDK — its reload guard stops the GStreamer main-loop thread automatically, so Domain Reload is safe |
| Editor crashes on the 2nd Play | `VisioForgeX.DestroySDK()` was called on Stop, then re-initialized | Don't shut the SDK down on Stop — it is process-global and reused; dispose only the per-play pipeline |
| Native runtime not found | Package imported partially, or wrong Build Target's flavor missing from the package | Re-import the package with all items checked; confirm the package contains the platform you targeted |
| No video, errors in the Console after import | The Editor needs a clean reload after the runtime is staged | Restart the Editor |
| `DllNotFoundException` on Android | Scripting Backend is Mono | Switch to IL2CPP |

For the full per-symptom reference, see [Troubleshooting](../../general/unity/troubleshooting/).

## Legacy `net48` Windows-only flavor

 I have an older Unity LTS pinned to Mono — what about the net48 build?

The original Windows-only build of the package targets **`.NET Framework 4.8`** managed assemblies and is still produced for projects that cannot move to `.NET Standard 2.1` (for example, Unity 2019.4 LTS without the modern Api Compatibility option). It ships as a separate `.unitypackage` with `NET48` in the filename, contains only the Windows-x64 native runtime, and uses `.NET Framework` as the Api Compatibility Level. New projects should use the `netstandard2.1` package described above — it covers the same Windows-x64 use case plus every other platform, and Unity 6 defaults to it. If you have a hard requirement for the `net48` build, contact support for the latest download link.

## Frequently Asked Questions

### Can I install the SDK in Unity via NuGet?

No. Unity does not run NuGet restore, and the SDK ships hundreds of native files that NuGet would not lay out for Unity. The `.unitypackage` bundles everything — managed assemblies, every platform's native runtime, scripts, and scenes — so you import a single file instead.

### Do I need to install GStreamer or any other system dependency?

No. The package is fully self-contained; everything the SDK needs is inside it. A system GStreamer install on your machine is not required and is not used by the bundled runtime — on the contrary, `VisioForgeEnvironment.Configure()` actively prunes any system GStreamer from the process search path to avoid a double-init.

### Which VisioForge SDKs are included?

The package ships four products from one shared `netstandard2.1` managed surface: the **Media Blocks SDK .NET** pipeline and the high-level **Media Player SDK .NET** (`MediaPlayerCoreX`), **Video Capture SDK .NET** (`VideoCaptureCoreX`), and **Video Edit SDK .NET** (`VideoEditCoreX`) engines. Each ships one or more ready sample scenes — see the [samples overview](../../general/unity/#samples).

### Does the same package work on Windows ARM64?

The package's Windows native runtime is x86\_64 only — there is no ARM64 native build today. Run it via x64 emulation only at your own risk; production use on Windows 11 ARM64 is not exercised.

### Can I open the same package in the Mac-host Editor?

Yes — if the package was built with `-IncludeMacOS`. The cumulative variant published at `files.visioforge.com/unity/` always contains the macOS flavor. A Windows-only variant opened in a Mac Editor surfaces a clear `[VisioForge] Native runtime folder not found at '…' for runtime platform OSXEditor` message; see [Bootstrap and lifecycle](../../general/unity/bootstrap/).

## See Also

- [Using VisioForge in Unity](../../general/unity/) — overview of how the integration works
- [Quickstart](../../general/unity/getting-started/) — five-step path to a playing video
- [Bootstrap and lifecycle](../../general/unity/bootstrap/) — what `Configure()` and `InitializeSdk()` do
- [Play a media file in Unity](../../general/unity/simple-player/) — the file-playback sample
- [View an RTSP camera in Unity](../../general/unity/rtsp-viewer/) — the RTSP sample
- [Capture a webcam](../../general/unity/video-capture-x/) · [Edit and render](../../general/unity/video-edit-x/) — the CoreX engine samples
- [Platform matrix](../../general/unity/platform-matrix/) — feature support by Unity platform
- [Media Blocks SDK .NET overview](../../mediablocks/) — the full block catalog
- [Installation guide](../) — install the SDK in other .NET project types

---END OF PAGE---


## Set Up Video SDKs for Uno Platform Cross-Platform .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/install/uno/
**Description:** Add video capture, playback, and editing to Uno Platform apps. NuGet setup, VideoView integration for Windows, Android, iOS, macOS, and Linux.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, WPF, Uno, GStreamer, Streaming, C#, NuGet
**API:** VideoView, UniversalSourceSettings, MediaBlocksPipeline, UniversalSourceBlock, VideoRendererBlock

# Integrating VisioForge SDKs with Uno Platform Applications

## Overview

Uno Platform is a powerful cross-platform UI framework that enables developers to build native mobile, desktop, and embedded applications from a single C# and XAML codebase. VisioForge provides comprehensive support for Uno Platform applications through the `VisioForge.DotNet.Core.UI.Uno` package, which contains specialized UI controls designed specifically for the Uno Platform.

Our SDKs enable powerful multimedia capabilities across all Uno Platform-supported platforms:

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Supported Platforms

Uno Platform with VisioForge SDKs supports:

- **Windows Desktop** - Full native WinUI 3 support with hardware acceleration
- **Android** - Native Android views with MediaCodec hardware acceleration
- **iOS** - Native UIKit with VideoToolbox hardware acceleration
- **macOS** - Mac Catalyst support for Apple Silicon and Intel
- **Linux Desktop** - Skia-based rendering with GStreamer

## Quick Start

### 1. Install NuGet Packages

Add the core VisioForge packages to your Uno Platform project:

```
<ItemGroup>
  <PackageReference Include="VisioForge.DotNet.Core.UI.Uno" Version="2026.*" />
  <PackageReference Include="VisioForge.DotNet.Core" Version="2026.*" />
</ItemGroup>
```

### 2. Initialize the SDK

Initialize the SDK at application startup. You can use either the synchronous or asynchronous version:

```
using VisioForge.Core;

// Synchronous initialization
VisioForgeX.InitSDK();

// Or async initialization (recommended)
await VisioForgeX.InitSDKAsync();
```

Clean up when the application exits:

```
VisioForgeX.DestroySDK();
```

### 3. Add VideoView to XAML

Add the VisioForge namespace and VideoView control to your XAML:

```
<Page x:Class="YourApp.MainPage"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:vf="using:VisioForge.Core.UI.Uno">

    <Grid>
        <vf:VideoView x:Name="videoView"
                      HorizontalAlignment="Stretch"
                      VerticalAlignment="Stretch"
                      Background="Black"/>
    </Grid>
</Page>
```

The VideoView control adapts to the native rendering capabilities of each platform while providing a consistent API for your application code.

## Implementing VideoView in Code

Here's a complete example of using VideoView with the Media Blocks pipeline:

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.X.Sources;

public sealed partial class MainPage : Page
{
    private MediaBlocksPipeline? _pipeline;
    private UniversalSourceBlock? _source;
    private VideoRendererBlock? _renderer;

    public MainPage()
    {
        this.InitializeComponent();
        this.Loaded += MainPage_Loaded;
        this.Unloaded += MainPage_Unloaded;
    }

    private async void MainPage_Loaded(object sender, RoutedEventArgs e)
    {
        // Initialize SDK (once at app startup)
        await VisioForgeX.InitSDKAsync();
    }

    private async Task PlayMediaAsync(string mediaPath)
    {
        // Clean up previous pipeline if any
        await CleanupPipelineAsync();

        // Create pipeline
        _pipeline = new MediaBlocksPipeline();

        // Create source settings - use factory method for URLs or file paths
        // Video-only playback: disable audio since we're not connecting audio output
        UniversalSourceSettings sourceSettings;
        if (Uri.TryCreate(mediaPath, UriKind.Absolute, out var uri) && !uri.IsFile)
        {
            // URL source
            sourceSettings = await UniversalSourceSettings.CreateAsync(uri, renderAudio: false);
        }
        else
        {
            // File path source
            sourceSettings = await UniversalSourceSettings.CreateAsync(mediaPath, renderAudio: false);
        }

        // Create source and renderer blocks
        _source = new UniversalSourceBlock(sourceSettings);
        _renderer = new VideoRendererBlock(_pipeline, videoView);

        // Connect blocks
        _pipeline.Connect(_source.VideoOutput, _renderer.Input);

        // Start playback
        await _pipeline.StartAsync();
    }

    private async Task CleanupPipelineAsync()
    {
        if (_pipeline != null)
        {
            await _pipeline.StopAsync();
            await _pipeline.DisposeAsync();
            _pipeline = null;
        }

        _source?.Dispose();
        _source = null;

        _renderer?.Dispose();
        _renderer = null;
    }

    private async void MainPage_Unloaded(object sender, RoutedEventArgs e)
    {
        await CleanupPipelineAsync();

        // Destroy SDK when app closes
        VisioForgeX.DestroySDK();
    }
}
```

## Sample Applications

For complete examples and sample code, visit:

- Sample applications in the [Media Blocks SDK/Uno](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/Uno) folder
- Sample applications in the [Media Player SDK X/Uno](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK%20X/Uno) folder
- Sample applications in the [Video Capture SDK X/Uno](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/Uno) folder
- Our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples)

Available samples include:

- **Simple Player** - Basic media player with playback controls
- **RTSP Viewer** - Network camera streaming viewer
- **Video Capture** - Camera capture with recording functionality

## Next Steps

For complete deployment instructions including:

- Platform-specific redistributable packages
- System requirements
- Build commands
- Platform configurations (permissions, capabilities, Info.plist settings)
- Complete sample project file
- Troubleshooting

See the [Uno Platform Deployment Guide](../../deployment-x/uno/).

## Additional Resources

- [Windows Deployment](../../deployment-x/Windows/)
- [Android Deployment](../../deployment-x/Android/)
- [iOS Deployment](../../deployment-x/iOS/)
- [macOS Deployment](../../deployment-x/macOS/)

---END OF PAGE---


## Install VisioForge SDK in Visual Studio — .NET NuGet Setup
**URL:** https://www.visioforge.com/help/docs/dotnet/install/visual-studio/
**Description:** Add VisioForge .NET SDKs to Visual Studio 2022+ projects via NuGet. WinForms/WPF/MAUI/console templates. Native dependencies and license setup.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS, WPF, Avalonia, NuGet
**API:** VideoView

# Comprehensive Guide to Integrating .NET SDKs with Visual Studio

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction to VisioForge .NET SDKs

VisioForge offers a powerful suite of multimedia SDKs for .NET developers, enabling you to build feature-rich applications with advanced video capture, editing, playback, and media processing capabilities. This comprehensive guide will walk you through the process of integrating these SDKs into your Visual Studio projects, ensuring a smooth development experience.

For professional developers working on multimedia applications, properly integrating these SDKs is crucial for optimal performance and functionality. Our recommended approach is to use NuGet packages, which simplifies dependency management and ensures you're always using the latest features and bug fixes.

## Installation Methods Overview

There are two primary methods to install VisioForge .NET SDKs:

1. **NuGet Package Installation** (Recommended): The modern, streamlined approach that handles dependencies automatically and simplifies updates.
2. **Manual Installation**: A traditional approach for specialized scenarios, though generally not recommended for most projects.

We'll cover both methods in detail, but strongly encourage the NuGet approach for most development scenarios.

## NuGet Package Installation (Recommended Method)

NuGet is the package manager for .NET, providing a centralized way to incorporate libraries into your projects without the hassle of manual file management. Here's a detailed walkthrough of integrating VisioForge SDKs using NuGet.

### Step 1: Create or Open Your .NET Project

First, you'll need a WinForms, WPF, or other .NET project. We recommend using the modern SDK-style project format for optimal compatibility.

#### Creating a New Project

1. Launch Visual Studio (2019 or 2022 recommended)
2. Select "Create a new project"
3. Filter templates by "C#" and either "WPF" or "Windows Forms"
4. Choose "WPF Application" or "Windows Forms Application" with the .NET Core/5/6+ framework
5. Ensure you select the modern SDK-style project format (this is the default in newer Visual Studio versions)

#### Configuring the Project

After creating a new project, you'll need to configure basic settings:

1. Enter your project name (use a descriptive name relevant to your application)
2. Choose an appropriate location and solution name
3. Select your target framework (.NET 6 or newer recommended for best performance and features)
4. Click "Create" to generate the project structure

### Step 2: Access NuGet Package Manager

Once your project is open in Visual Studio:

1. Right-click on your project in Solution Explorer
2. Select "Manage NuGet Packages..." from the context menu
3. The NuGet Package Manager will open in the center pane

This interface provides search functionality and package browsing to easily find and install the VisioForge components you need.

### Step 3: Install the UI Package for Your Framework

VisioForge SDKs offer specialized UI components for different .NET frameworks. You'll need to select the appropriate UI package based on your project type.

1. In the NuGet Package Manager, switch to the "Browse" tab
2. Search for "VisioForge.DotNet.Core.UI"
3. Select the appropriate UI package for your project type from the search results

#### Available UI Packages

VisioForge supports a wide range of UI frameworks. Choose the one that matches your project:

- **[VisioForge.DotNet.Core.UI.WinUI](https://www.nuget.org/packages/VisioForge.DotNet.Core.UI.WinUI)**: For modern Windows UI applications
- **[VisioForge.DotNet.Core.UI.MAUI](https://www.nuget.org/packages/VisioForge.DotNet.Core.UI.MAUI)**: For cross-platform applications using .NET MAUI
- **[VisioForge.DotNet.Core.UI.Avalonia](https://www.nuget.org/packages/VisioForge.DotNet.Core.UI.Avalonia)**: For cross-platform desktop applications using Avalonia UI

These UI packages provide the necessary controls and components specifically designed for video rendering and interaction within your chosen framework.

### Step 4: Install the Core SDK Package

After installing the UI package, you'll need to add the main SDK package for your specific multimedia needs:

1. Return to the NuGet Package Manager "Browse" tab
2. Search for the specific VisioForge SDK you need (e.g., "VisioForge.DotNet.VideoCapture")
3. Click "Install" on the appropriate package

#### Available Core SDK Packages

Choose the SDK that aligns with your application's requirements:

- **[VisioForge.DotNet.VideoCapture](https://www.nuget.org/packages/VisioForge.DotNet.VideoCapture)**: For applications that need to capture video from cameras, screen recording, or other sources
- **[VisioForge.DotNet.VideoEdit](https://www.nuget.org/packages/VisioForge.DotNet.VideoEdit)**: For video editing, processing, and conversion applications
- **[VisioForge.DotNet.MediaPlayer](https://www.nuget.org/packages/VisioForge.DotNet.MediaPlayer)**: For creating media players with advanced playback controls
- **[VisioForge.DotNet.MediaBlocks](https://www.nuget.org/packages/VisioForge.DotNet.MediaBlocks)**: For building complex media processing pipelines

Each package includes comprehensive documentation, and you can install multiple packages if your application requires different multimedia capabilities.

### Step 5: Implementing the VideoView Control (Optional)

The VideoView control is crucial for applications that need to display video content. You can add it to your UI using XAML (for WPF) or through the designer (for WinForms).

#### For WPF Applications

Add the required namespace to your XAML file:

```
xmlns:wpf="clr-namespace:VisioForge.Core.UI.WPF;assembly=VisioForge.Core"
```

Then add the VideoView control to your layout:

```
<wpf:VideoView
    Width="640"
    Height="480"
    Margin="10,10,0,0"
    HorizontalAlignment="Left"
    VerticalAlignment="Top"/>
```

The VideoView control will appear in your designer:

#### For WinForms Applications

1. Open the form in designer mode
2. Locate the VisioForge controls in the toolbox (if they don't appear, right-click the toolbox and select "Choose Items...")
3. Drag and drop the VideoView control onto your form
4. Adjust the size and position properties as needed

### Step 6: Install Required Redistribution Packages

Depending on your specific implementation, you may need additional redistribution packages:

1. Return to the NuGet Package Manager
2. Search for "VisioForge.DotNet.Core.Redist" to see available redistribution packages
3. Install the ones relevant to your platform and SDK choice

The required redistribution packages vary based on:

- Target operating system (Windows, macOS, Linux)
- Hardware acceleration requirements
- Specific codecs and formats your application will use
- Backend engine configuration

Consult the specific Deployment documentation page for your selected product to determine which redistribution packages are necessary for your application.

## Manual Installation (Alternative Method)

While we generally don't recommend manual installation due to its complexity and potential for configuration issues, there are specific scenarios where it might be necessary. Follow these steps if NuGet isn't an option for your project:

1. Download the [complete SDK installer](https://files.visioforge.com/trials/visioforge_sdks_installer_dotnet_setup.exe) from our website
2. Run the installer with administrator privileges and follow the on-screen instructions
3. Create your WinForms or WPF project in Visual Studio
4. Add references to the installed SDK libraries:
5. Right-click "References" in Solution Explorer
6. Select "Add Reference"
7. Navigate to the installed SDK location
8. Select the required DLL files
9. Configure the Visual Studio Toolbox:
10. Right-click the Toolbox and select "Add Tab"
11. Name the new tab "VisioForge"
12. Right-click the tab and select "Choose Items..."
13. Browse to the SDK installation directory
14. Select `VisioForge.Core.dll`
15. Drag and drop the VideoView control onto your form or window

This manual approach requires additional configuration for deployment and updates must be managed manually.

## Advanced Configuration and Best Practices

For production applications, consider these additional implementation details:

- **License Management**: Implement proper license validation at application startup
- **Error Handling**: Add comprehensive error handling around SDK initialization and operation
- **Performance Optimization**: Configure hardware acceleration and threading based on your target devices
- **Resource Management**: Implement proper disposal of SDK resources to prevent memory leaks

## Troubleshooting Common Issues

If you encounter problems during installation or implementation:

- Verify your project targets a supported .NET version
- Ensure all required redistributable packages are installed
- Check for NuGet package version compatibility
- Review the SDK documentation for platform-specific requirements

## Conclusion and Next Steps

With the VisioForge .NET SDKs properly installed in your Visual Studio project, you're now ready to leverage their powerful multimedia capabilities. The NuGet installation method ensures you have the correct dependencies and simplifies future updates.

To deepen your understanding and maximize the potential of these SDKs:

- Explore our [comprehensive code samples on GitHub](https://github.com/visioforge/.Net-SDK-s-samples)
- Review the product-specific documentation for advanced features
- Join our developer community forums for support and best practices

By following this guide, you've established a solid foundation for developing sophisticated multimedia applications with VisioForge and Visual Studio.

---END OF PAGE---


## Install VisioForge .NET SDKs in Visual Studio for Mac
**URL:** https://www.visioforge.com/help/docs/dotnet/install/visual-studio-mac/
**Description:** Install and configure VisioForge .NET SDKs in Visual Studio for Mac for multimedia macOS and iOS application development.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming, Webcam, C#, NuGet
**API:** VideoView

# Complete Guide to Integrating VisioForge .NET SDKs with Visual Studio for Mac

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

Visual Studio for Mac is retired

Microsoft [retired Visual Studio for Mac](https://learn.microsoft.com/en-us/visualstudio/releases/2022/what-happened-to-vs-for-mac) on August 31, 2024. No new installs are possible and the IDE no longer receives updates. For macOS .NET development with VisioForge SDKs, use **[JetBrains Rider](../rider/)** or **Visual Studio Code with the C# Dev Kit** instead. The NuGet package names, UI controls and C# snippets on this page apply identically to those IDEs.

## Introduction to VisioForge SDKs on macOS

VisioForge provides powerful multimedia SDKs for .NET developers working on macOS and iOS platforms. This detailed guide will walk you through the entire process of integrating these SDKs into your Visual Studio for Mac projects. While this tutorial primarily focuses on macOS application development, the same principles apply to iOS applications with minimal adaptations.

By following this guide, you'll learn how to properly set up your development environment, install the necessary packages, configure UI components, and prepare your application for deployment. This knowledge will serve as a solid foundation for building sophisticated multimedia applications using VisioForge technology.

## Prerequisites for Development

Before starting the integration process, ensure you have:

- Visual Studio for Mac (latest version recommended)
- .NET SDK installed (minimum version 6.0)
- Basic knowledge of C# and .NET development
- Administrative access to your macOS system
- Active internet connection for NuGet package downloads
- Optional: XCode for storyboard editing

Having these prerequisites in place will ensure a smooth installation process and prevent common setup issues.

## Setting Up a New macOS Project

Let's begin by creating a new macOS project in Visual Studio for Mac. This will serve as the foundation for our VisioForge SDK integration.

### Creating the Project Structure

1. Launch Visual Studio for Mac.
2. Select **File > New Solution** from the menu bar.
3. In the template selection dialog, navigate to **.NET > App**.
4. Choose **macOS Application** as your project template.
5. Configure your project settings, including:
6. Project name (choose something descriptive)
7. Organization identifier (typically in reverse domain format)
8. Target framework (.NET 6.0 or later recommended)
9. Solution name (can match your project name)
10. Click **Create** to generate your project template.

This creates a basic macOS application with the standard project structure required for VisioForge SDK integration.

## Installing VisioForge SDK Packages

After creating your project, the next step is to install the necessary VisioForge SDK packages via NuGet. These packages contain the core functionality and UI components required for multimedia operations.

### Adding the Main SDK Package

Each VisioForge product line has a dedicated main package that contains the core functionality. You'll need to choose the appropriate package based on your development requirements.

1. Right-click on your project in the Solution Explorer.
2. Select **Manage NuGet Packages** from the context menu.
3. Click on the **Browse** tab in the NuGet Package Manager.
4. In the search box, type "VisioForge" to find all available packages.
5. Select one of the following packages based on your requirements:

Available NuGet packages:

- [VisioForge.DotNet.VideoCapture](https://www.nuget.org/packages/VisioForge.DotNet.VideoCapture) - For video capture, webcam, and screen recording functionality
- [VisioForge.DotNet.VideoEdit](https://www.nuget.org/packages/VisioForge.DotNet.VideoEdit) - For video editing, processing, and conversion
- [VisioForge.DotNet.MediaPlayer](https://www.nuget.org/packages/VisioForge.DotNet.MediaPlayer) - For media playback and streaming
- [VisioForge.DotNet.MediaBlocks](https://www.nuget.org/packages/VisioForge.DotNet.MediaBlocks) - For advanced media processing workflows
- Click **Add Package** to install your selected package.
- Accept any license agreements that appear.

The installation process will automatically resolve dependencies and add references to your project.

### Apple UI Controls

For macOS and iOS applications, the Apple-specific UI controls (`VideoView`, `GLView`) are **shipped inside the main `VisioForge.DotNet.Core` package** — there is no separate `UI.Apple` NuGet. Once you've added `VisioForge.DotNet.Core` above, reference the controls via the `VisioForge.Core.UI.Apple` namespace:

```
using VisioForge.Core.UI.Apple;
```

## Integrating Video Preview Capabilities

Most multimedia applications require video preview functionality. VisioForge SDKs provide specialized controls for this purpose that integrate seamlessly with macOS applications.

### Adding the VideoView Control

The VideoView control is the primary component for displaying video content in your application. Here's how to add it to your interface:

1. Open your application's main storyboard file by double-clicking it in the Solution Explorer.
2. Visual Studio for Mac will open XCode Interface Builder for storyboard editing.
3. From the Object Library, find the **Custom View** control.
4. Drag the Custom View control onto your window where you want the video to appear.
5. Set appropriate constraints to ensure proper sizing and positioning.
6. Using the Identity Inspector, set a descriptive name for your Custom View (e.g., "videoViewHost").
7. Save your changes and return to Visual Studio for Mac.

This Custom View will serve as a container for the VisioForge VideoView control, which will be added programmatically.

### Initializing the VideoView in Code

After adding the container Custom View, you need to initialize the VideoView control programmatically:

1. Open your ViewController.cs file.
2. Add the necessary using directives at the top of the file:

```
using VisioForge.Core.UI.Apple;
using CoreGraphics;
```

1. Add a private field to your ViewController class to hold the VideoView reference:

```
private VideoView _videoView;
```

1. Modify the ViewDidLoad method to initialize and add the VideoView:

```
public override void ViewDidLoad()
{
    base.ViewDidLoad();

    // Create and add VideoView
    _videoView = new VideoView(new CGRect(0, 0, videoViewHost.Bounds.Width, videoViewHost.Bounds.Height));
    this.videoViewHost.AddSubview(_videoView);

    // Configure VideoView properties
    _videoView.AutoresizingMask = Foundation.NSViewResizingMask.WidthSizable | Foundation.NSViewResizingMask.HeightSizable;

    // Additional initialization code
    InitializeMediaComponents();
}

private async void InitializeMediaComponents()
{
    // Initialize your VisioForge SDK components here. On macOS, always use the
    // cross-platform X engines — classic VideoCaptureCore / MediaPlayerCore /
    // VideoEditCore are Windows-only.
    await VisioForgeX.InitSDKAsync();

    // For example, for playback:
    // var player = new MediaPlayerCoreX(_videoView);
    // var settings = await UniversalSourceSettings.CreateAsync(new Uri("https://example.com/video.mp4"));
    // await player.OpenAsync(settings);
    // await player.PlayAsync();
}
```

This code creates a `VideoView` instance, sizes it to match your container view, and adds it as a subview. The `AutoresizingMask` property ensures that the video view resizes properly when the window size changes.

## Adding Required Redistribution Packages

VisioForge SDKs rely on various native libraries and components that must be included in your application bundle. These dependencies vary based on the specific SDK you're using and your target platform.

Check the [deployment documentation](../../deployment-x/) for detailed information on which redistribution packages are required for your specific scenario.

## Troubleshooting Common Issues

If you encounter issues during installation or integration, consider these common solutions:

1. **Missing dependencies**: Ensure all required redistribution packages are installed
2. **Build errors**: Verify that your project targets a compatible .NET version
3. **Runtime crashes**: Check for platform-specific initialization issues
4. **Black video display**: Verify that the VideoView is properly initialized and added to the view hierarchy
5. **Performance issues**: Consider enabling hardware acceleration where available

For more specific troubleshooting guidance, refer to the VisioForge documentation or contact their support team.

## Next Steps and Resources

Now that you've successfully integrated VisioForge SDKs into your Visual Studio for Mac project, you can explore more advanced features and capabilities:

- Create custom video processing workflows
- Implement recording and capture functionality
- Develop sophisticated media editing features
- Build streaming media applications

### Additional Resources

- Visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) for code samples and example projects
- Join the [developer forum](https://support.visioforge.com/) to connect with other developers
- Subscribe to our newsletter for updates on new features and best practices

By following this guide, you've established a solid foundation for developing powerful multimedia applications on macOS and iOS using VisioForge SDKs and Visual Studio for Mac.

---END OF PAGE---


## Apple Platform Media Blocks in C# .NET — iOS, macOS
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/_Apple/
**Description:** Build iOS and macOS media apps with ProRes encoding, VideoToolbox acceleration, and native audio blocks using VisioForge Media Blocks SDK.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS
**API:** MetalVideoCompositorBlock, MediaBlocksPipeline, VideoRendererBlock, SystemAudioSourceBlock, OSXAudioSinkBlock

# Apple Platform Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

This section covers MediaBlocks specifically optimized for Apple platforms (iOS, macOS, tvOS).

## Available Blocks

### Audio Sources

- **SystemAudioSourceBlock**: macOS and iOS audio capture through Core Audio, configured with `OSXAudioSourceSettings` on macOS and Mac Catalyst, `IOSAudioSourceSettings` on iOS
- See [Audio Sources Documentation](../Sources/#system-audio-source)

### Audio Sinks

- **OSXAudioSinkBlock**: macOS audio playback
- See [Audio Rendering Documentation](../AudioRendering/)
- **IOSAudioSinkBlock**: iOS audio playback
- See [Audio Rendering Documentation](../AudioRendering/)

### Video Sources

- **IOSVideoSourceBlock**: iOS camera capture
- See [Video Sources Documentation](../Sources/#system-video-source)

### Video Encoders

- **AppleProResEncoderBlock**: Apple ProRes professional video codec
- See [ProRes Encoder Documentation](../VideoEncoders/#apple-prores-encoder)

### Video Processing

- **MetalVideoCompositorBlock**: GPU-accelerated multi-input video compositor using Apple Metal
- **MetalConvertScaleBlock**: GPU-accelerated format conversion and scaling using Apple Metal
- **MetalDeinterlaceBlock**: GPU-accelerated deinterlacing using Apple Metal
- **MetalOverlayBlock**: GPU-accelerated image overlay using Apple Metal
- **MetalTransformBlock**: GPU-accelerated flip, rotate, and crop using Apple Metal
- **MetalVideoFilterBlock**: GPU-accelerated brightness, contrast, saturation, hue, gamma, sharpness, sepia, invert, film grain, and vignette using Apple Metal

## Metal Video Compositor

### Metal Video Compositor Block

The `MetalVideoCompositorBlock` composites multiple video streams in real time using the Apple Metal GPU framework. Each input stream has configurable position, size, z-order, alpha, and blend operator. The block produces a single BGRA video output.

#### Block info

Name: MetalVideoCompositorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | N (one per stream) |
| Output video | Uncompressed video | 1 |

#### Settings

The block takes a `MetalVideoCompositorSettings` instance:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Width` | `int` | 1920 | Output width in pixels |
| `Height` | `int` | 1080 | Output height in pixels |
| `FrameRate` | `VideoFrameRate` | FPS\_30 | Output frame rate |
| `Background` | `VideoMixerBackground` | Transparent | Background mode |
| `Streams` | `List<VideoMixerStream>` | Empty | Input stream configurations |

Each input stream is a `MetalVideoMixerStream`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Rectangle` | `Rect` | required | Position and size within the output frame |
| `ZOrder` | `uint` | required | Stacking order (higher = in front) |
| `Alpha` | `double` | 1.0 | Opacity (0.0 transparent – 1.0 opaque) |
| `BlendOperator` | `MetalVideoMixerBlendOperator` | Over | Blend mode: Source, Over, or Add |
| `KeepAspectRatio` | `bool` | false | Preserve source aspect ratio during scaling |

#### The sample pipeline

```
graph LR;
    VideoSource1-->MetalVideoCompositorBlock;
    VideoSource2-->MetalVideoCompositorBlock;
    MetalVideoCompositorBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Configure compositor: 1920x1080 @ 30fps
var settings = new MetalVideoCompositorSettings(1920, 1080, VideoFrameRate.FPS_30);

// First stream: left half of screen
settings.AddStream(new MetalVideoMixerStream(
    rectangle: new Rect(0, 0, 960, 1080),
    zorder: 0));

// Second stream: right half of screen
// Rect ctor is (left, top, right, bottom). For the right half of a 1920x1080
// canvas use right=1920 and bottom=1080 — the previous form (960, 0, 960, 1080)
// has left==right and produces a zero-width box.
settings.AddStream(new MetalVideoMixerStream(
    rectangle: new Rect(960, 0, 1920, 1080),
    zorder: 1));

var compositor = new MetalVideoCompositorBlock(settings);

// Render composited output
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(compositor.Output, videoRenderer.Input);

await pipeline.StartAsync();

// Real-time: fade out stream 0 over 2 seconds
compositor.StartFadeOut(settings.Streams[0].ID, TimeSpan.FromSeconds(2));
```

#### Availability

```
bool available = MetalVideoCompositorBlock.IsAvailable();
```

Returns `true` if the `vfmetalcompositor` GStreamer plugin is available on the current system.

#### Platforms

macOS, iOS. On iOS the Metal elements are part of the device runtime only - they are not available in the iOS Simulator, where `IsAvailable()` returns `false`.

## Metal Convert/Scale

### Metal Convert/Scale Block

The `MetalConvertScaleBlock` performs pixel-format conversion and scaling in a single GPU pass using the Apple Metal framework. It can optionally add letterbox/pillarbox borders to preserve the source aspect ratio.

#### Block info

Name: MetalConvertScaleBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

#### Settings

The block takes a `MetalConvertScaleSettings` instance:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Method` | `MetalScalingMethod` | Bilinear | Scaling interpolation: `Bilinear` or `Nearest` |
| `AddBorders` | `bool` | false | Add letterbox/pillarbox borders to preserve aspect ratio |
| `BorderColor` | `uint` | 0xFF000000 | Border color in ARGB format (opaque black) |

#### The sample pipeline

```
graph LR;
    VideoSource-->MetalConvertScaleBlock;
    MetalConvertScaleBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var videoSource = new IOSVideoSourceBlock(videoSettings);

// Bilinear scaling with letterbox borders
var settings = new MetalConvertScaleSettings
{
    Method = MetalScalingMethod.Bilinear,
    AddBorders = true,
    BorderColor = 0xFF000000
};
var convertScale = new MetalConvertScaleBlock(settings);
pipeline.Connect(videoSource.Output, convertScale.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(convertScale.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = MetalConvertScaleBlock.IsAvailable();
```

Returns `true` if the `vfmetalconvertscale` GStreamer plugin is available on the current system.

#### Platforms

macOS, iOS. On iOS the Metal elements are part of the device runtime only - they are not available in the iOS Simulator, where `IsAvailable()` returns `false`.

## Metal Deinterlace

### Metal Deinterlace Block

The `MetalDeinterlaceBlock` removes interlacing artifacts on the GPU using the Apple Metal framework. It supports bob, weave, linear, and greedy-H (motion-adaptive) algorithms.

#### Block info

Name: MetalDeinterlaceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

#### Settings

The block takes a `MetalDeinterlaceSettings` instance:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Method` | `MetalDeinterlaceMethod` | Bob | Algorithm: `Bob`, `Weave`, `Linear`, or `GreedyH` |
| `FieldLayout` | `MetalDeinterlaceFieldLayout` | Auto | Field order: `Auto`, `TopFieldFirst`, or `BottomFieldFirst` |
| `MotionThreshold` | `double` | 0.1 | Motion detection threshold for the greedy-H algorithm (0.0–1.0) |

#### The sample pipeline

```
graph LR;
    VideoSource-->MetalDeinterlaceBlock;
    MetalDeinterlaceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var videoSource = new IOSVideoSourceBlock(videoSettings);

// Motion-adaptive greedy-H deinterlacing
var settings = new MetalDeinterlaceSettings
{
    Method = MetalDeinterlaceMethod.GreedyH,
    FieldLayout = MetalDeinterlaceFieldLayout.Auto,
    MotionThreshold = 0.1
};
var deinterlace = new MetalDeinterlaceBlock(settings);
pipeline.Connect(videoSource.Output, deinterlace.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(deinterlace.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = MetalDeinterlaceBlock.IsAvailable();
```

Returns `true` if the `vfmetaldeinterlace` GStreamer plugin is available on the current system.

#### Platforms

macOS, iOS. On iOS the Metal elements are part of the device runtime only - they are not available in the iOS Simulator, where `IsAvailable()` returns `false`.

## Metal Overlay

### Metal Overlay Block

The `MetalOverlayBlock` composites a PNG or JPEG image onto video frames on the GPU using the Apple Metal framework. The overlay can be positioned in absolute pixels or as a fraction of the frame size, with adjustable opacity.

#### Block info

Name: MetalOverlayBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

#### Settings

The block takes a `MetalOverlaySettings` instance:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Location` | `string` | null | Path to the overlay image (PNG or JPEG); null disables the overlay |
| `X` | `int` | 0 | X position in pixels (ignored when `RelativeX` is not -1) |
| `Y` | `int` | 0 | Y position in pixels (ignored when `RelativeY` is not -1) |
| `Width` | `int` | 0 | Overlay width in pixels (0 = original image width) |
| `Height` | `int` | 0 | Overlay height in pixels (0 = original image height) |
| `Alpha` | `double` | 1.0 | Opacity (0.0 transparent – 1.0 opaque) |
| `RelativeX` | `double` | -1.0 | Relative X as a fraction of video width; -1.0 uses pixel `X` |
| `RelativeY` | `double` | -1.0 | Relative Y as a fraction of video height; -1.0 uses pixel `Y` |

#### The sample pipeline

```
graph LR;
    VideoSource-->MetalOverlayBlock;
    MetalOverlayBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var videoSource = new IOSVideoSourceBlock(videoSettings);

// Logo at top-left with 80% opacity
var settings = new MetalOverlaySettings
{
    Location = "logo.png",
    X = 20,
    Y = 20,
    Alpha = 0.8
};
var overlay = new MetalOverlayBlock(settings);
pipeline.Connect(videoSource.Output, overlay.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(overlay.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = MetalOverlayBlock.IsAvailable();
```

Returns `true` if the `vfmetaloverlay` GStreamer plugin is available on the current system.

#### Platforms

macOS, iOS. On iOS the Metal elements are part of the device runtime only - they are not available in the iOS Simulator, where `IsAvailable()` returns `false`.

## Metal Transform

### Metal Transform Block

The `MetalTransformBlock` applies flip, rotate, and crop operations on the GPU using the Apple Metal framework.

#### Block info

Name: MetalTransformBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

#### Settings

The block takes a `MetalTransformSettings` instance:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Method` | `MetalTransformMethod` | None | Rotation/flip: `None`, `Clockwise`, `Rotate180`, `CounterClockwise`, `HorizontalFlip`, `VerticalFlip`, `UpperLeftDiagonal`, or `UpperRightDiagonal` |
| `CropTop` | `int` | 0 | Pixels to crop from the top |
| `CropBottom` | `int` | 0 | Pixels to crop from the bottom |
| `CropLeft` | `int` | 0 | Pixels to crop from the left |
| `CropRight` | `int` | 0 | Pixels to crop from the right |

#### The sample pipeline

```
graph LR;
    VideoSource-->MetalTransformBlock;
    MetalTransformBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var videoSource = new IOSVideoSourceBlock(videoSettings);

// Rotate 90 degrees clockwise and crop 10px from each side
var settings = new MetalTransformSettings
{
    Method = MetalTransformMethod.Clockwise,
    CropLeft = 10,
    CropRight = 10
};
var transform = new MetalTransformBlock(settings);
pipeline.Connect(videoSource.Output, transform.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(transform.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = MetalTransformBlock.IsAvailable();
```

Returns `true` if the `vfmetaltransform` GStreamer plugin is available on the current system.

#### Platforms

macOS, iOS. On iOS the Metal elements are part of the device runtime only - they are not available in the iOS Simulator, where `IsAvailable()` returns `false`.

## Metal Video Filter

### Metal Video Filter Block

The `MetalVideoFilterBlock` applies color and image adjustments on the GPU using the Apple Metal framework. Brightness, contrast, saturation, hue, gamma, sharpness, sepia, invert, film grain, vignette, chroma key and a 3D LUT are all applied in a single GPU pass.

#### Block info

Name: MetalVideoFilterBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

#### Settings

The block takes a `MetalVideoFilterSettings` instance:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Brightness` | `double` | 0.0 | Brightness adjustment, -1.0 to 1.0 |
| `Contrast` | `double` | 1.0 | Contrast adjustment, 0.0 to 2.0 |
| `Saturation` | `double` | 1.0 | Saturation adjustment, 0.0 to 2.0 |
| `Hue` | `double` | 0.0 | Hue rotation, -1.0 to 1.0 |
| `Gamma` | `double` | 1.0 | Gamma correction, 0.01 to 10.0 |
| `Sharpness` | `double` | 0.0 | Blur below 0, sharpen above 0, -1.0 to 1.0 |
| `Sepia` | `double` | 0.0 | Sepia mix amount, 0.0 to 1.0 |
| `Invert` | `bool` | false | Invert the colors |
| `Noise` | `double` | 0.0 | Film grain amount, 0.0 to 1.0 |
| `Vignette` | `double` | 0.0 | Vignette darkness, 0.0 to 1.0 |
| `ChromaKeyEnabled` | `bool` | false | Enable chroma key (green screen) removal |
| `ChromaKeyColor` | `uint` | 0xFF00FF00 | Chroma key target color in ARGB |
| `ChromaKeyTolerance` | `double` | 0.2 | Chroma key color matching tolerance, 0.0 to 1.0 |
| `ChromaKeySmoothness` | `double` | 0.1 | Chroma key edge smoothness, 0.0 to 1.0 |
| `LutFile` | `string` | null | Path to a 3D LUT file (`.cube` or `.png`); null disables the LUT |

Call `Settings.Update()` after changing a property to apply it to a running pipeline.

#### The sample pipeline

```
graph LR;
    VideoSource-->MetalVideoFilterBlock;
    MetalVideoFilterBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var videoSource = new IOSVideoSourceBlock(videoSettings);

// Warmer, slightly punchier picture with a soft vignette
var settings = new MetalVideoFilterSettings
{
    Brightness = 0.05,
    Contrast = 1.15,
    Saturation = 1.2,
    Vignette = 0.3
};
var filter = new MetalVideoFilterBlock(settings);
pipeline.Connect(videoSource.Output, filter.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(filter.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = MetalVideoFilterBlock.IsAvailable();
```

Returns `true` if the `vfmetalvideofilter` GStreamer plugin is available on the current system.

#### Platforms

macOS, iOS. On iOS the Metal elements are part of the device runtime only - they are not available in the iOS Simulator, where `IsAvailable()` returns `false`.

## Platform Requirements

- **iOS**: iOS 12.0 or later
- **macOS**: macOS 10.13 or later
- **tvOS**: tvOS 12.0 or later

## Features

- Native integration with Apple frameworks (AVFoundation, Core Audio, Core Video)
- Hardware-accelerated processing on Apple Silicon and Intel Macs
- Optimized for low power consumption on mobile devices
- Support for high-quality ProRes encoding
- Integration with iOS camera and microphone permissions

## Sample Code

### iOS Camera Capture

```
var pipeline = new MediaBlocksPipeline();

// iOS video source
var videoSource = new IOSVideoSourceBlock(videoSettings);

// Process and display
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoSource.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### macOS Audio Capture and Playback

```
var pipeline = new MediaBlocksPipeline();

// macOS audio source
var audioSource = new SystemAudioSourceBlock(audioSettings);

// macOS audio sink
var audioSink = new OSXAudioSinkBlock();
pipeline.Connect(audioSource.Output, audioSink.Input);

await pipeline.StartAsync();
```

### ProRes Encoding

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("input.mp4"));

// Apple ProRes encoder
// AppleProResEncoderSettings exposes Quality (double 0.0-1.0), Bitrate, MaxKeyframeInterval,
// MaxKeyFrameIntervalDuration, AllowFrameReordering, PreserveAlpha, Realtime — not a named profile enum.
var proresSettings = new AppleProResEncoderSettings
{
    Quality = 0.8
};
var proresEncoder = new AppleProResEncoderBlock(proresSettings);
pipeline.Connect(fileSource.VideoOutput, proresEncoder.Input);

// Output to MOV file
var movSink = new MOVSinkBlock(new MOVSinkSettings("output.mov"));
pipeline.Connect(proresEncoder.Output, movSink.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

## Platforms

iOS, macOS, tvOS.

## Related Documentation

- [Sources](../Sources/) - All source blocks including Apple-specific
- [VideoEncoders](../VideoEncoders/) - Video encoding including ProRes
- [AudioRendering](../AudioRendering/) - Audio playback

---END OF PAGE---


## Linux VA-API Hardware Video Acceleration in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/_Linux/
**Description:** Use VA-API GPU-accelerated video encoding and decoding on Linux with VisioForge Media Blocks SDK. Ubuntu and Debian platform support for .NET apps.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS
**API:** VAAPIH264DecoderBlock, UniversalSourceBlock, UniversalSourceSettings, VideoRendererBlock, VAAPIHEVCDecoderBlock

# Linux Platform Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

This section covers MediaBlocks specifically optimized for Linux platforms.

## Available Blocks

### VA-API Hardware Decoders

Linux provides hardware-accelerated video decoding through VA-API (Video Acceleration API):

- **VAAPIH264DecoderBlock**: Hardware H.264/AVC decoding
- **VAAPIHEVCDecoderBlock**: Hardware H.265/HEVC decoding
- **VAAPIJPEGDecoderBlock**: Hardware JPEG decoding
- **VAAPIVC1DecoderBlock**: Hardware VC-1 decoding

See [Video Decoders Documentation](../VideoDecoders/)

## Platform Requirements

- **Linux**: Any modern Linux distribution
- **VA-API**: libva and appropriate driver for your GPU
- **Hardware**: Intel, AMD, or other GPU with VA-API support

## Features

- **Hardware Acceleration**: GPU-based video decoding
- **Low CPU Usage**: Offload decoding to dedicated hardware
- **Wide Compatibility**: Works with Intel, AMD, and other GPUs
- **Power Efficiency**: Reduced power consumption
- **Multi-Stream**: Handle multiple HD/4K streams

## Sample Code

### Hardware H.264 Decoding

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video.mp4"));

// VA-API hardware decoder
if (VAAPIH264DecoderBlock.IsAvailable())
{
    var vaapiDecoder = new VAAPIH264DecoderBlock();
    pipeline.Connect(fileSource.VideoOutput, vaapiDecoder.Input);

    var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
    pipeline.Connect(vaapiDecoder.Output, videoRenderer.Input);
}
else
{
    // Fallback to software decoder
    var decoder = new UniversalDecoderBlock(MediaBlockPadMediaType.Video);
    pipeline.Connect(fileSource.VideoOutput, decoder.Input);

    var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
    pipeline.Connect(decoder.VideoOutput, videoRenderer.Input);
}

await pipeline.StartAsync();
```

### Multiple Hardware Decoders

```
var pipeline = new MediaBlocksPipeline();

// Decode H.264 stream
var h264Source = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("h264.mp4"));
var h264Decoder = new VAAPIH264DecoderBlock();
pipeline.Connect(h264Source.VideoOutput, h264Decoder.Input);

// Decode H.265 stream
var h265Source = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("h265.mp4"));
var h265Decoder = new VAAPIHEVCDecoderBlock();
pipeline.Connect(h265Source.VideoOutput, h265Decoder.Input);

// Mix both streams (example)
var mixer = new VideoMixerBlock(mixerSettings);
pipeline.Connect(h264Decoder.Output, mixer.Inputs[0]);
pipeline.Connect(h265Decoder.Output, mixer.Inputs[1]);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(mixer.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

## Setup and Configuration

### Installing VA-API

**Ubuntu/Debian:**

```
sudo apt-get install libva2 libva-drm2 vainfo
```

**Fedora/RHEL:**

```
sudo dnf install libva libva-utils
```

### Checking VA-API Support

```
vainfo
```

This command displays available VA-API profiles and entrypoints.

### Driver Installation

**Intel GPUs:**

```
# Ubuntu/Debian
sudo apt-get install intel-media-va-driver

# Fedora/RHEL
sudo dnf install intel-media-driver
```

**AMD GPUs:**

```
# Ubuntu/Debian
sudo apt-get install mesa-va-drivers

# Fedora/RHEL
sudo dnf install mesa-va-drivers
```

## Checking Hardware Support in Code

```
// Check if VA-API H.264 decoder is available
if (VAAPIH264DecoderBlock.IsAvailable())
{
    Console.WriteLine("VA-API H.264 hardware decoding is available");
    var decoder = new VAAPIH264DecoderBlock();
}
else
{
    Console.WriteLine("VA-API not available, using software decoder");
    var decoder = new UniversalDecoderBlock(MediaBlockPadMediaType.Video);
}
```

## Performance Tips

- Ensure VA-API drivers are properly installed
- Use hardware decoders when available for best performance
- Check decoder availability before creating blocks
- Monitor GPU memory usage when processing multiple streams
- Use `vainfo` command to verify hardware support

## Troubleshooting

**VA-API not working:** 1. Verify driver installation with `vainfo` 2. Check user permissions (may need to be in `video` or `render` group) 3. Ensure GStreamer VA-API plugins are installed: `gstreamer1.0-vaapi`

**Permission issues:**

```
# Add user to video group
sudo usermod -a -G video $USER
# Log out and back in for changes to take effect
```

## Platforms

Linux (Ubuntu, Debian, Fedora, RHEL, Arch, and other distributions).

Requires VA-API support with appropriate drivers.

## Related Documentation

- [VideoDecoders](../VideoDecoders/) - Hardware decoding blocks
- [Nvidia](../Nvidia/) - Nvidia GPU acceleration (also works on Linux)

---END OF PAGE---


## AMD AMA Hardware Video Encoding & Decoding in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/AMA/
**Description:** Encode and decode H.264, HEVC, and AV1 on AMD Alveo accelerators with the AMA Video SDK in VisioForge Media Blocks SDK for .NET on Linux.
**Tags:** Media Blocks SDK, .NET, Linux, Streaming, AV1, H.265
**API:** AMAH264EncoderSettings, AMAHEVCEncoderSettings, AMAAV1EncoderSettings, AMAH264DecoderSettings, AMAHEVCDecoderSettings, AMAAV1DecoderSettings, AMAScalerBlock, AMAScalerSettings

# AMD AMA Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The **AMD AMA Video SDK** is AMD's hardware media-acceleration platform for AMD Alveo media accelerators. It ships a family of GStreamer elements (`ama_h264enc`, `ama_h265enc`, `ama_av1enc`, `ama_h264dec`, `ama_h265dec`, `ama_av1dec`, `ama_scaler`, `ama_upload`, `ama_download`) that run H.264, HEVC, and AV1 encoding, decoding, and scaling entirely on the accelerator. VisioForge Media Blocks SDK wraps this platform so you can offload video processing to AMD hardware from a standard C# pipeline. The AMA platform is distinct from AMD AMF (which drives Radeon GPUs) — AMA targets dedicated Alveo media accelerators such as the **Alveo MA35D**, the device currently supported.

**Key facts:**

- **Platform:** AMD AMA Video SDK on AMD Alveo media accelerators (currently the Alveo MA35D).
- **Codecs:** H.264, HEVC (H.265), and AV1 — hardware encode and decode.
- **Operating system:** Linux x86\_64 only. There is no Windows or macOS AMA support.
- **Device selection:** the `Device` property picks the accelerator — `-1` (default) auto-selects, `0`/`1`/`2`… pin a specific card when several AMD devices are present.
- **Memory model:** encoding/decoding/scaling run in device memory; the SDK inserts `ama_upload` / `ama_download` automatically when data crosses to or from system memory.
- **Distribution:** VisioForge ships only the managed wrapper. The AMA runtime (kernel driver + GStreamer plugins) is installed separately from AMD; no AMD binaries are bundled with the SDK.

## Prerequisites

Before the AMA blocks can be used, the target machine must have:

- Linux x86\_64 (Ubuntu, Alma/RHEL, or Debian per the AMD AMA SDK support matrix).
- An AMD Alveo media accelerator installed and provisioned (kernel driver, huge pages, IOMMU / Above-4G decoding enabled in the host firmware).
- The AMD AMA Video SDK installed, including its GStreamer plugins, so the `ama_*` elements are discoverable by GStreamer.

Every AMA settings and block class exposes a static `IsAvailable()` method that probes for the required `ama_*` elements. Call it before building a pipeline and fall back to a software or other-vendor encoder when it returns `false`:

```
if (AMAH264EncoderSettings.IsAvailable())
{
    // AMA H.264 encoder is present — use hardware encoding.
}
```

## AMA H.264 encoder

Hardware H.264 encoder backed by the `ama_h264enc` element. Configure it with `AMAH264EncoderSettings` (implements `IH264EncoderSettings`) and pass it to a standard `H264EncoderBlock`.

### Block info

Name: H264EncoderBlock (with `AMAH264EncoderSettings`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | H264 | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->H264EncoderBlock;
    H264EncoderBlock-->MP4SinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

// AMD AMA (Alveo) hardware H.264 encoder. Device = -1 auto-selects the accelerator.
var h264Settings = new AMAH264EncoderSettings
{
    Device = -1,
    Bitrate = 6000, // Kbps
    RateControl = AMARateControl.CBR
};
var h264EncoderBlock = new H264EncoderBlock(h264Settings);
pipeline.Connect(fileSource.VideoOutput, h264EncoderBlock.Input);

var mp4SinkBlock = new MP4SinkBlock(new MP4SinkSettings("output.mp4"));
pipeline.Connect(h264EncoderBlock.Output, mp4SinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Linux (x86\_64) with the AMD AMA Video SDK.

## AMA HEVC encoder

Hardware HEVC (H.265) encoder backed by the `ama_h265enc` element. Configure it with `AMAHEVCEncoderSettings` (implements `IHEVCEncoderSettings`) and pass it to a standard `HEVCEncoderBlock`.

### Block info

Name: HEVCEncoderBlock (with `AMAHEVCEncoderSettings`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | HEVC | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->HEVCEncoderBlock;
    HEVCEncoderBlock-->MP4SinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var hevcSettings = new AMAHEVCEncoderSettings
{
    Device = -1,
    Bitrate = 6000, // Kbps
    TuneMetrics = AMATuneMetrics.VMAF
};
var hevcEncoderBlock = new HEVCEncoderBlock(hevcSettings);
pipeline.Connect(fileSource.VideoOutput, hevcEncoderBlock.Input);

var mp4SinkBlock = new MP4SinkBlock(new MP4SinkSettings("output.mp4"));
pipeline.Connect(hevcEncoderBlock.Output, mp4SinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Linux (x86\_64) with the AMD AMA Video SDK.

## AMA AV1 encoder

Hardware AV1 encoder backed by the `ama_av1enc` element. Configure it with `AMAAV1EncoderSettings` (implements `IAV1EncoderSettings`) and pass it to a standard `AV1EncoderBlock`. AV1 adds a `DeviceType` property (`AMAAV1DeviceType`) that selects the AV1 engine.

### Block info

Name: AV1EncoderBlock (with `AMAAV1EncoderSettings`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | AV1 | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AV1EncoderBlock;
    AV1EncoderBlock-->MP4SinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var av1Settings = new AMAAV1EncoderSettings
{
    Device = -1,
    DeviceType = AMAAV1DeviceType.Type1,
    Bitrate = 6000 // Kbps
};
var av1EncoderBlock = new AV1EncoderBlock(av1Settings);
pipeline.Connect(fileSource.VideoOutput, av1EncoderBlock.Input);

var mp4SinkBlock = new MP4SinkBlock(new MP4SinkSettings("output.mp4"));
pipeline.Connect(av1EncoderBlock.Output, mp4SinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Linux (x86\_64) with the AMD AMA Video SDK.

## Common encoder settings

The three AMA encoder settings classes share the same core properties (AV1 additionally exposes `DeviceType`, and its QP range is 0–255 rather than 0–51):

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Device` | int | −1 | Accelerator to encode on. −1 auto-selects. |
| `Slice` | int | −1 | Sub-engine (slice) of the device. −1 = auto. |
| `Bitrate` | uint | 5000 | Target bitrate in Kbps. |
| `MaxBitrate` | int | −1 | Peak bitrate in Kbps for VBR/CVBR. −1 = auto. |
| `RateControl` | `AMARateControl` | Auto | Rate-control mode. |
| `QPMode` | `AMAQPMode` | Auto | QP control mode. |
| `QP` | int | −1 | Fixed QP in constant-QP mode. −1 = disabled. |
| `MinQP` / `MaxQP` | int | 0 / 51 (255 for AV1) | Allowed QP range. |
| `BFrames` | int | −1 | B-frames between P-frames. −1 = auto. |
| `GOPLength` | int | −1 | Maximum I-frame distance. −1 = auto. |
| `Tier` | `AMATier` | Auto | Encoding tier. |
| `TuneMetrics` | `AMATuneMetrics` | VQ | Objective quality metric to tune for. |
| `SpatialAQ` / `TemporalAQ` | bool | true | Adaptive-quantization toggles (with `*Gain` 0–255). |
| `LookaheadDepth` | int | −1 | Look-ahead depth. −1 = auto. |
| `LatencyMs` | int | −1 | Encoder latency target (ms). −1 = auto. |

## AMA decoders

Hardware decoders for H.264 (`ama_h264dec`), HEVC (`ama_h265dec`), and AV1 (`ama_av1dec`). Configure them with `AMAH264DecoderSettings` / `AMAHEVCDecoderSettings` / `AMAAV1DecoderSettings` (implementing `IH264/HEVC/AV1DecoderSettings`) and pass them to the corresponding decoder block. When a decoder feeds a system-memory consumer, the SDK appends `ama_download` automatically.

### Block info

Name: `H264DecoderBlock` / `HEVCDecoderBlock` / `AV1DecoderBlock` (with an AMA settings object).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Encoded video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Device` | int | −1 | Accelerator to decode on. −1 auto-selects. |
| `LowLatency` | bool | false | Enable low-latency decoding. |
| `LatencyLogging` | bool | false | Log latency information to syslog. |
| `AllowDownscaling` | bool | false | Allow decoder-level downscaling. |

### The sample pipeline

```
graph LR;
    BasicFileSourceBlock-->UniversalDemuxBlock;
    UniversalDemuxBlock-->HEVCDecoderBlock;
    HEVCDecoderBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// AMD AMA (Alveo) hardware HEVC decoder.
var hevcDecoder = new HEVCDecoderBlock(new AMAHEVCDecoderSettings { Device = -1 });

var basicFileSource = new BasicFileSourceBlock("test_hevc.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_hevc.mp4");
var mediaInfo = reader.Info;
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), hevcDecoder.Input);
pipeline.Connect(hevcDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Linux (x86\_64) with the AMD AMA Video SDK.

## AMA scaler

The `AMAScalerBlock` resizes video (and optionally halves the frame rate) on the accelerator using the `ama_scaler` element. The block wraps the chain `ama_upload ! ama_scaler ! capsfilter ! ama_download`, so it accepts system-memory frames on its input and emits system-memory frames downstream — you can drop it into any pipeline without managing device memory yourself.

### Block info

Name: `AMAScalerBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Video (system memory) | 1 |
| Output video | Video (system memory) | 1 |

### Settings

`AMAScalerSettings`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Width` / `Height` | int | 0 | Target output size in pixels (144–7580). 0 leaves the dimension unconstrained. |
| `Device` | int | −1 | Accelerator to scale on. −1 auto-selects. |
| `Framerate` | `AMAScalerFramerate` | Auto | Output frame-rate mode (Auto / Full / Half). |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AMAScalerBlock;
    AMAScalerBlock-->H264EncoderBlock;
    H264EncoderBlock-->MP4SinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

// Scale to 1280x720 on the AMD accelerator.
var scaler = new AMAScalerBlock(new AMAScalerSettings(1280, 720));
pipeline.Connect(fileSource.VideoOutput, scaler.Input);

var h264EncoderBlock = new H264EncoderBlock(new AMAH264EncoderSettings());
pipeline.Connect(scaler.Output, h264EncoderBlock.Input);

var mp4SinkBlock = new MP4SinkBlock(new MP4SinkSettings("output.mp4"));
pipeline.Connect(h264EncoderBlock.Output, mp4SinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Linux (x86\_64) with the AMD AMA Video SDK.

## Full hardware transcode

An AMA decoder, the AMA scaler, and an AMA encoder chained together run every stage — decode, scale, and encode — on the AMD accelerator. Each block is self-contained: it accepts and emits system-memory frames, so the SDK moves data on and off the device (`ama_download` / `ama_upload`) at each block boundary while the decode, scale, and encode work itself runs on the accelerator:

```
graph LR;
    Source-->AMADecoder-->AMAScaler-->AMAEncoder-->Sink;
```

Wire an `H264DecoderBlock` (with `AMAH264DecoderSettings`), an `AMAScalerBlock`, and an `HEVCEncoderBlock` (with `AMAHEVCEncoderSettings`) in sequence to transcode H.264 → scaled HEVC, with every stage running on the AMD accelerator.

## Enums reference

| Enum | Members |
| --- | --- |
| `AMARateControl` | Auto, CQP, CBR, VBR, CVBR |
| `AMAQPMode` | Auto, RelativeLoad, Uniform |
| `AMATier` | Auto, Main, High |
| `AMATuneMetrics` | VQ, PSNR, SSIM, VMAF |
| `AMAAV1DeviceType` | Any, Type1, Type2 |
| `AMAScalerFramerate` | Auto, Full, Half |

## Selecting the device

Every AMA settings object (`AMA*EncoderSettings`, `AMA*DecoderSettings`, and `AMAScalerSettings`) exposes a `Device` property that decides which AMD accelerator runs the work — set it on the settings object you pass to the block (the blocks themselves have no `Device` property):

- `Device = -1` (default) — the AMA runtime auto-selects an available accelerator.
- `Device = 0` / `1` / `2`… — pins the work to a specific card, which is how you choose one Alveo accelerator when several AMD devices are installed in the same host.

Because AMA targets dedicated Alveo media accelerators rather than a Radeon GPU, selecting an AMA settings class already directs the work to the accelerator, not to any integrated AMD graphics.

## Limitations

- **Linux x86\_64 only.** The AMA elements do not exist on Windows or macOS; the settings classes are compiled only into the Linux build of the SDK.
- **MediaBlocks pipeline only.** The AMA encoders run on the direct Media Blocks pipeline. They are not supported on the `VideoEditCoreX` encodebin output path and raise a `NotSupportedException` there — build AMA encoding with `H264EncoderBlock` / `HEVCEncoderBlock` / `AV1EncoderBlock` instead.
- The AMA runtime must be installed separately (see [Prerequisites](#prerequisites)); the SDK bundles no AMD binaries.

## FAQ

### Does VisioForge support AMD AMA and Alveo hardware encoding?

Yes. VisioForge Media Blocks SDK wraps the AMD AMA Video SDK to provide H.264, HEVC, and AV1 hardware encoding and decoding, plus a hardware scaler, on AMD Alveo media accelerators. Support is Linux x86\_64 only and requires the AMD AMA Video SDK to be installed.

### How do I choose which AMD device the AMA encoder runs on?

Set the `Device` property on the AMA settings object. `-1` (the default) auto-selects an available accelerator; `0`, `1`, `2`, and so on pin the encode, decode, or scale to a specific card when multiple AMD devices are present in the host.

### Is AMA hardware acceleration available on Windows or macOS?

No. The AMD AMA Video SDK is Linux x86\_64 only, so the AMA encoder, decoder, and scaler blocks are available only on Linux. On Windows or macOS, use the AMF, NVENC, QSV, or software encoders instead.

### What is the difference between AMD AMF and AMD AMA encoders?

AMD AMF drives Radeon GPUs and is available on Windows, Linux, and macOS through classes such as `AMFH264EncoderSettings`. AMD AMA is a separate platform that drives dedicated Alveo media accelerators (such as the MA35D) on Linux, exposed through the `AMA*` classes. They target different hardware and are configured with different settings classes.

### How do I run a full transcode on the AMD accelerator?

Chain an AMA decoder, the `AMAScalerBlock`, and an AMA encoder. Each stage runs on the AMD accelerator; the blocks exchange frames through system memory, and the SDK moves data on and off the device automatically (`ama_download` / `ama_upload`) at each boundary.

## See Also

- [Video Encoders](../VideoEncoders/) — all H.264, HEVC, AV1, and VP9 encoder blocks, including the AMD AMF, NVENC, and QSV hardware encoders.
- [Video Decoders](../VideoDecoders/) — hardware and software decoder blocks for every supported codec.
- [Linux-Specific Blocks](../_Linux/) — blocks and features available on Linux builds of the SDK.
- [HEVC Encoding Guide](../../general/video-encoders/hevc/) — hardware HEVC encoding across AMD, NVIDIA, and Intel.
- [AV1 Encoding Guide](../../general/video-encoders/av1/) — AV1 hardware and software encoding options.

---END OF PAGE---


## Audio Encoder Blocks - AAC, MP3, FLAC, Opus in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/AudioEncoders/
**Description:** Encode audio to AAC, MP3, FLAC, Opus, Vorbis, and WMA using VisioForge Media Blocks SDK. Configurable bitrate, sample rate, and channel settings.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming
**API:** UniversalSourceBlock, MediaBlocksPipeline, UniversalSourceSettings, FileSinkBlock, AACEncoderBlock

# Audio encoders blocks

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Audio encoding is the process of converting raw audio data into a compressed format. This process is essential for reducing the size of audio files, making them easier to store and stream over the internet. VisioForge Media Blocks SDK provides a wide range of audio encoders that support various formats and codecs.

## Availability checks

Before using any encoder, you should check if it's available on the current platform. Each encoder block provides a static `IsAvailable()` method for this purpose:

```
// For most encoders
if (EncoderBlock.IsAvailable())
{
    // Use the encoder
}

// For AAC encoder which requires passing settings
if (AACEncoderBlock.IsAvailable(settings))
{
    // Use the AAC encoder
}
```

This check is important because not all encoders are available on all platforms. Always perform this check before attempting to use an encoder to avoid runtime errors.

## AAC encoder

`AAC (Advanced Audio Coding)`: A lossy compression format known for its efficiency and superior sound quality compared to MP3, widely used in digital music and broadcasting.

AAC encoder is used for encoding files in MP4, MKV, M4A and some other formats, as well as for network streaming using RTSP and HLS.

Use the `AACEncoderSettings` class to set the parameters.

### Block info

Name: AACEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | AAC | 1 |

### Constructor options

```
// Constructor with custom settings
public AACEncoderBlock(IAACEncoderSettings settings)

// Constructor without parameters (uses default settings)
public AACEncoderBlock() // Uses GetDefaultSettings() internally
```

### Settings

The `AACEncoderBlock` works with any implementation of the `IAACEncoderSettings` interface. Different implementations are available depending on the platform:

- `AVENCAACEncoderSettings` - Available on Windows and macOS/Linux (preferred when available)
- `MFAACEncoderSettings` - Windows Media Foundation implementation (Windows only)
- `VOAACEncoderSettings` - Used on Android and iOS

You can use the static `GetDefaultSettings()` method to get the optimal encoder settings for the current platform:

```
var settings = AACEncoderBlock.GetDefaultSettings();
```

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AACEncoderBlock;
    AACEncoderBlock-->MP4SinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var aacEncoderBlock = new AACEncoderBlock(new MFAACEncoderSettings() { Bitrate = 192 });

pipeline.Connect(fileSource.AudioOutput, aacEncoderBlock.Input);

var m4aSinkBlock = new MP4SinkBlock(new MP4SinkSettings(@"output.m4a"));
pipeline.Connect(aacEncoderBlock.Output, m4aSinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

## ADPCM encoder

`ADPCM (Adaptive Differential Pulse Code Modulation)`: A type of audio compression that reduces the bit rate required for audio storage and transmission while maintaining audio quality through adaptive prediction.

ADPCM encoder is used for embedding audio streams in DV, WAV and AVI formats.

Use the `ADPCMEncoderSettings` class to set the parameters.

### Block info

Name: ADPCMEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | ADPCM | 1 |

### Constructor options

```
// Constructor with block align parameter
public ADPCMEncoderBlock(int blockAlign = 1024)
```

The `blockAlign` parameter defines the block alignment in bytes. The default value is 1024.

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->ADPCMEncoderBlock;
    ADPCMEncoderBlock-->WAVSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// ADPCMEncoderBlock takes an optional block-align int (default 1024) — no Settings class.
var adpcmEncoderBlock = new ADPCMEncoderBlock(blockAlign: 1024);
pipeline.Connect(fileSource.AudioOutput, adpcmEncoderBlock.Input);

var wavSinkBlock = new WAVSinkBlock(@"output.wav");
pipeline.Connect(adpcmEncoderBlock.Output, wavSinkBlock.Input);

await pipeline.StartAsync();
```

## AptX encoder

`AptX`: A psychoacoustic audio codec algorithm that provides CD-like audio quality with low latency for Bluetooth audio applications. Uses 4:1 compression ratio and supports stereo audio only, making it ideal for wireless audio transmission.

### Block info

Name: AptXEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM | 1 |
| Output | AptX | 1 |

### Constructor options

```
// Constructor with custom settings
public AptXEncoderBlock(AptXEncoderSettings settings)
```

### Settings

The `AptXEncoderBlock` requires `AptXEncoderSettings` for configuration.

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AptXEncoderBlock;
    AptXEncoderBlock-->AudioRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.wav";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var aptxSettings = new AptXEncoderSettings();
var aptxEncoder = new AptXEncoderBlock(aptxSettings);
pipeline.Connect(fileSource.AudioOutput, aptxEncoder.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(aptxEncoder.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, Linux (requires GStreamer AptX plugin).

## AptX decoder

`AptX Decoder`: Decodes AptX compressed audio streams into raw PCM audio. This decoder handles AptX bitstreams from Bluetooth audio sources and outputs high-quality stereo PCM audio.

### Block info

Name: AptXDecoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | AptX | 1 |
| Output | PCM | 1 |

### Constructor options

```
// Constructor with custom settings
public AptXDecoderBlock(AptXDecoderSettings settings)
```

### Settings

The `AptXDecoderBlock` requires `AptXDecoderSettings` for configuration.

### The sample pipeline

```
graph LR;
    AptXSourceBlock-->AptXDecoderBlock;
    AptXDecoderBlock-->AudioRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assume we have an AptX source (e.g., Bluetooth receiver)
var aptxSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("aptx_stream"));

var aptxSettings = new AptXDecoderSettings();
var aptxDecoder = new AptXDecoderBlock(aptxSettings);
pipeline.Connect(aptxSource.AudioOutput, aptxDecoder.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(aptxDecoder.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, Linux (requires GStreamer AptX plugin).

## ALAW encoder

`ALAW (A-law algorithm)`: A standard companding algorithm used in digital communications systems to optimize the dynamic range of an analog signal for digitizing.

ALAW encoder is used for embedding audio streams in WAV format or transmitting over IP.

Use the `ALAWEncoderSettings` class to set the parameters.

### Block info

Name: ALAWEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | ALAW | 1 |

### Constructor options

```
// Default constructor
public ALAWEncoderBlock()
```

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->ALAWEncoderBlock;
    ALAWEncoderBlock-->WAVSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// ALAWEncoderBlock has a parameterless constructor.
var alawEncoderBlock = new ALAWEncoderBlock();
pipeline.Connect(fileSource.AudioOutput, alawEncoderBlock.Input);

var wavSinkBlock = new WAVSinkBlock(@"output.wav");
pipeline.Connect(alawEncoderBlock.Output, wavSinkBlock.Input);

await pipeline.StartAsync();
```

## FLAC encoder

`FLAC (Free Lossless Audio Codec)`: A lossless audio compression format that preserves audio quality while significantly reducing file size compared to uncompressed formats like WAV.

FLAC encoder is used for encoding audio in FLAC format.

Use the `FLACEncoderSettings` class to set the parameters.

### Block info

Name: FLACEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | FLAC | 1 |

### Constructor options

```
// Constructor with settings
public FLACEncoderBlock(FLACEncoderSettings settings)
```

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->FLACEncoderBlock;
    FLACEncoderBlock-->FileSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var flacEncoderBlock = new FLACEncoderBlock(new FLACEncoderSettings());
pipeline.Connect(fileSource.AudioOutput, flacEncoderBlock.Input);

var fileSinkBlock = new FileSinkBlock(@"output.flac");
pipeline.Connect(flacEncoderBlock.Output, fileSinkBlock.Input);

await pipeline.StartAsync();
```

## MP2 encoder

`MP2 (MPEG-1 Audio Layer II)`: An older audio compression format that preceded MP3, still used in some broadcasting applications due to its efficiency at specific bitrates.

MP2 encoder is used for transmitting over IP or embedding to AVI/MPEG-2 formats.

Use the `MP2EncoderSettings` class to set the parameters.

### Block info

Name: MP2EncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | audio/mpeg | 1 |

### Constructor options

```
// Constructor with settings
public MP2EncoderBlock(MP2EncoderSettings settings)
```

The `MP2EncoderSettings` class allows you to configure parameters such as:

- Bitrate (default: 192 kbps)

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MP2EncoderBlock;
    MP2EncoderBlock-->FileSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var mp2EncoderBlock = new MP2EncoderBlock(new MP2EncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, mp2EncoderBlock.Input);

var fileSinkBlock = new FileSinkBlock(@"output.mp2");
pipeline.Connect(mp2EncoderBlock.Output, fileSinkBlock.Input);

await pipeline.StartAsync();
```

## MP3 encoder

`MP3 (MPEG Audio Layer III)`: A popular lossy audio format that revolutionized digital music distribution by compressing files while retaining a reasonable sound quality.

An MP3 encoder can convert audio streams into MP3 files or embed MP3 audio streams in formats like AVI, MKV, and others.

Use the `MP3EncoderSettings` class to set the parameters.

### Block info

Name: MP3EncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | audio/mpeg | 1 |

### Constructor options

```
// Constructor with settings and optional parser flag
public MP3EncoderBlock(MP3EncoderSettings settings, bool addParser = false)
```

The `addParser` parameter is used to add a parser to the output stream, which is required for certain streaming applications like RTMP (YouTube/Facebook) streaming.

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MP3EncoderBlock;
    MP3EncoderBlock-->FileSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var mp3EncoderBlock = new MP3EncoderBlock(new MP3EncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, mp3EncoderBlock.Input);

var fileSinkBlock = new FileSinkBlock(@"output.mp3");
pipeline.Connect(mp3EncoderBlock.Output, fileSinkBlock.Input);

await pipeline.StartAsync();
```

### Streaming to RTMP example

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Add parser is set to true for RTMP streaming
var mp3EncoderBlock = new MP3EncoderBlock(new MP3EncoderSettings() { Bitrate = 192 }, addParser: true);
pipeline.Connect(fileSource.AudioOutput, mp3EncoderBlock.Input);

// Connect to RTMP sink — RTMPSinkSettings has no string ctor; URL goes into the Location property.
var rtmpSink = new RTMPSinkBlock(new RTMPSinkSettings { Location = "rtmp://streaming-server/live/stream" });
pipeline.Connect(mp3EncoderBlock.Output, rtmpSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

## OPUS encoder

`OPUS`: A highly efficient lossy audio compression format designed for the internet with low latency and high audio quality, making it ideal for real-time applications like WebRTC.

OPUS encoder is used for embedding audio streams in WebM or OGG formats.

Use the `OPUSEncoderSettings` class to set the parameters.

### Block info

Name: OPUSEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | OPUS | 1 |

### Constructor options

```
// Constructor with settings
public OPUSEncoderBlock(OPUSEncoderSettings settings)
```

The `OPUSEncoderSettings` class allows you to configure parameters such as:

- Bitrate (default: 128 kbps)
- Audio bandwidth
- Frame size and other encoding parameters

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->OPUSEncoderBlock;
    OPUSEncoderBlock-->WebMSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var opusEncoderBlock = new OPUSEncoderBlock(new OPUSEncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, opusEncoderBlock.Input);

var webmSinkBlock = new WebMSinkBlock(new WebMSinkSettings(@"output.webm"));
pipeline.Connect(opusEncoderBlock.Output, webmSinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

## Speex encoder

`Speex`: A patent-free audio compression format designed specifically for speech, offering high compression rates while maintaining clarity for voice recordings.

Speex encoder is used for embedding audio streams in OGG format.

Use the `SpeexEncoderSettings` class to set the parameters.

### Block info

Name: SpeexEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | Speex | 1 |

### Constructor options

```
// Constructor with settings
public SpeexEncoderBlock(SpeexEncoderSettings settings)
```

The `SpeexEncoderSettings` class allows you to configure parameters such as:

- Mode (SpeexEncoderMode): NarrowBand, WideBand, UltraWideBand
- Quality
- Complexity
- VAD (Voice Activity Detection)
- DTX (Discontinuous Transmission)

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SpeexEncoderBlock;
    SpeexEncoderBlock-->OGGSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var speexEncoderBlock = new SpeexEncoderBlock(new SpeexEncoderSettings() { Mode = SpeexEncoderMode.NarrowBand });
pipeline.Connect(fileSource.AudioOutput, speexEncoderBlock.Input);

// OGGSinkBlock has dynamic inputs — call CreateNewInput(...) to get a typed audio pad.
var oggSinkBlock = new OGGSinkBlock(new OGGSinkSettings(@"output.ogg"));
pipeline.Connect(speexEncoderBlock.Output, oggSinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

## Vorbis encoder

`Vorbis`: An open-source, lossy audio compression format designed as a free alternative to MP3, often used within the OGG container format.

Vorbis encoder is used for embedding audio streams in OGG or WebM formats.

Use the `VorbisEncoderSettings` class to set the parameters.

### Block info

Name: VorbisEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | Vorbis | 1 |

### Constructor options

```
// Constructor with settings
public VorbisEncoderBlock(VorbisEncoderSettings settings)
```

The `VorbisEncoderSettings` class allows you to configure parameters such as:

- Quality: Integer value between -1 and 10 (default 4). Used when `RateControl = VorbisEncoderRateControl.Quality`.
- Bitrate: Target bitrate in Kbit/s. Used when `RateControl = VorbisEncoderRateControl.Bitrate`.
- RateControl: `VorbisEncoderRateControl.Quality` (VBR quality mode) or `VorbisEncoderRateControl.Bitrate` (bitrate-based).

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VorbisEncoderBlock;
    VorbisEncoderBlock-->OGGSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var vorbisEncoderBlock = new VorbisEncoderBlock(new VorbisEncoderSettings { Quality = 5 });
pipeline.Connect(fileSource.AudioOutput, vorbisEncoderBlock.Input);

// OGGSinkBlock has dynamic inputs — call CreateNewInput(...) to get a typed audio pad.
var oggSinkBlock = new OGGSinkBlock(new OGGSinkSettings(@"output.ogg"));
pipeline.Connect(vorbisEncoderBlock.Output, oggSinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

## WAV encoder

`WAV (Waveform Audio File Format)`: An uncompressed audio format that preserves audio quality but results in larger file sizes compared to compressed formats.

WAV encoder is used for encoding audio into WAV format.

Use the `WAVEncoderSettings` class to set the parameters.

### Block info

Name: WAVEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | WAV | 1 |

### Constructor options

```
// Constructor with settings
public WAVEncoderBlock(WAVEncoderSettings settings)
```

The `WAVEncoderSettings` class allows you to configure various parameters for the WAV format.

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->WAVEncoderBlock;
    WAVEncoderBlock-->FileSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var wavEncoderBlock = new WAVEncoderBlock(new WAVEncoderSettings());
pipeline.Connect(fileSource.AudioOutput, wavEncoderBlock.Input);

var fileSinkBlock = new FileSinkBlock(@"output.wav");
pipeline.Connect(wavEncoderBlock.Output, fileSinkBlock.Input);

await pipeline.StartAsync();
```

## WavPack encoder

`WavPack`: A free and open-source lossless audio compression format that offers high compression rates while maintaining excellent audio quality, supporting hybrid lossy/lossless modes.

WavPack encoder is used for encoding audio in WavPack format, which is ideal for archiving audio with perfect fidelity.

Use the `WavPackEncoderSettings` class to set the parameters.

### Block info

Name: WavPackEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | WavPack | 1 |

### Constructor options

```
// Constructor with settings
public WavPackEncoderBlock(WavPackEncoderSettings settings)
```

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->WavPackEncoderBlock;
    WavPackEncoderBlock-->FileSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var wavpackEncoderBlock = new WavPackEncoderBlock(new WavPackEncoderSettings());
pipeline.Connect(fileSource.AudioOutput, wavpackEncoderBlock.Input);

var fileSinkBlock = new FileSinkBlock(@"output.wv");
pipeline.Connect(wavpackEncoderBlock.Output, fileSinkBlock.Input);

await pipeline.StartAsync();
```

## WMA encoder

`WMA (Windows Media Audio)`: A proprietary audio compression format developed by Microsoft, offering various compression levels and features for different audio applications.

WMA encoder is used for encoding audio in WMA format.

Use the `WMAEncoderSettings` class to set the parameters.

### Block info

Name: WMAEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PCM/IEEE | 1 |
| Output | WMA | 1 |

### Constructor options

```
// Constructor with settings
public WMAEncoderBlock(WMAEncoderSettings settings)
```

The `WMAEncoderSettings` class allows you to configure parameters such as:

- Bitrate (default: 128 kbps)
- Quality settings
- VBR (Variable Bit Rate) options

### Default settings

You can use the static method to get default settings:

```
var settings = WMAEncoderBlock.GetDefaultSettings();
```

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->WMAEncoderBlock;
    WMAEncoderBlock-->ASFSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var wmaEncoderBlock = new WMAEncoderBlock(new WMAEncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, wmaEncoderBlock.Input);

var asfSinkBlock = new ASFSinkBlock(new ASFSinkSettings(@"output.wma"));
pipeline.Connect(wmaEncoderBlock.Output, asfSinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

## Resource management

All encoder blocks implement `IDisposable` and have internal cleanup mechanisms. It's recommended to properly dispose of them when they're no longer needed:

```
// Using block
using (var encoder = new MP3EncoderBlock(settings))
{
    // Use encoder
}

// Or manual disposal
var encoder = new MP3EncoderBlock(settings);
try {
    // Use encoder
}
finally {
    encoder.Dispose();
}
```

## Platforms

Windows, macOS, Linux, iOS, Android.

Note that not all encoders are available on all platforms. Always use the `IsAvailable()` method to check for availability before using an encoder.

---END OF PAGE---


## Audio Processing Blocks for C# .NET - Mixer, EQ, Effects
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/AudioProcessing/
**Description:** Build audio pipelines in C# with VisioForge Media Blocks SDK — mixer, equalizer, reverb, noise reduction, and 30+ blocks. Cross-platform support.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS
**API:** AudioRendererBlock, UniversalSourceBlock, MediaBlocksPipeline, UniversalSourceSettings, AudioMixerBlock, AudioDelayBlock

# Audio Processing and Effect Blocks for .NET

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

VisioForge Media Blocks SDK provides a pipeline-based approach to audio processing in C# and .NET. Connect audio blocks — converters, resamplers, mixers, equalizers, effects, and analyzers — to build real-time audio processing chains for your applications. Each block has typed input/output pins that you wire together using `pipeline.Connect()`.

For detailed audio effect parameters and properties, see the [Audio Effects Reference](../../general/audio-effects/reference/).

All blocks are cross-platform and work on Windows, macOS, Linux, iOS, and Android.

## Basic Audio Processing

### Audio Converter

The audio converter block converts audio from one format to another.

#### Block info

Name: AudioConverterBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

No configurable parameters. Automatically negotiates and converts audio formats between connected elements.

**GStreamer Element**: `audioconvert`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AudioConverterBlock;
    AudioConverterBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioConverter = new AudioConverterBlock();
pipeline.Connect(fileSource.AudioOutput, audioConverter.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(audioConverter.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Audio Resampler

The audio resampler block changes the sample rate of an audio stream.

#### Block info

Name: AudioResamplerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `AudioResamplerSettings`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Format` | `AudioFormatX` | `S16LE` | Target audio sample format |
| `SampleRate` | `int` | `44100` | Target sample rate in Hz |
| `Channels` | `int` | `2` | Target number of audio channels |
| `Quality` | `int` | `4` | Resample quality (0 = lowest, 10 = best) |
| `ResampleMethod` | `AudioResamplerMethod` | `Kaiser` | Resampling algorithm: `Nearest`, `Linear`, `Cubic`, `BlackmanNuttall`, `Kaiser` |

**GStreamer Element**: `audioresample`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AudioResamplerBlock;
    AudioResamplerBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Resample to 48000 Hz, stereo
var settings = new AudioResamplerSettings(AudioFormatX.S16LE, 48000, 2);
var audioResampler = new AudioResamplerBlock(settings);
pipeline.Connect(fileSource.AudioOutput, audioResampler.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(audioResampler.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Audio Timestamp Corrector

The audio timestamp corrector block can add or remove frames to correct input stream from unstable sources.

#### Block info

Name: AudioTimestampCorrectorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `AudioTimestampCorrectorSettings`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Silent` | `bool` | `true` | Suppresses notify signals for dropped and duplicated frames |
| `SkipToFirst` | `bool` | `false` | Does not produce buffers before the first one is received |
| `Tolerance` | `TimeSpan` | `40 ms` | Minimum timestamp difference before samples are added or dropped |

**GStreamer Element**: `audiorate`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AudioTimestampCorrectorBlock;
    AudioTimestampCorrectorBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var settings = new AudioTimestampCorrectorSettings();
var corrector = new AudioTimestampCorrectorBlock(settings);
pipeline.Connect(fileSource.AudioOutput, corrector.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(corrector.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Audio Delay

The audio delay block shifts audio buffer timestamps to delay the entire audio stream. Use it when the captured or decoded audio arrives earlier than video and you need to correct A/V sync, or when only one branch of an audio pipeline should be delayed before recording or streaming.

`AudioDelayBlock` is different from echo effects such as `EchoBlock` or `RSAudioEchoBlock`: it does not mix a delayed copy back into the signal. It delays the stream itself by applying a timestamp offset.

#### Block info

Name: AudioDelayBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `AudioDelaySettings` or pass a `TimeSpan` directly to the constructor:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Delay` | `TimeSpan` | `TimeSpan.Zero` | Non-negative audio delay to apply to the stream |
| `Sync` | `bool` | `true` | Synchronizes the underlying element to the pipeline clock |
| `Silent` | `bool` | `true` | Suppresses handoff messages from the underlying element |

**GStreamer Element**: `identity` with `ts-offset`.

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AudioDelayBlock;
    AudioDelayBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Delay audio by 500 ms.
var audioDelay = new AudioDelayBlock(TimeSpan.FromMilliseconds(500));
pipeline.Connect(fileSource.AudioOutput, audioDelay.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(audioDelay.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Delaying only the recording branch

When you preview and record at the same time, place `AudioDelayBlock` only on the branch that needs the offset.

```
var audioTee = new TeeBlock(2, MediaBlockPadMediaType.Audio);
pipeline.Connect(audioSource.Output, audioTee.Input);

// Preview branch without additional delay.
pipeline.Connect(audioTee.Outputs[0], audioRenderer.Input);

// Recording branch with delayed audio.
var audioDelay = new AudioDelayBlock(TimeSpan.FromMilliseconds(250));
pipeline.Connect(audioTee.Outputs[1], audioDelay.Input);
pipeline.Connect(audioDelay.Output, aacEncoder.Input);
pipeline.Connect(aacEncoder.Output, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Audio));
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Volume

The volume block allows you to control the volume of the audio stream.

#### Block info

Name: VolumeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Level` | `double` | `1.0` | Volume level multiplier (0.0 = silence, 1.0 = original, values > 1.0 amplify) |
| `Mute` | `bool` | `false` | Mutes the audio stream without changing the volume level |

**GStreamer Element**: `volume`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VolumeBlock;
    VolumeBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// VolumeBlock has a parameterless constructor; set Level on the property (0.0 silence, 1.0 normal, >1.0 amplified).
var volume = new VolumeBlock { Level = 0.8 };
pipeline.Connect(fileSource.AudioOutput, volume.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(volume.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Audio mixer

The audio mixer block mixes multiple audio streams into one. Block mixes the streams regardless of their format, converting if necessary.

All input streams will be synchronized. The mixer block handles the conversion of different input audio formats to a common format for mixing. By default, it will try to match the format of the first connected input, but this can be explicitly configured.

Use the `AudioMixerSettings` class to set the custom output format. This is useful if you need a specific sample rate, channel layout, or audio format (like S16LE, Float32LE, etc.) for the mixed output.

#### Block info

Name: AudioMixerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 (dynamically created) |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `AudioMixerSettings`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Format` | `AudioInfoX` | `S16LE, 48000 Hz, 2 ch` | Output audio format (sample format, sample rate, channel count) |

**Runtime methods:**

| Method | Description |
| --- | --- |
| `CreateNewInput()` | Creates a new input pad (before pipeline start) |
| `CreateNewInputLive()` | Creates a new input pad during playback |
| `RemoveInputLive(MediaBlockPad)` | Removes an input pad during playback |
| `SetVolume(int streamIndex, double value)` | Sets volume for a specific input by 0-based index (0.0–10.0) |
| `SetMute(int streamIndex, bool value)` | Mutes or unmutes a specific input by 0-based index |

**GStreamer Element**: `audiomixer`

#### The sample pipeline

```
graph LR;
    VirtualAudioSourceBlock#1-->AudioMixerBlock;
    VirtualAudioSourceBlock#2-->AudioMixerBlock;
    AudioMixerBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var audioSource1Block = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());
var audioSource2Block = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// Configure the mixer with specific output settings if needed
// For example, to output 48kHz, 2-channel, S16LE audio:
// var mixerSettings = new AudioMixerSettings() { Format = new AudioInfoX(AudioFormatX.S16LE, 48000, 2) };
// var audioMixerBlock = new AudioMixerBlock(mixerSettings);
var audioMixerBlock = new AudioMixerBlock(new AudioMixerSettings());

// Each call to CreateNewInput() adds a new input to the mixer
var inputPad1 = audioMixerBlock.CreateNewInput();
pipeline.Connect(audioSource1Block.Output, inputPad1);

var inputPad2 = audioMixerBlock.CreateNewInput();
pipeline.Connect(audioSource2Block.Output, inputPad2);

// Output the mixed audio to the default audio renderer
var audioRenderer = new AudioRendererBlock();
pipeline.Connect(audioMixerBlock.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Controlling Individual Input Streams

You can control the volume and mute state of individual input streams connected to the `AudioMixerBlock`. The `streamIndex` for these methods corresponds to the order in which the inputs were added via `CreateNewInput()` or `CreateNewInputLive()` (starting from 0).

- **Set Volume**: Use the `SetVolume(int streamIndex, double value)` method. The `value` ranges from 0.0 (silence) to 1.0 (normal volume), and can be higher for amplification (e.g., up to 10.0, though specifics might depend on the underlying implementation limits).
- **Set Mute**: Use the `SetMute(int streamIndex, bool value)` method. Set `value` to `true` to mute the stream and `false` to unmute it.

```
// Assuming audioMixerBlock is already created and inputs are connected

// Set volume of the first input stream (index 0) to 50%
audioMixerBlock.SetVolume(0, 0.5);

// Mute the second input stream (index 1)
audioMixerBlock.SetMute(1, true);
```

#### Dynamic Input Management (Live Pipeline)

The `AudioMixerBlock` supports adding and removing inputs dynamically while the pipeline is running:

- **Adding Inputs**: Use the `CreateNewInputLive()` method to get a new input pad that can be connected to a source. The underlying GStreamer elements will be set up to handle the new input.
- **Removing Inputs**: Use the `RemoveInputLive(MediaBlockPad blockPad)` method. This will disconnect the specified input pad and clean up associated resources.

This is particularly useful for applications where the number of audio sources can change during operation, such as a live mixing console or a conferencing application.

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Audio sample grabber

The audio sample grabber block allows you to access the raw audio samples from the audio stream.

#### Block info

Name: AudioSampleGrabberBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `format` (constructor) | `AudioFormatX` | `S16LE` | Audio sample format for captured frames |

| Event | Args Type | Description |
| --- | --- | --- |
| `OnAudioFrameBuffer` | `AudioFrameBufferEventArgs` | Fires for each captured audio frame with raw audio data, sample rate, channels, and timestamp |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AudioSampleGrabberBlock;
    AudioSampleGrabberBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioSampleGrabber = new AudioSampleGrabberBlock();
audioSampleGrabber.OnAudioFrameBuffer += (sender, args) =>
{
    // args.Frame.Data        — IntPtr to the raw PCM buffer
    // args.Frame.DataSize    — byte length of the buffer
    // args.Frame.Info.Format — AudioFormat (e.g., S16LE, F32LE)
    // args.Frame.Info.SampleRate / Channels / BPS
    // Set args.UpdateData = true if you mutate the buffer and want it propagated downstream.
};
pipeline.Connect(fileSource.AudioOutput, audioSampleGrabber.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(audioSampleGrabber.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Audio Effects

### Amplify

Block amplifies an audio stream by an amplification factor. Several clipping modes are available.

Use method and level values to configure.

#### Block info

Name: AmplifyBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Level` | `double` | `1.0` | Amplification multiplier (1.0 = no change, 2.0 = double volume, 0.5 = half volume) |
| `Method` | `AmplifyClippingMethod` | `Normal` | Clipping method when amplified audio exceeds the valid range |

`AmplifyClippingMethod` values:

| Value | Description |
| --- | --- |
| `Normal` | Hard clip at maximum level |
| `WrapNegative` | Push overdriven values back from the opposite side |
| `WrapPositive` | Push overdriven values back from the same side |
| `NoClip` | No clipping applied |

**GStreamer Element**: `audioamplify`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AmplifyBlock;
    AmplifyBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var amplify = new AmplifyBlock(AmplifyClippingMethod.Normal, 2.0);
pipeline.Connect(fileSource.AudioOutput, amplify.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(amplify.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Echo

The echo block adds echo effect to the audio stream.

#### Block info

Name: EchoBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Delay` | `TimeSpan` | `200 ms` | Echo delay time between the original signal and its repetitions |
| `MaxDelay` | `TimeSpan` | `500 ms` | Maximum echo delay (determines internal buffer size). Must be >= `Delay` |
| `Intensity` | `float` | `0` | Volume of the delayed signal (0.0 = no echo, 1.0 = full volume) |
| `Feedback` | `float` | `0` | Feedback amount for echo repetitions (0.0 = single echo, values near 1.0 = infinite feedback) |

**GStreamer Element**: `audioecho`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->EchoBlock;
    EchoBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// EchoBlock has a parameterless constructor; set properties directly.
var echo = new EchoBlock
{
    Delay     = TimeSpan.FromMilliseconds(200),   // echo delay
    MaxDelay  = TimeSpan.FromMilliseconds(500),   // internal buffer size (must be >= Delay)
    Intensity = 0.5f,                             // volume of delayed signal (0.0-1.0)
    Feedback  = 0.3f                              // feedback amount (0.0-near 1.0)
};
pipeline.Connect(fileSource.AudioOutput, echo.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(echo.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Karaoke

The karaoke block applies a karaoke effect to the audio stream, removing center-panned vocals.

#### Block info

Name: KaraokeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `KaraokeAudioEffect`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Level` | `float` | `1.0` | Vocal suppression strength (0.0 = no effect, 1.0 = maximum suppression) |
| `MonoLevel` | `float` | `1.0` | Suppression level for mono/center channel content (0.0–1.0) |
| `FilterBand` | `float` | `220` | Center frequency of the filter band in Hz targeting vocal range |
| `FilterWidth` | `float` | `100` | Width of the frequency band to process in Hz |

**GStreamer Element**: `audiokaraoke`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->KaraokeBlock;
    KaraokeBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var settings = new KaraokeAudioEffect();
var karaoke = new KaraokeBlock(settings);
pipeline.Connect(fileSource.AudioOutput, karaoke.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(karaoke.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Reverberation

The reverberation block adds reverb effects to the audio stream.

#### Block info

Name: ReverberationBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `ReverberationAudioEffect`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `RoomSize` | `float` | `0.5` | Size of the simulated room (0.0 = small room, 1.0 = large hall) |
| `Damping` | `float` | `0.2` | High frequency damping (0.0 = bright, 1.0 = dark/muffled) |
| `Width` | `float` | `1.0` | Stereo width of the reverb (0.0 = mono, 1.0 = full stereo) |
| `Level` | `float` | `0.5` | Wet/dry mix level (0.0 = dry only, 1.0 = wet only) |

**GStreamer Element**: `freeverb`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->ReverberationBlock;
    ReverberationBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var settings = new ReverberationAudioEffect();
var reverb = new ReverberationBlock(settings);
pipeline.Connect(fileSource.AudioOutput, reverb.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(reverb.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Wide Stereo

The wide stereo block enhances the stereo image of the audio.

#### Block info

Name: WideStereoBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `WideStereoAudioEffect`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Level` | `float` | `0.01` | Stereo widening amount (0.0 = no widening, higher values = wider stereo image). Typical: 0.01–0.03 subtle, 0.05–0.10 moderate, 0.15+ strong |

**GStreamer Element**: `stereo`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->WideStereoBlock;
    WideStereoBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var settings = new WideStereoAudioEffect();
var wideStereo = new WideStereoBlock(settings);
pipeline.Connect(fileSource.AudioOutput, wideStereo.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(wideStereo.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Equalization and Filtering

### Balance

Block allows you to control the balance between left and right channels.

#### Block info

Name: AudioBalanceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Balance` | `float` | `0.0` | Stereo balance position (-1.0 = full left, 0.0 = center, +1.0 = full right) |

**GStreamer Element**: `audiopanorama`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AudioBalanceBlock;
    AudioBalanceBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Balance: -1.0 (full left) to 1.0 (full right), 0.0 = center. The ctor takes a float, not double.
var balance = new AudioBalanceBlock(0.5f);
pipeline.Connect(fileSource.AudioOutput, balance.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(balance.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Equalizer (10 bands)

The 10-band equalizer block provides a 10-band equalizer for audio processing.

#### Block info

Name: Equalizer10Block.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

The equalizer provides 10 fixed-frequency bands. Use `SetBand(int index, double gain)` to adjust individual bands. Gain range: -24 dB to +12 dB.

| Band Index | Center Frequency | Bandwidth |
| --- | --- | --- |
| 0 | 29 Hz | 19 Hz |
| 1 | 59 Hz | 39 Hz |
| 2 | 119 Hz | 79 Hz |
| 3 | 237 Hz | 157 Hz |
| 4 | 474 Hz | 314 Hz |
| 5 | 947 Hz | 628 Hz |
| 6 | 1889 Hz | 1257 Hz |
| 7 | 3770 Hz | 2511 Hz |
| 8 | 7523 Hz | 5765 Hz |
| 9 | 15011 Hz | 11498 Hz |

Constructor is parameterless. Use `SetBand(int index, double gain)` to adjust each of the 10 bands after construction.

**GStreamer Element**: `equalizer-10bands`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->Equalizer10Block;
    Equalizer10Block-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Create 10-band equalizer (parameterless ctor; bands default to 0 dB)
var equalizer = new Equalizer10Block();

// Set bands individually
equalizer.SetBand(0, 3); // Band 0 (31 Hz) to +3 dB
equalizer.SetBand(1, 2); // Band 1 (62 Hz) to +2 dB
equalizer.SetBand(9, -3); // Band 9 (16 kHz) to -3 dB

pipeline.Connect(fileSource.AudioOutput, equalizer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(equalizer.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Equalizer (Parametric)

The parametric equalizer block provides a parametric equalizer for audio processing.

#### Block info

Name: EqualizerParametricBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Use `SetNumBands(int count)` to set the number of bands (1–64, default 3), then configure each band with `SetState(int index, ParametricEqualizerBand band)`.

`ParametricEqualizerBand` properties:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Frequency` | `float` | varies | Center frequency in Hz |
| `Gain` | `float` | `0.0` | Band gain in dB (-24 to +12) |
| `Width` | `float` | `1.0` | Bandwidth (width) in Hz |

Default bands (when 3 bands configured):

| Band | Frequency | Bandwidth |
| --- | --- | --- |
| 0 | 110 Hz | 100 Hz |
| 1 | 1100 Hz | 1000 Hz |
| 2 | 11000 Hz | 10000 Hz |

**GStreamer Element**: `equalizer-nbands`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->EqualizerParametricBlock;
    EqualizerParametricBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Create parametric equalizer
var equalizer = new EqualizerParametricBlock();

// Configure the number of bands, then set each band via SetState(int index, ParametricEqualizerBand).
// ParametricEqualizerBand(freq: Hz, width: Hz bandwidth, gain: dB). Properties: Frequency, Width, Gain.
equalizer.SetNumBands(4);
equalizer.SetState(0, new ParametricEqualizerBand(freq: 100f,  width: 50f,  gain: 3f));
equalizer.SetState(1, new ParametricEqualizerBand(freq: 1000f, width: 500f, gain: -2f));

pipeline.Connect(fileSource.AudioOutput, equalizer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(equalizer.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Chebyshev Band Pass/Reject

The Chebyshev band pass/reject block applies a band pass or band reject filter to the audio stream using Chebyshev filters.

#### Block info

Name: ChebyshevBandPassRejectBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `ChebyshevBandPassRejectAudioEffect`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Mode` | `ChebyshevBandMode` | `BandPass` | Filter mode: `BandPass` (pass frequencies in range) or `BandReject` (reject frequencies in range) |
| `LowerFrequency` | `float` | `220.0` | Lower cutoff frequency in Hz |
| `UpperFrequency` | `float` | `3000.0` | Upper cutoff frequency in Hz |
| `Poles` | `int` | `4` | Number of filter poles (2–32, must be even). Higher values = sharper cutoff |
| `Type` | `int` | `1` | Chebyshev filter type: 1 (ripple in passband) or 2 (ripple in stopband) |
| `Ripple` | `float` | `0.25` | Amount of ripple in dB (Type 1: passband ripple, Type 2: stopband ripple) |

**GStreamer Element**: `audiochebband`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->ChebyshevBandPassRejectBlock;
    ChebyshevBandPassRejectBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var settings = new ChebyshevBandPassRejectAudioEffect();
var filter = new ChebyshevBandPassRejectBlock(settings);
pipeline.Connect(fileSource.AudioOutput, filter.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(filter.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Chebyshev Limit

The Chebyshev limit block applies low-pass or high-pass filtering to the audio using Chebyshev filters.

#### Block info

Name: ChebyshevLimitBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `ChebyshevLimitAudioEffect`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Mode` | `ChebyshevLimitMode` | `LowPass` | Filter mode: `LowPass` (remove high frequencies) or `HighPass` (remove low frequencies) |
| `CutOffFrequency` | `float` | `1000.0` | Cutoff frequency in Hz |
| `Poles` | `int` | `4` | Number of filter poles (2–32, must be even). Higher values = sharper cutoff |
| `Type` | `int` | `1` | Chebyshev filter type: 1 (ripple in passband) or 2 (ripple in stopband) |
| `Ripple` | `float` | `0.25` | Amount of ripple in dB |

**GStreamer Element**: `audiocheblimit`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->ChebyshevLimitBlock;
    ChebyshevLimitBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var settings = new ChebyshevLimitAudioEffect();
var filter = new ChebyshevLimitBlock(settings);
pipeline.Connect(fileSource.AudioOutput, filter.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(filter.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Dynamic Processing

### Compressor/Expander

The compressor/expander block provides dynamic range compression or expansion.

#### Block info

Name: CompressorExpanderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `CompressorExpanderAudioEffect`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Mode` | `AudioCompressorMode` | `Compressor` | Processing mode: `Compressor` (reduce dynamic range) or `Expander` (increase dynamic range) |
| `Characteristics` | `AudioDynamicCharacteristics` | `HardKnee` | Knee type: `HardKnee` (abrupt transition) or `SoftKnee` (gradual transition) |
| `Ratio` | `float` | `1.0` | Compression/expansion ratio (e.g., 2.0 = 2:1 compression) |
| `Threshold` | `float` | `0.0` | Threshold level (0.0–1.0). Signal above this level is compressed/expanded |

Constructor is parameterless. Configure via `Ratio`, `Threshold`, `Mode`, and `Characteristics` properties after construction.

**GStreamer Element**: `audiodynamic`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->CompressorExpanderBlock;
    CompressorExpanderBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// CompressorExpanderBlock has a parameterless constructor; set properties directly.
var compressor = new CompressorExpanderBlock
{
    Mode            = AudioCompressorMode.Compressor,
    Characteristics = AudioDynamicCharacteristics.HardKnee,
    Ratio           = 4f,    // 4:1 compression
    Threshold       = 0.5f   // 0.0-1.0 (linear amplitude, not dB on this block)
};
pipeline.Connect(fileSource.AudioOutput, compressor.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(compressor.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Scale/Tempo

The scale/tempo block allows you to change the tempo and pitch of the audio stream.

#### Block info

Name: ScaleTempoBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Rate` | `double` | `1.0` | Playback rate multiplier (0.5 = half speed, 1.0 = normal, 2.0 = double speed). Pitch is preserved |
| `Overlap` | `double` | `0.2` | Percentage of stride to overlap (0.0–1.0). Higher values improve quality at CPU cost |
| `Search` | `TimeSpan` | `14 ms` | Length of search window for best overlap position |
| `Stride` | `TimeSpan` | `30 ms` | Length of output audio stride |

Constructor is parameterless; set `Rate` via the property (or the underlying `SetRate` accessor is called internally when `Rate` is assigned).

**GStreamer Element**: `scaletempo`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->ScaleTempoBlock;
    ScaleTempoBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// ScaleTempoBlock has a parameterless constructor; set Rate via property.
// 1.0 = normal, 0.5 = half-speed, 2.0 = double-speed; pitch is preserved.
var scaleTempo = new ScaleTempoBlock { Rate = 1.5 };
pipeline.Connect(fileSource.AudioOutput, scaleTempo.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(scaleTempo.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Analysis and Metering

### VU Meter

The VU meter block allows you to measure the volume level of the audio stream.

#### Block info

Name: VUMeterBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Event-based block. Subscribe to the `OnAudioVUMeter` event (type: `EventHandler<VUMeterXEventArgs>`) to receive level data.

`VUMeterXEventArgs.MeterData` carries a `VUMeterXData` instance with per-channel arrays:

| Property on `VUMeterXData` | Type | Description |
| --- | --- | --- |
| `ChannelsCount` | `int` | Number of audio channels reported |
| `Peak` | `double[]` | Per-channel peak levels (dB) |
| `RMS` | `double[]` | Per-channel RMS levels (dB) |
| `Decay` | `double[]` | Per-channel decay levels (dB) |

**GStreamer Element**: `level`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VUMeterBlock;
    VUMeterBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var vuMeter = new VUMeterBlock();
vuMeter.OnAudioVUMeter += (sender, args) =>
{
    var data = args.MeterData;
    for (int i = 0; i < data.ChannelsCount; i++)
    {
        Console.WriteLine($"Ch{i}: Peak={data.Peak[i]:F2} dB, RMS={data.RMS[i]:F2} dB");
    }
};
pipeline.Connect(fileSource.AudioOutput, vuMeter.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(vuMeter.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Audio Effects

### Audio Effects

The AudioEffects block provides a comprehensive collection of audio processing effects that can be applied to audio streams. For detailed effect parameters and properties, see the [Audio Effects Reference](../../general/audio-effects/reference/).

#### Block info

Name: AudioEffectsBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Collection-based effect management. Use the following methods:

| Method | Description |
| --- | --- |
| `AddOrUpdate(BaseAudioEffect effect)` | Adds a new effect or updates an existing one of the same type |
| `Remove<T>()` | Removes the effect of the specified type |
| `Clear()` | Removes all effects |
| `Get<T>()` | Returns the effect of the specified type, or null |

Supported effect types include all effects from `VisioForge.Core.Types.X.AudioEffects` namespace. See [Audio Effects Reference](../../general/audio-effects/reference/) for detailed parameters.

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AudioEffectsBlock;
    AudioEffectsBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEffects = new AudioEffectsBlock();
pipeline.Connect(fileSource.AudioOutput, audioEffects.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(audioEffects.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Audio Loudness Normalization

The AudioLoudNorm block normalizes audio loudness according to EBU R128 standards, ensuring consistent perceived loudness across different audio content.

#### Block info

Name: AudioLoudNormBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `AudioLoudNormAudioEffect`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `LoudnessTarget` | `double` | `-24.0` | Target integrated loudness in LUFS (-70.0 to -5.0) |
| `LoudnessRangeTarget` | `double` | `7.0` | Target loudness range in LU (1.0 to 20.0) |
| `MaxTruePeak` | `double` | `-2.0` | Maximum true peak in dBTP (-9.0 to 0.0) |
| `Offset` | `double` | `0.0` | Offset gain in LU (-99.0 to 99.0) |

**GStreamer Element**: `audioloudnorm`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AudioLoudNormBlock;
    AudioLoudNormBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var loudNorm = new AudioLoudNormBlock();
pipeline.Connect(fileSource.AudioOutput, loudNorm.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(loudNorm.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### RNN Noise Reduction

The AudioRNNoise block uses recurrent neural network (RNN) based noise reduction to remove background noise from audio streams while preserving speech quality.

#### Block info

Name: AudioRNNoiseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `VadThreshold` | `float` | `0.0` | Voice Activity Detection threshold (0.0–1.0). When > 0, acts as a gate: audio below this speech probability is silenced. 0.0 = noise reduction only, no gating |

**GStreamer Element**: `audiornnoise`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AudioRNNoiseBlock;
    AudioRNNoiseBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "noisy_audio.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var rnnoise = new AudioRNNoiseBlock();
pipeline.Connect(fileSource.AudioOutput, rnnoise.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(rnnoise.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Remove Silence

The RemoveSilence block automatically detects and removes silent portions from audio streams, useful for podcasts, voice recordings, and audio editing.

#### Block info

Name: RemoveSilenceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `RemoveSilenceAudioEffect`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Threshold` | `double` | `0.001` | Silence threshold as a linear amplitude (0.0–1.0), converted to decibels for the element. Audio below this level is considered silence; 1.0 is full scale and treats everything as silence |
| `Squash` | `bool` | `false` | Silence is always dropped. When true, the surviving buffers are pulled back to close the gap; when false, they keep their original timestamps |

**GStreamer Element**: `removesilence`

Two limits of the element

Its pads are **S16LE mono only**, and the block inserts no converter — a stereo stream is downmixed for everything downstream of it (measured: a 44.1 kHz stereo MP3 arrives past the block as mono PCM16). The graph links at all only because `UniversalSourceBlock` puts its own converter after the decoder; a source without one has nothing to negotiate the stereo down. Put an `AudioConverterBlock` after the block if the rest of the graph needs stereo back.

Its detector ANDs the level test with a zero-crossing test: a buffer counts as speech only when it is both loud enough *and* low-frequency enough. Noise-like or high-frequency content is treated as silence at every threshold, including the -70 dB floor.

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->RemoveSilenceBlock;
    RemoveSilenceBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "podcast.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var removeSilence = new RemoveSilenceBlock();
pipeline.Connect(fileSource.AudioOutput, removeSilence.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(removeSilence.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Csound Filter

The CsoundFilter block provides advanced audio synthesis and processing using the Csound audio programming language.

#### Block info

Name: CsoundFilterBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

Configure via `CsoundAudioEffect`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `CsdText` | `string` | `null` | Inline Csound CSD script text |
| `Location` | `string` | `null` | Path to an external .csd file (alternative to CsdText) |
| `Loop` | `bool` | `false` | Whether to loop the Csound score |
| `ScoreOffset` | `double` | `0.0` | Score time offset in seconds |

**GStreamer Element**: `csoundfilter`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->CsoundFilterBlock;
    CsoundFilterBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// CsoundFilterBlock takes the Csound (.csd) script contents directly, not a settings object.
// Load the script from disk and pass the text to the constructor — optionally set Loop/ScoreOffset.
var csdText = File.ReadAllText("filter.csd");
var csound = new CsoundFilterBlock(csdText, loop: false, scoreOffset: 0.0);
pipeline.Connect(fileSource.AudioOutput, csound.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(csound.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux (requires Csound).

### EBU R128 Level

The EbuR128Level block measures audio loudness according to the EBU R128 standard, providing accurate loudness measurements for broadcast compliance.

#### Block info

Name: EbuR128LevelBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Mode` | `EbuR128Mode` | `All` | Measurement mode flags: `MomentaryLoudness`, `ShortTermLoudness`, `GlobalLoudness`, `LoudnessRange`, `SamplePeak`, `TruePeak`, `All` |
| `PostMessages` | `bool` | `true` | Whether to post GStreamer bus messages with measurement results |
| `Interval` | `TimeSpan` | `1 s` | Interval between measurement updates |

`EbuR128LevelBlock` measures loudness internally and posts results on the GStreamer bus when `PostMessages = true`. It does **not** expose a managed event — read the `level` property or handle the bus message yourself if you need the values inside .NET.

**GStreamer Element**: `ebur128level`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->EbuR128LevelBlock;
    EbuR128LevelBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var ebuR128 = new EbuR128LevelBlock
{
    Mode         = EbuR128Mode.All,
    PostMessages = true,                      // enable GStreamer bus messages with measurement results
    Interval     = TimeSpan.FromSeconds(1)    // measurement cadence
};
pipeline.Connect(fileSource.AudioOutput, ebuR128.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(ebuR128.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### HRTF Render

The HRTFRender block applies Head-Related Transfer Function (HRTF) processing to create 3D spatial audio effects from stereo or multi-channel audio.

#### Block info

Name: HRTFRenderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `HrirFile` | `string` | `""` | Path to an hrtfrender HRIR binary for spatial rendering (not a SOFA file) |
| `InterpolationSteps` | `ulong` | `8` | Number of interpolation steps for smooth spatial transitions |
| `BlockLength` | `ulong` | `512` | Processing block length in samples |
| `DistanceGain` | `float` | `1.0` | Distance-based gain attenuation factor |

All properties support real-time updates during playback.

**GStreamer Element**: `hrtfrender`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->HRTFRenderBlock;
    HRTFRenderBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// HRTFRenderBlock has a parameterless ctor; configure via properties.
// Download a compatible HRIR binary from https://github.com/mrDIMAS/hrir_sphere_builder/tree/master/hrtf_base/IRCAM.
var hrtf = new HRTFRenderBlock
{
    HrirFile           = "IRC_1002_C.bin", // path to HRIR binary
    InterpolationSteps = 8,              // ulong — smoother transitions = more CPU
    BlockLength        = 512,            // ulong — processing block size
    DistanceGain       = 1.0f            // float — how strongly distance attenuates
};
pipeline.Connect(fileSource.AudioOutput, hrtf.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(hrtf.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### RS Audio Echo

The RSAudioEcho block provides high-quality echo effects using the rsaudiofx GStreamer plugin.

#### Block info

Name: RSAudioEchoBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Delay` | `TimeSpan` | `500 ms` | Echo delay time |
| `MaxDelay` | `TimeSpan` | `1000 ms` | Maximum allowed delay (must be >= Delay) |
| `Intensity` | `double` | `0.5` | Echo intensity (0.0–1.0) |
| `Feedback` | `double` | `0.0` | Feedback amount — controls echo repetitions (0.0–1.0) |

All properties support real-time updates during playback.

**GStreamer Element**: `rsaudioecho`

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->RSAudioEchoBlock;
    RSAudioEchoBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// RSAudioEchoBlock has a parameterless ctor; configure via properties (Delay/MaxDelay are TimeSpan).
var rsEcho = new RSAudioEchoBlock
{
    Delay     = TimeSpan.FromMilliseconds(500),
    MaxDelay  = TimeSpan.FromMilliseconds(1000),
    Intensity = 0.5,   // 0.0-1.0 — echo volume
    Feedback  = 0.3    // 0.0-0.9 — how many repeats before decay
};
pipeline.Connect(fileSource.AudioOutput, rsEcho.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(rsEcho.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux (requires rsaudiofx plugin).

### Pitch Shifter

The `PitchBlock` shifts the pitch of an audio stream without affecting playback speed. It uses the SoundTouch library via the GStreamer `pitch` element, supporting shifts from −12 to +12 semitones (one octave down to one octave up).

#### Block info

Name: PitchBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Semitones` | `int` | `0` | Pitch shift in semitones (−12 to +12) |
| `Pitch` | `float` | `1.0` | Direct pitch multiplier (1.0 = no change, 2.0 = one octave up, 0.5 = one octave down) |

#### Availability

`PitchBlock.IsAvailable()` returns `true` if the GStreamer `pitch` element (SoundTouch plugin) is present.

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->PitchBlock;
    PitchBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var pitchBlock = new PitchBlock(semitones: 5);
pipeline.Connect(fileSource.AudioOutput, pitchBlock.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(pitchBlock.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux.

### Silence Detector

The `SilenceDetectorBlock` analyzes audio levels in real time to detect silence periods based on a configurable dBFS threshold. It is a pass-through block — audio is forwarded unchanged while `OnSilenceStarted` and `OnSilenceEnded` events fire at state transitions. Detected periods can be retrieved as a list or exported as JSON.

#### Block info

Name: SilenceDetectorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `ThresholdDb` | `double` | `-40.0` | Silence threshold in dBFS; audio below this level is treated as silence |

Key methods:

- `GetSilencePeriods()` — returns all detected `SilencePeriod` objects.
- `FinalizeSilencePeriods(TimeSpan endTime)` — closes any in-progress period and returns the full list.
- `ExportSilencePeriodsJson()` — returns a JSON string with start/end timestamps for every detected period.

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SilenceDetectorBlock;
    SilenceDetectorBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var silenceDetector = new SilenceDetectorBlock(thresholdDb: -35.0);
silenceDetector.OnSilenceStarted += (s, e) => Console.WriteLine($"Silence started at {e.Timestamp}");
silenceDetector.OnSilenceEnded += (s, e) => Console.WriteLine($"Silence ended at {e.Timestamp}");
pipeline.Connect(fileSource.AudioOutput, silenceDetector.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(silenceDetector.Output, audioRenderer.Input);

await pipeline.StartAsync();

// After pipeline stops, export detected silence periods
var json = silenceDetector.ExportSilencePeriodsJson();
Console.WriteLine(json);
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Weighted Channel Mix

The `WeightedChannelMixBlock` mixes the left and right stereo channels with independently adjustable weights, producing a mono or stereo output. It is primarily used for dual-mono sources such as karaoke audio where one channel carries an instrumental track and the other a full mix.

Weights can be changed at runtime without rebuilding the pipeline. Values above 1.0 boost the channel but may cause clipping.

#### Block info

Name: WeightedChannelMixBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed stereo audio | 1 |
| Output | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `LeftChannelWeight` | `float` | `0.5` | Mix weight for the left channel (0.0–1.0+) |
| `RightChannelWeight` | `float` | `0.5` | Mix weight for the right channel (0.0–1.0+) |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->WeightedChannelMixBlock;
    WeightedChannelMixBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "karaoke.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Use only the instrumental (left) channel
var mixer = new WeightedChannelMixBlock(leftWeight: 1.0f, rightWeight: 0.0f);
pipeline.Connect(fileSource.AudioOutput, mixer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(mixer.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Frequently Asked Questions

 How do I connect audio blocks in a pipeline?

Create a `MediaBlocksPipeline`, instantiate the blocks you need, then connect them using `pipeline.Connect(sourceBlock.Output, destinationBlock.Input)`. Each block has typed input and output pins — the pipeline validates that connected pins have compatible media types.

  Can I apply multiple audio effects in a single pipeline?

Yes. You can chain any number of audio blocks in sequence. For example, connect a source to an equalizer block, then to a reverb block, then to a renderer. Alternatively, use the `AudioEffectsBlock` to apply multiple effects within a single block. For effect parameters, see the [Audio Effects Reference](../../general/audio-effects/reference/).

  How do I mix multiple audio sources together?

Use the `AudioMixerBlock` to combine multiple audio inputs into a single output. Connect each source to a separate input pin on the mixer. The mixer supports volume control per input and automatic format negotiation.

  What is the difference between AudioEffectsBlock and individual effect blocks?

Individual effect blocks (like `AmplifyBlock`, `EchoBlock`, `ReverbBlock`) wrap a single GStreamer element and are connected as separate pipeline nodes. The `AudioEffectsBlock` lets you apply multiple effects within one block by adding effect instances to its collection — useful when you need several effects without complex wiring.

  Do audio blocks support real-time parameter changes?

Yes. You can modify block properties during playback. For example, change the volume level, adjust EQ bands, or update mixer weights while the pipeline is running. Changes take effect immediately without stopping the pipeline.

## See Also

- [Audio Effects Overview](../../general/audio-effects/)
- [Audio Effects Reference](../../general/audio-effects/reference/)
- [Audio Encoders](../../general/audio-encoders/)
- [Media Blocks SDK Overview](../)

---END OF PAGE---


## Cross-Platform Audio Rendering and Playback in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/AudioRendering/
**Description:** Play audio to speakers on Windows, macOS, Linux, iOS, and Android using VisioForge Media Blocks SDK. Device selection, buffer control, volume management.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Playback
**API:** AudioRendererBlock, OSXAudioSinkBlock, IOSAudioSinkBlock, OSXAudioSinkSettings, MediaBlocksPipeline

# Audio Rendering Block: Cross-Platform Audio Output Processing

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to Audio Rendering

The Audio Renderer Block serves as a critical component in media processing pipelines, enabling applications to output audio streams to sound devices across multiple platforms. This versatile block handles the complex task of converting digital audio data into audible sound through the appropriate hardware interfaces, making it an essential tool for developers building audio-enabled applications.

Audio rendering requires careful management of hardware resources, buffer settings, and timing synchronization to ensure smooth, uninterrupted playback. This block abstracts these complexities and provides a unified interface for audio output across diverse computing environments.

## Core Functionality

The Audio Renderer Block accepts uncompressed audio streams and outputs them to either the default audio device or a user-selected alternative. It provides essential audio playback controls including:

- Volume adjustment with precise decibel control
- Mute functionality for silent operation
- Device selection from available system audio outputs
- Buffering settings to optimize for latency or stability

These capabilities allow developers to create applications with professional-grade audio output without needing to implement platform-specific code for each target operating system.

## Underlying Technology

### Platform-Specific Implementation

The `AudioRendererBlock` supports various platform-specific audio rendering technologies. It can be configured to use a specific audio device and API (see Device Management section). When instantiated using its default constructor (e.g., `new AudioRendererBlock()`), it attempts to select a suitable default audio API based on the operating system:

- **Windows**: The default constructor typically uses DirectSound. The block supports multiple audio APIs including:
- DirectSound: Provides low-latency output with broad compatibility
- WASAPI (Windows Audio Session API): Offers exclusive mode for highest quality
- ASIO (Audio Stream Input/Output): Professional-grade audio with minimal latency for specialized hardware
- **macOS**: Utilizes the CoreAudio framework. The default constructor will typically select a CoreAudio-based device for:
- High-resolution audio output
- Native integration with macOS audio subsystem
- Support for audio units and professional equipment (Note: Similarly for macOS, an `OSXAudioSinkBlock` is available for direct interaction with the platform-specific GStreamer sink if needed for specialized scenarios.)
- **Linux**: Implements ALSA (Advanced Linux Sound Architecture). The default constructor will typically select an ALSA-based device for:
- Direct hardware access
- Comprehensive device support
- Integration with the Linux audio stack
- **iOS**: Employs CoreAudio, optimized for mobile. The default constructor will typically select a CoreAudio-based device, enabling features like:
- Power-efficient rendering
- Background audio capabilities
- Integration with iOS audio session management (Note: For developers requiring more direct control over the iOS-specific GStreamer sink or having advanced use cases, the SDK also provides `IOSAudioSinkBlock` as a distinct media block.)
- **Android**: Defaults to using OpenSL ES to provide:
- Low-latency audio output
- Hardware acceleration when available

## OSXAudioSinkBlock: Direct macOS Audio Output

The `OSXAudioSinkBlock` is a platform-specific media block designed for advanced scenarios where direct interaction with the macOS GStreamer audio sink is required. This block is useful for developers who need low-level control over audio output on macOS devices, such as custom device selection or integration with other native components.

### Key Features

- Direct access to the macOS audio sink
- Device selection via `DeviceID`
- Suitable for specialized or professional audio applications on macOS

### Settings: `OSXAudioSinkSettings`

The `OSXAudioSinkBlock` requires an `OSXAudioSinkSettings` object to specify the audio output device. The `OSXAudioSinkSettings` class allows you to define:

- `DeviceID`: The ID of the macOS audio output device (starting from 0)

Example:

```
using VisioForge.Core.Types.X.Sinks;

// Select the first available audio device (DeviceID = 0)
var osxSettings = new OSXAudioSinkSettings { DeviceID = 0 };

// Create the macOS audio sink block
var osxAudioSink = new OSXAudioSinkBlock(osxSettings);
```

### Availability Check

You can check if the `OSXAudioSinkBlock` is available on the current platform:

```
bool isAvailable = OSXAudioSinkBlock.IsAvailable();
```

### Integration Example

Below is a minimal example of integrating `OSXAudioSinkBlock` into a media pipeline:

```
var pipeline = new MediaBlocksPipeline();

// Set up your audio source block as needed
var audioSourceBlock = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// Define settings for the sink
var osxSettings = new OSXAudioSinkSettings { DeviceID = 0 };
var osxAudioSink = new OSXAudioSinkBlock(osxSettings);

// Connect the source to the macOS audio sink
pipeline.Connect(audioSourceBlock.Output, osxAudioSink.Input);

await pipeline.StartAsync();
```

## IOSAudioSinkBlock: Direct iOS Audio Output

The `IOSAudioSinkBlock` is a platform-specific media block designed for advanced scenarios where direct interaction with the iOS GStreamer audio sink is required. This block is useful for developers who need low-level control over audio output on iOS devices, such as custom audio routing, format handling, or integration with other native components.

### Key Features

- Direct access to the iOS GStreamer audio sink
- Fine-grained control over audio format, sample rate, and channel count
- Suitable for specialized or professional audio applications on iOS

### Settings: `AudioInfoX`

The `IOSAudioSinkBlock` requires an `AudioInfoX` object to specify the audio format. The `AudioInfoX` class allows you to define:

- `Format`: The audio sample format (e.g., `AudioFormatX.S16LE`, `AudioFormatX.F32LE`, etc.)
- `SampleRate`: The sample rate in Hz (e.g., 44100, 48000)
- `Channels`: The number of audio channels (e.g., 1 for mono, 2 for stereo)

Example:

```
using VisioForge.Core.Types.X;

// Define audio format: 16-bit signed little-endian, 44100 Hz, stereo
var audioInfo = new AudioInfoX(AudioFormatX.S16LE, 44100, 2);

// Create the iOS audio sink block
var iosAudioSink = new IOSAudioSinkBlock(audioInfo);
```

### Availability Check

You can check if the `IOSAudioSinkBlock` is available on the current platform:

```
bool isAvailable = IOSAudioSinkBlock.IsAvailable();
```

### Integration Example

Below is a minimal example of integrating `IOSAudioSinkBlock` into a media pipeline:

```
var pipeline = new MediaBlocksPipeline();

// Set up your audio source block as needed
var audioSourceBlock = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// Define audio format for the sink
var audioInfo = new AudioInfoX(AudioFormatX.S16LE, 44100, 2);
var iosAudioSink = new IOSAudioSinkBlock(audioInfo);

// Connect the source to the iOS audio sink
pipeline.Connect(audioSourceBlock.Output, iosAudioSink.Input);

await pipeline.StartAsync();
```

## Technical Specifications

### Block Information

Name: AudioRendererBlock

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | uncompressed audio | 1 |

### Audio Format Support

The Audio Renderer Block accepts a wide range of uncompressed audio formats:

- Sample rates: 8kHz to 192kHz
- Bit depths: 8-bit, 16-bit, 24-bit, and 32-bit (floating point)
- Channel configurations: Mono, stereo, and multichannel (up to 7.1 surround)

This flexibility allows developers to work with everything from basic voice applications to high-fidelity music and immersive audio experiences.

## Device Management

### Enumerating Available Devices

The Audio Renderer Block provides straightforward methods to discover and select from available audio output devices on the system using the `GetDevicesAsync` static method:

```
// Get a list of all audio output devices on the current system
var availableDevices = await AudioRendererBlock.GetDevicesAsync();

// Optionally specify the API to use
var directSoundDevices = await AudioRendererBlock.GetDevicesAsync(AudioOutputDeviceAPI.DirectSound);

// Display device information
foreach (var device in availableDevices)
{
    Console.WriteLine($"Device: {device.Name}");
}

// Create a renderer with a specific device
var audioRenderer = new AudioRendererBlock(availableDevices[0]);
```

### Default Device Handling

When no specific device is selected, the block automatically routes audio to the system's default output device. The no-parameter constructor attempts to select an appropriate default device based on the platform:

```
// Create with default device
var audioRenderer = new AudioRendererBlock();
```

The block also monitors device status, handling scenarios such as:

- Device disconnection during playback
- Default device changes by the user
- Audio endpoint format changes

## Performance Considerations

### Latency Management

Audio rendering latency is critical for many applications. The block provides configuration options through the `Settings` property and synchronization control via the `IsSync` property:

```
// Control synchronization behavior
audioRenderer.IsSync = true; // Enable synchronization (default)

// Check if a specific API is available on this platform
bool isDirectSoundAvailable = AudioRendererBlock.IsAvailable(AudioOutputDeviceAPI.DirectSound);
```

### Volume and Mute Control

The AudioRendererBlock provides precise volume control and mute functionality:

```
// Set volume (0.0 to 1.0 range)
audioRenderer.Volume = 0.8; // 80% volume

// Get current volume
double currentVolume = audioRenderer.Volume;

// Mute/unmute
audioRenderer.Mute = true; // Mute audio
audioRenderer.Mute = false; // Unmute audio

// Check mute state
bool isMuted = audioRenderer.Mute;
```

### Resource Utilization

The Audio Renderer Block is designed for efficiency, with optimizations for:

- CPU usage during playback
- Memory footprint for buffer management
- Power consumption on mobile devices

## Integration Examples

### Basic Pipeline Setup

The following example demonstrates how to set up a simple audio rendering pipeline using a virtual audio source:

```
var pipeline = new MediaBlocksPipeline();

var audioSourceBlock = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// Create audio renderer with default settings
var audioRenderer = new AudioRendererBlock();
pipeline.Connect(audioSourceBlock.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

### Real-World Audio Pipeline

For a more practical application, here's how to capture system audio and render it:

```
graph LR;
    SystemAudioSourceBlock-->AudioRendererBlock;
```

```
var pipeline = new MediaBlocksPipeline();

// Capture system audio
var systemAudioSource = new SystemAudioSourceBlock();

// Configure the audio renderer
var audioRenderer = new AudioRendererBlock();
audioRenderer.Volume = 0.8f; // 80% volume

// Connect blocks
pipeline.Connect(systemAudioSource.Output, audioRenderer.Input);

// Start processing
await pipeline.StartAsync();

// Allow audio to play for 10 seconds
await Task.Delay(TimeSpan.FromSeconds(10));

// Stop the pipeline
await pipeline.StopAsync();
```

## Compatibility and Platform Support

The Audio Renderer Block is designed for cross-platform operation, supporting:

- Windows 10 and later
- macOS 10.13 and later
- Linux (Ubuntu, Debian, Fedora)
- iOS 12.0 and later
- Android 8.0 and later

This wide platform support enables developers to create consistent audio experiences across different operating systems and devices.

## Conclusion

The Audio Renderer Block provides developers with a powerful, flexible solution for audio output across multiple platforms. By abstracting the complexities of platform-specific audio APIs, it allows developers to focus on creating exceptional audio experiences without worrying about the underlying implementation details.

Whether building a simple media player, a professional audio editing application, or a real-time communications platform, the Audio Renderer Block provides the tools needed for high-quality, reliable audio output.

---END OF PAGE---


## Audio Visualizer Blocks for .NET - Spectrum and Waveform
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/AudioVisualizers/
**Description:** Build audio-reactive applications with VisioForge Media Blocks SDK visualizer blocks — Spacescope, Spectroscope, Synaescope, and Wavescope renderers.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS
**API:** VideoRendererBlock, UniversalSourceBlock, MediaBlocksPipeline, UniversalSourceSettings, SynaescopeBlock

# Audio visualizer blocks

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

VisioForge Media Blocks SDK .Net includes a set of audio visualizer blocks that allow you to create audio-reactive visualizations for your applications. These blocks take audio input and produce video output representing the audio characteristics.

The blocks can be connected to other audio and video processing blocks to create complex media pipelines.

Most of the blocks are available for all platforms, including Windows, Linux, MacOS, Android, and iOS.

## Spacescope

The Spacescope block is a simple audio visualization element that maps the left and right audio channels to X and Y coordinates, respectively, creating a Lissajous-like pattern. This visualizes the phase relationship between the channels. The appearance, such as using dots or lines and colors, can be customized via `SpacescopeSettings`.

#### Block info

Name: SpacescopeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Video | 1 |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SpacescopeBlock;
    SpacescopeBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3"; // Or any audio source
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Settings can be customized, e.g., for shader, line thickness, etc.
// The style (dots, lines, color-dots, color-lines) can be set in SpacescopeSettings.
var spacescopeSettings = new SpacescopeSettings();
var spacescope = new SpacescopeBlock(spacescopeSettings);
pipeline.Connect(fileSource.AudioOutput, spacescope.Input);

// Assuming you have a VideoRendererBlock or a way to display video output
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(spacescope.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Spectrascope

The Spectrascope block is a simple spectrum visualization element. It renders the frequency spectrum of the audio input as a series of bars.

#### Block info

Name: SpectrascopeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Video | 1 |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SpectrascopeBlock;
    SpectrascopeBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3"; // Or any audio source
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var spectrascope = new SpectrascopeBlock();
pipeline.Connect(fileSource.AudioOutput, spectrascope.Input);

// Assuming you have a VideoRendererBlock or a way to display video output
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(spectrascope.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Synaescope

The Synaescope block is an audio visualization element that analyzes frequencies and out-of-phase properties of the audio. It draws this analysis as dynamic clouds of stars, creating colorful and abstract patterns.

#### Block info

Name: SynaescopeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Video | 1 |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SynaescopeBlock;
    SynaescopeBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3"; // Or any audio source
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// SynaescopeBlock uses GStreamer defaults — there is no settings class on the managed surface.
var synaescope = new SynaescopeBlock();
pipeline.Connect(fileSource.AudioOutput, synaescope.Input);

// Assuming you have a VideoRendererBlock or a way to display video output
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(synaescope.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Wavescope

The Wavescope block is a simple audio visualization element that renders the audio waveforms, similar to an oscilloscope display. The drawing style (dots, lines, colors) can be configured using `WavescopeSettings`.

#### Block info

Name: WavescopeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed audio | 1 |
| Output | Video | 1 |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->WavescopeBlock;
    WavescopeBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3"; // Or any audio source
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Settings can be customized, e.g., for style, mono/stereo mode, etc.
// The style (dots, lines, color-dots, color-lines) can be set in WavescopeSettings.
var wavescopeSettings = new WavescopeSettings();
var wavescope = new WavescopeBlock(wavescopeSettings);
pipeline.Connect(fileSource.AudioOutput, wavescope.Input);

// Assuming you have a VideoRendererBlock or a way to display video output
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(wavescope.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## LibVisual Bumpscope

LibVisual Bumpscope creates a bumpmapped oscilloscope visualization effect.

### Block info

Name: LibVisualBumpscopeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | uncompressed audio | 1 |
| Output video | uncompressed video | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var audioSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp3"));

var bumpscope = new LibVisualBumpscopeBlock();
pipeline.Connect(audioSource.AudioOutput, bumpscope.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(bumpscope.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## LibVisual Corona

LibVisual Corona creates a radiant corona visualization effect.

### Block info

Name: LibVisualCoronaBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | uncompressed audio | 1 |
| Output video | uncompressed video | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var audioSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp3"));

var corona = new LibVisualCoronaBlock();
pipeline.Connect(audioSource.AudioOutput, corona.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(corona.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## LibVisual Infinite

LibVisual Infinite creates an infinite tunnel visualization effect.

### Block info

Name: LibVisualInfiniteBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | uncompressed audio | 1 |
| Output video | uncompressed video | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var audioSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp3"));

var infinite = new LibVisualInfiniteBlock();
pipeline.Connect(audioSource.AudioOutput, infinite.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(infinite.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## LibVisual Jakdaw

LibVisual Jakdaw creates a dynamic visualization effect.

### Block info

Name: LibVisualJakdawBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | uncompressed audio | 1 |
| Output video | uncompressed video | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var audioSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp3"));

var jakdaw = new LibVisualJakdawBlock();
pipeline.Connect(audioSource.AudioOutput, jakdaw.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(jakdaw.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## LibVisual Jess

LibVisual Jess creates a particle-based visualization effect.

### Block info

Name: LibVisualJessBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | uncompressed audio | 1 |
| Output video | uncompressed video | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var audioSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp3"));

var jess = new LibVisualJessBlock();
pipeline.Connect(audioSource.AudioOutput, jess.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(jess.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## LibVisual LV Analyzer

LibVisual LV Analyzer creates a frequency analyzer visualization.

### Block info

Name: LibVisualLVAnalyzerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | uncompressed audio | 1 |
| Output video | uncompressed video | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var audioSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp3"));

var analyzer = new LibVisualLVAnalyzerBlock();
pipeline.Connect(audioSource.AudioOutput, analyzer.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(analyzer.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## LibVisual LV Scope

LibVisual LV Scope creates a classic oscilloscope visualization.

### Block info

Name: LibVisualLVScopeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | uncompressed audio | 1 |
| Output video | uncompressed video | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var audioSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp3"));

var scope = new LibVisualLVScopeBlock();
pipeline.Connect(audioSource.AudioOutput, scope.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(scope.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## LibVisual Oinksie

LibVisual Oinksie creates a playful visualization effect.

### Block info

Name: LibVisualOinksieBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | uncompressed audio | 1 |
| Output video | uncompressed video | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var audioSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp3"));

var oinksie = new LibVisualOinksieBlock();
pipeline.Connect(audioSource.AudioOutput, oinksie.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(oinksie.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

---END OF PAGE---


## AWS S3 Cloud Media Storage - Source and Sink in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/AWS/
**Description:** Read and write media files to Amazon S3 in your pipeline using VisioForge Media Blocks SDK. Stream, transcode, and store video directly to cloud storage.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS
**API:** AWSS3SinkBlock, AWSS3SinkSettings, MP4SinkBlock, SystemVideoSourceBlock, VideoEncoderBlock

# AWS S3 Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

AWS S3 blocks enable interaction with Amazon Simple Storage Service (S3) to read media files as sources or write media files as sinks within your pipelines.

## AWSS3SinkBlock

The `AWSS3SinkBlock` allows you to write media data from your pipeline to a file in an AWS S3 bucket. This is useful for storing recorded media, transcoded files, or other outputs directly to cloud storage.

#### Block info

Name: `AWSS3SinkBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Auto (depends on connected block) | 1 |

#### Settings

The `AWSS3SinkBlock` is configured using `AWSS3SinkSettings`. Key properties:

- `Uri` (string): The S3 object URI (e.g., "s3://your-bucket-name/path/to/output/file.mp4"). Alternatively, set `Bucket` and `Key` separately.
- `Bucket` (string): The target S3 bucket name.
- `Key` (string): The object key (path within the bucket).
- `AccessKey` (string): Your AWS Access Key.
- `SecretAccessKey` (string): Your AWS Secret Access Key.
- `Region` (string): The AWS region where the bucket is located (default `"us-west-1"`).
- `SessionToken` (string, optional): AWS temporary session token from STS, if using temporary credentials.
- `EndpointUri` (string, optional): Custom S3-compatible endpoint URI.
- `ContentType` (string, optional): The MIME type of the content being uploaded (e.g., "video/mp4").
- `ContentDisposition` (string, optional): Content-Disposition header to set for the uploaded object.
- `Metadata` (Dictionary<string, string>, optional): A map of user metadata to store with the object.
- `ForcePathStyle` (bool, optional): Force client to use path-style addressing for buckets.
- `UseMultipartUpload` (bool, optional, default `true`): Use multipart upload for large files.
- `PartSize` (ulong, optional, default 5 MB): Size in bytes of an individual part used for multipart upload.
- `OnError` (S3SinkOnError, optional): How to handle errors during upload.
- `RequestTimeout` (TimeSpan, optional, default 15s): Timeout for S3 requests (set to `TimeSpan.Zero` for infinity).
- `RetryAttempts` (uint, optional, default 5): Number of retry attempts before abandoning a request.

#### The sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->VideoEncoderBlock;
    VideoEncoderBlock-->MP4SinkBlock;
    SystemAudioSourceBlock-->AudioEncoderBlock;
    AudioEncoderBlock-->MP4SinkBlock;
    MP4SinkBlock-->AWSS3SinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create video source (e.g., webcam)
var videoDevice = (await DeviceEnumerator.Shared.VideoSourcesAsync())[0];
var videoSourceSettings = new VideoCaptureDeviceSourceSettings(videoDevice);
var videoSource = new SystemVideoSourceBlock(videoSourceSettings);

// Create audio source (e.g., microphone)
var audioDevice = (await DeviceEnumerator.Shared.AudioSourcesAsync())[0];
var audioSourceSettings = audioDevice.CreateSourceSettings(audioDevice.Formats[0].ToFormat());
var audioSource = new SystemAudioSourceBlock(audioSourceSettings);

// Create video encoder
var h264Settings = new OpenH264EncoderSettings(); // Example encoder settings
var videoEncoder = new H264EncoderBlock(h264Settings);

// Create audio encoder
var opusSettings = new OPUSEncoderSettings(); // Example encoder settings
var audioEncoder = new OPUSEncoderBlock(opusSettings);

// Create an MP4 muxer in mux-only mode — produces a muxed output pad instead of writing a file.
var mp4MuxSettings = new MP4SinkSettings(string.Empty) { MuxOnly = true };
var mp4Muxer = new MP4SinkBlock(mp4MuxSettings);

// Configure AWSS3SinkSettings
var s3SinkSettings = new AWSS3SinkSettings
{
    Uri = "s3://your-bucket-name/output/recorded-video.mp4",
    AccessKey = "YOUR_AWS_ACCESS_KEY",
    SecretAccessKey = "YOUR_AWS_SECRET_ACCESS_KEY",
    Region = "your-aws-region", // e.g., "us-east-1"
    ContentType = "video/mp4"
};

var s3Sink = new AWSS3SinkBlock(s3SinkSettings);

// Connect video path
pipeline.Connect(videoSource.Output, videoEncoder.Input);
pipeline.Connect(videoEncoder.Output, mp4Muxer.CreateNewInput(MediaBlockPadMediaType.Video));

// Connect audio path
pipeline.Connect(audioSource.Output, audioEncoder.Input);
pipeline.Connect(audioEncoder.Output, mp4Muxer.CreateNewInput(MediaBlockPadMediaType.Audio));

// Connect muxer to S3 sink
pipeline.Connect(mp4Muxer.Output, s3Sink.Input);

// Check if AWSS3Sink is available
if (!AWSS3SinkBlock.IsAvailable())
{
    Console.WriteLine("AWS S3 Sink Block is not available. Check SDK redistributables.");
    return;
}

// Start pipeline
await pipeline.StartAsync();

// ... wait for recording to finish ...

// Stop pipeline
await pipeline.StopAsync();
```

#### Remarks

You can check if the `AWSS3SinkBlock` is available at runtime using the static method `AWSS3SinkBlock.IsAvailable()`. This ensures that the necessary underlying GStreamer plugins and AWS SDK components are present.

#### Platforms

Windows, macOS, Linux. (Availability depends on GStreamer AWS plugin and AWS SDK support on these platforms).

---END OF PAGE---


## Bridge Blocks for Dynamic Pipeline Switching in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Bridge/
**Description:** Dynamically switch between audio, video, and subtitle pipelines without interrupting playback using VisioForge Media Blocks SDK bridge blocks.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming
**API:** MediaBlocksPipeline, VideoRendererBlock, MediaBlockPadMediaType, BridgeAudioSourceBlock, BridgeAudioSinkBlock

# Bridge blocks

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Bridges can be used to link two pipelines and dynamically switch between them. For example, you can switch between different files or cameras in the first Pipeline without interrupting streaming in the second Pipeline.

To link source and sink, give them the same name. Each bridge pair has a unique channel name.

## Bridge audio sink and source

Bridges can be used to connect different media pipelines and use them independently. `BridgeAudioSourceBlock` is used to connect to `BridgeAudioSinkBlock` and supports uncompressed audio.

### Block info

#### BridgeAudioSourceBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output audio | uncompressed audio | 1 |

#### BridgeAudioSinkBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | uncompressed audio | 1 |

### Sample pipelines

#### First pipeline with an audio source and a bridge audio sink

```
graph LR;
    VirtualAudioSourceBlock-->BridgeAudioSinkBlock;
```

#### Second pipeline with a bridge audio source and an audio renderer

```
graph LR;
    BridgeAudioSourceBlock-->AudioRendererBlock;
```

### Sample code

The source pipeline with virtual audio source and bridge audio sink.

```
// create source pipeline
var sourcePipeline = new MediaBlocksPipeline();

// create virtual audio source and bridge audio sink
// BridgeAudioSinkSettings requires (string channel, AudioInfoX audioInfo) — no parameterless ctor
var audioInfo = new AudioInfoX(AudioFormatX.S16LE, 48000, 2);
var audioSourceBlock = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());
var bridgeAudioSink = new BridgeAudioSinkBlock(new BridgeAudioSinkSettings("audio-bridge", audioInfo));

// connect source and sink
sourcePipeline.Connect(audioSourceBlock.Output, bridgeAudioSink.Input);

// start pipeline
await sourcePipeline.StartAsync();
```

The sink pipeline with bridge audio source and audio renderer.

```
// create sink pipeline
var sinkPipeline = new MediaBlocksPipeline();

// create bridge audio source and audio renderer
// BridgeAudioSourceSettings requires (string channel, AudioInfoX audioInfo) — must match the sink above
var audioInfo = new AudioInfoX(AudioFormatX.S16LE, 48000, 2);
var bridgeAudioSource = new BridgeAudioSourceBlock(new BridgeAudioSourceSettings("audio-bridge", audioInfo));
var audioRenderer = new AudioRendererBlock();

// connect source and sink
sinkPipeline.Connect(bridgeAudioSource.Output, audioRenderer.Input);

// start pipeline
await sinkPipeline.StartAsync();
```

## Bridge video sink and source

Bridges can be used to connect different media pipelines and use them independently. `BridgeVideoSinkBlock` is used to connect to the `BridgeVideoSourceBlock` and supports uncompressed video.

### Blocks info

#### BridgeVideoSinkBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | uncompressed video | 1 |

#### BridgeVideoSourceBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | uncompressed video | 1 |

### Sample pipelines

#### First pipeline with a video source and a bridge video sink

```
graph LR;
    VirtualVideoSourceBlock-->BridgeVideoSinkBlock;
```

#### Second pipeline with a bridge video source and a video renderer

```
graph LR;
    BridgeVideoSourceBlock-->VideoRendererBlock;
```

### Sample code

Source pipeline with a virtual video source and bridge video sink.

```
// create source pipeline
var sourcePipeline = new MediaBlocksPipeline();

// create virtual video source and bridge video sink
var videoSourceBlock = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());
var bridgeVideoSink = new BridgeVideoSinkBlock(new BridgeVideoSinkSettings());

// connect source and sink
sourcePipeline.Connect(videoSourceBlock.Output, bridgeVideoSink.Input);

// start pipeline
await sourcePipeline.StartAsync();
```

Sink pipeline with a bridge video source and video renderer.

```
// create sink pipeline
var sinkPipeline = new MediaBlocksPipeline();

// create bridge video source and video renderer
var bridgeVideoSource = new BridgeVideoSourceBlock(new BridgeVideoSourceSettings());
var videoRenderer = new VideoRendererBlock(sinkPipeline, VideoView1);

// connect source and sink
sinkPipeline.Connect(bridgeVideoSource.Output, videoRenderer.Input);

// start pipeline
await sinkPipeline.StartAsync();
```

## Bridge subtitle sink and source

Bridges can be used to connect different media pipelines and use them independently. `BridgeSubtitleSourceBlock` is used to connect to the `BridgeSubtitleSinkBlock`and supports text media type.

### Block info

#### BridgeSubtitleSourceBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | text | 1 |

#### BridgeSubtitleSinkBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | text | 1 |

## Proxy source

Proxy source/proxy sink pair of blocks can be used to connect different media pipelines and use them independently.

### Block info

Name: ProxySourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output | Any uncompressed | 1 |

### Sample pipelines

#### First pipeline with a video source and a proxy video sink

```
graph LR;
    VirtualVideoSourceBlock-->ProxySinkBlock;
```

#### Second pipeline with a proxy video source and a video renderer

```
graph LR;
    ProxySourceBlock-->VideoRendererBlock;
```

### Sample code

```
// ProxySink and ProxySource are paired by string pairID — pick any unique value per pair.
const string pairID = "video-proxy-1";

// source pipeline with virtual video source and proxy sink
var sourcePipeline = new MediaBlocksPipeline();
var videoSourceBlock = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());
var proxyVideoSink = new ProxySinkBlock(pairID);
sourcePipeline.Connect(videoSourceBlock.Output, proxyVideoSink.Input);

// sink pipeline with proxy video source and video renderer — matching pairID links them
var sinkPipeline = new MediaBlocksPipeline();
var proxyVideoSource = new ProxySourceBlock(pairID);
var videoRenderer = new VideoRendererBlock(sinkPipeline, VideoView1);
sinkPipeline.Connect(proxyVideoSource.Output, videoRenderer.Input);

// start pipelines
await sourcePipeline.StartAsync();
await sinkPipeline.StartAsync();
```

## Platforms

All bridge blocks are supported on Windows, macOS, Linux, iOS, and Android.

## Bridge Buffer sink and source

BridgeBuffer blocks provide high-performance memory buffer-based communication between pipelines, ideal for sharing video frames without encoding overhead.

### Block info

#### BridgeBufferSinkBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | uncompressed video | 1 |

#### BridgeBufferSourceBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output | auto | 1 |

### Sample code

```
// First pipeline with video source and bridge buffer sink
var sourcePipeline = new MediaBlocksPipeline();
var videoSource = new SystemVideoSourceBlock(videoSettings);

var videoInfo = new VideoFrameInfoX(1920, 1080, VideoFormatX.NV12, new VideoFrameRate(30));
var bufferSink = new BridgeBufferSinkBlock("buffer-channel", videoInfo);
sourcePipeline.Connect(videoSource.Output, bufferSink.Input);

// Second pipeline with bridge buffer source and renderer
var sinkPipeline = new MediaBlocksPipeline();
var bufferSource = new BridgeBufferSourceBlock("buffer-channel");
var videoRenderer = new VideoRendererBlock(sinkPipeline, VideoView1);
sinkPipeline.Connect(bufferSource.Output, videoRenderer.Input);

await sourcePipeline.StartAsync();
await sinkPipeline.StartAsync();
```

## InterPipe sink and source

InterPipe blocks use GStreamer's interpipesink/interpipesrc elements for efficient inter-pipeline communication with support for both audio and video.

### Block info

#### InterPipeSinkBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | audio or video | 1 |

#### InterPipeSourceBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output | audio or video | 1 |

### Sample code

```
// First pipeline with video source and interpipe sink
var sourcePipeline = new MediaBlocksPipeline();
var videoSource = new SystemVideoSourceBlock(videoSettings);

var videoInfo = new VideoFrameInfoX(1920, 1080, VideoFormatX.NV12, new VideoFrameRate(30));
var interpipeSink = new InterPipeSinkBlock("interpipe-channel", videoInfo);
sourcePipeline.Connect(videoSource.Output, interpipeSink.Input);

// Second pipeline with interpipe source and renderer
var sinkPipeline = new MediaBlocksPipeline();
var interpipeSource = new InterPipeSourceBlock("interpipe-channel", MediaBlockPadMediaType.Video);
var videoRenderer = new VideoRendererBlock(sinkPipeline, VideoView1);
sinkPipeline.Connect(interpipeSource.Output, videoRenderer.Input);

await sourcePipeline.StartAsync();
await sinkPipeline.StartAsync();
```

## RS Inter sink and source

RSInter blocks use the Rust-based GStreamer rsinter plugin for high-performance inter-pipeline communication.

### Block info

#### RSInterSinkBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | audio or video | 1 |

#### RSInterSourceBlock information

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output | audio or video | 1 |

### Sample code

```
// First pipeline with video source and rsinter sink
var sourcePipeline = new MediaBlocksPipeline();
var videoSource = new SystemVideoSourceBlock(videoSettings);

var rsinterSink = new RSInterSinkBlock(MediaBlockPadMediaType.Video, "rsinter-channel");
sourcePipeline.Connect(videoSource.Output, rsinterSink.Input);

// Second pipeline with rsinter source and renderer
var sinkPipeline = new MediaBlocksPipeline();
var rsinterSource = new RSInterSourceBlock(MediaBlockPadMediaType.Video, "rsinter-channel");
var videoRenderer = new VideoRendererBlock(sinkPipeline, VideoView1);
sinkPipeline.Connect(rsinterSource.Output, videoRenderer.Input);

await sourcePipeline.StartAsync();
await sinkPipeline.StartAsync();
```

## AppBridge Video and Audio

AppBridge blocks use GStreamer's `appsink` and `appsrc` elements to provide direct buffer transfer between pipelines with **preserved timestamps**. Unlike other bridge types that may regenerate timestamps, AppBridge maintains the original PTS (Presentation Timestamp), DTS (Decode Timestamp), and duration values.

This makes AppBridge ideal for:

- **Hardware outputs** like Decklink cards that require precise timing synchronization
- **Live streaming** scenarios where timestamp accuracy is critical
- **Multi-pipeline architectures** where clock synchronization between pipelines is important

### How it works

1. The sink block (`AppBridgeVideoSinkBlock` or `AppBridgeAudioSinkBlock`) captures buffers using `appsink` with `sync=false` to avoid clock-based delays
2. Buffers are passed directly to the linked source with their original timestamps preserved
3. The source block (`AppBridgeVideoSourceBlock` or `AppBridgeAudioSourceBlock`) injects buffers using `appsrc` with `is-live=true` and `do-timestamp=false`
4. The downstream element (e.g., Decklink) receives properly timestamped buffers for hardware clock synchronization

### Block info

#### AppBridgeVideoSinkBlock

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | uncompressed video | 1 |

#### AppBridgeVideoSourceBlock

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output | uncompressed video | 1 |

#### AppBridgeAudioSinkBlock

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | uncompressed audio | 1 |

#### AppBridgeAudioSourceBlock

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output | uncompressed audio | 1 |

### Settings

#### AppBridgeVideoSinkSettings / AppBridgeAudioSinkSettings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| Channel | string | required | Unique channel name to match with source |
| Info | VideoFrameInfoX / AudioInfoX | required | Media format specification |
| MaxBuffers | int | 5 (video) / 10 (audio) | Maximum buffer queue size |
| Sync | bool | false | Sync to pipeline clock (false for live sources) |

#### AppBridgeVideoSourceSettings / AppBridgeAudioSourceSettings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| Channel | string | required | Channel name matching the sink |
| Info | VideoFrameInfoX / AudioInfoX | required | Media format specification |
| IsLive | bool | true | Marks source as live for proper pipeline behavior |
| DoTimestamp | bool | false | Set to false to preserve original timestamps |

#### Generating secure channel names

For security, use the `GenerateUniqueChannel()` helper method to create GUID-based channel names:

```
var channel = AppBridgeVideoSinkSettings.GenerateUniqueChannel("decklink_video");
// Returns: "decklink_video_a1b2c3d4e5f6..."
```

### Sample pipelines

#### Main pipeline with video/audio tee and AppBridge sinks

```
graph LR;
    VideoSource-->VideoTee;
    VideoTee-->VideoRenderer;
    VideoTee-->AppBridgeVideoSinkBlock;
    AudioSource-->AudioTee;
    AudioTee-->AudioRenderer;
    AudioTee-->AppBridgeAudioSinkBlock;
```

#### Output pipeline with AppBridge sources and Decklink output

```
graph LR;
    AppBridgeVideoSourceBlock-->DecklinkVideoAudioSinkBlock;
    AppBridgeAudioSourceBlock-->VolumeBlock;
    VolumeBlock-->DecklinkVideoAudioSinkBlock;
```

### Sample code

Complete example showing Decklink output using AppBridge for proper timestamp handling:

```
// Main pipeline with video/audio sources
var mainPipeline = new MediaBlocksPipeline();

// Video and audio format definitions
var videoInfo = new VideoFrameInfoX(1920, 1080, new VideoFrameRate(60));
var audioInfo = new AudioInfoX(AudioFormatX.S16LE, 48000, 2);

// Create tees for splitting streams
var videoTee = new TeeBlock(2, MediaBlockPadMediaType.Video);
var audioTee = new TeeBlock(2, MediaBlockPadMediaType.Audio);

// AppBridge sinks in main pipeline
var videoSinkSettings = new AppBridgeVideoSinkSettings("decklink_video", videoInfo);
var appBridgeVideoSink = new AppBridgeVideoSinkBlock(videoSinkSettings);

var audioSinkSettings = new AppBridgeAudioSinkSettings("decklink_audio", audioInfo);
var appBridgeAudioSink = new AppBridgeAudioSinkBlock(audioSinkSettings);

// Connect tee outputs to AppBridge sinks
mainPipeline.Connect(videoTee.Outputs[1], appBridgeVideoSink.Input);
mainPipeline.Connect(audioTee.Outputs[1], appBridgeAudioSink.Input);

// Decklink output pipeline
var decklinkPipeline = new MediaBlocksPipeline();

// AppBridge sources - same channel names as sinks
var videoSourceSettings = new AppBridgeVideoSourceSettings("decklink_video", videoInfo);
var appBridgeVideoSource = new AppBridgeVideoSourceBlock(videoSourceSettings);

var audioSourceSettings = new AppBridgeAudioSourceSettings("decklink_audio", audioInfo);
var appBridgeAudioSource = new AppBridgeAudioSourceBlock(audioSourceSettings);

// Decklink output
var decklinkVideoSettings = new DecklinkVideoSinkSettings(0, DecklinkMode.HD1080p60);
var decklinkAudioSettings = new DecklinkAudioSinkSettings(0);
var decklinkOutput = new DecklinkVideoAudioSinkBlock(decklinkVideoSettings, decklinkAudioSettings);

// Connect AppBridge sources to Decklink
decklinkPipeline.Connect(appBridgeVideoSource.Output, decklinkOutput.VideoInput);
decklinkPipeline.Connect(appBridgeAudioSource.Output, decklinkOutput.AudioInput);

// Start pipelines
await mainPipeline.StartAsync();
await decklinkPipeline.StartAsync();

// Cleanup when done
await decklinkPipeline.StopAsync();
appBridgeVideoSource.Dispose();
appBridgeAudioSource.Dispose();
appBridgeVideoSink.Dispose();
appBridgeAudioSink.Dispose();
```

### When to use AppBridge vs other bridges

| Bridge Type | Best For | Timestamp Handling |
| --- | --- | --- |
| **AppBridge** | Decklink, hardware outputs, precise timing | Preserves original PTS/DTS |
| Standard Bridge | Software rendering, general use | May regenerate timestamps |
| InterPipe | Multiple consumers, flexible routing | Depends on configuration |
| RSInter | High-performance Rust-based | Depends on configuration |
| BridgeBuffer | Memory sharing, zero-copy | Buffer-based |

## Platforms

All bridge blocks are supported on Windows, macOS, Linux, iOS, and Android.

Note: InterPipe and RSInter blocks require the corresponding GStreamer plugins to be installed.

---END OF PAGE---


## VisioForge Media Blocks SDK in C# .NET — Cheat Sheet
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/cheat-sheet/
**Description:** One-page Media Blocks SDK reference with NuGet packages, pipeline APIs, a canonical example, platform support, and common pitfalls.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Avalonia, MAUI, WPF, WinForms, GStreamer, Playback, Capture, Recording, Streaming, Encoding, MP4, H.264, H.265, AAC, C#, NuGet
**API:** MediaBlocksPipeline, UniversalSourceBlock, VideoRendererBlock, SystemVideoSourceBlock, H264EncoderBlock, MP4SinkBlock, DeviceEnumerator

# VisioForge Media Blocks SDK in C# .NET — Cheat Sheet

Media Blocks SDK is the most flexible VisioForge .NET SDK — build arbitrary media pipelines by composing blocks (sources, encoders, renderers, sinks). Choose Media Blocks when you need custom pipelines that the higher-level Media Player / Video Capture / Video Edit SDKs can't express.

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Platform support

- Runs on Windows (x64 / x86), macOS, Linux x64, Android, and iOS.
- UI frameworks: WinForms, WPF, MAUI, Avalonia, Uno, plus console.
- Cross-platform processing is powered by a bundled GStreamer backend on macOS/Android/iOS and by the system GStreamer 1.22+ install on Linux.
- For the full codec × platform matrix, see [platform-matrix.md](../../platform-matrix/).

## NuGet packages

Main SDK package (all platforms):

```
<PackageReference Include="VisioForge.DotNet.MediaBlocks" Version="2026.8.16" />
```

Windows x64 runtime (pick x86 for 32-bit apps):

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<!-- Optional: extra decoders/encoders via Libav -->
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64.UPX" Version="2026.4.29" />
```

Windows x86:

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x86" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x86.UPX" Version="2026.4.29" />
```

macOS (native and MAUI / macCatalyst):

```
<PackageReference Include="VisioForge.CrossPlatform.Core.macOS" Version="2026.8.5" />
<PackageReference Include="VisioForge.CrossPlatform.Core.macCatalyst" Version="2026.8.5" />
```

Linux x64 (also requires GStreamer 1.22+ installed on the system):

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Linux.x64" Version="2025.9.0" />
```

Android and iOS:

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.7.27" />
<PackageReference Include="VisioForge.CrossPlatform.Core.iOS" Version="2025.12.0" />
```

UI integration packages (optional, per framework):

```
<PackageReference Include="VisioForge.DotNet.Core.UI.MAUI" Version="2026.8.16" />
<PackageReference Include="VisioForge.DotNet.Core.UI.Avalonia" Version="2026.8.16" />
```

Full install walkthrough: [install/index.md](../../install/).

## Primary API classes

| Class | Role | See also |
| --- | --- | --- |
| `MediaBlocksPipeline` | Root pipeline object. Connects blocks via `Connect(output, input)`. Exposes `StartAsync` / `StopAsync` / `DisposeAsync` and the `OnError`, `OnStart`, `OnStop` events. | [GettingStarted/pipeline.md](../GettingStarted/pipeline/) |
| `UniversalSourceBlock` | Opens a file, URL, or stream as input. Analyzes streams automatically and exposes `VideoOutput` / `AudioOutput` pads. | [GettingStarted/player.md](../GettingStarted/player/) |
| `VideoRendererBlock` | Binds pipeline video output to an `IVideoView` control (WinForms / WPF / MAUI / Avalonia). Supports snapshots. | [GettingStarted/player.md](../GettingStarted/player/) |
| `SystemVideoSourceBlock` | Webcam / USB / built-in camera input. Configured via `VideoCaptureDeviceSourceSettings`. | [GettingStarted/camera.md](../GettingStarted/camera/) |
| `AndroidUVCSourceBlock` | USB (UVC) camera attached to an Android device over OTG, which Camera2 cannot see. Configured via `AndroidUVCSourceSettings`. | [../general/guides/android-usb-camera.md](../../general/guides/android-usb-camera/) |
| `H264EncoderBlock` | H.264 encoder with software and hardware (NVENC / AMF / Quick Sync) backends. | [GettingStarted/pipeline.md](../GettingStarted/pipeline/) |
| `MP4SinkBlock` | Writes encoded video + audio to an `.mp4` file. Add inputs via `IMediaBlockDynamicInputs.CreateNewInput`. | [Guides/rtsp-save-original-stream.md](../Guides/rtsp-save-original-stream/) |
| `DeviceEnumerator` | Lists cameras, microphones, and audio outputs asynchronously via `DeviceEnumerator.Shared.VideoSourcesAsync()` etc. | [GettingStarted/device-enum.md](../GettingStarted/device-enum/) |

## Canonical minimum example

The simplest useful pipeline — load a file, render video + audio, clean up. Lift and adapt from [GettingStarted/player.md](../GettingStarted/player/).

```
using System;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.MediaBlocks.AudioRendering;
using VisioForge.Core.Types.X.Sources;

// 1. Initialize SDK once at application startup
await VisioForgeX.InitSDKAsync();

// 2. Create the pipeline and subscribe to errors
var pipeline = new MediaBlocksPipeline();
pipeline.OnError += (s, e) => Console.WriteLine(e.Message);

// 3. Source: open a media file (URL or local path via URI)
var sourceSettings = await UniversalSourceSettings.CreateAsync(
    new Uri("file:///C:/Videos/sample.mp4"));
var fileSource = new UniversalSourceBlock(sourceSettings);

// 4. Video renderer — VideoView1 is an IVideoView on your form/page
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// 5. Audio renderer — pick the first system audio output
var audioOutputs = await DeviceEnumerator.Shared.AudioOutputsAsync();
var audioRenderer = new AudioRendererBlock(audioOutputs[0]);

// 6. Connect output pads → input pads
pipeline.Connect(fileSource.VideoOutput, videoRenderer.Input);
pipeline.Connect(fileSource.AudioOutput, audioRenderer.Input);

// 7. Play
await pipeline.StartAsync();

// ... later, on user stop / app exit:
await pipeline.StopAsync();
await pipeline.DisposeAsync();
VisioForgeX.DestroySDK(); // sync only — no async variant
```

Swap `UniversalSourceBlock` for `SystemVideoSourceBlock` (camera) or `RTSPSourceBlock` (IP camera) without changing the rest of the wiring.

## Typical workflow

1. Init SDK — `await VisioForgeX.InitSDKAsync()`.
2. Create `MediaBlocksPipeline` and subscribe to `OnError`.
3. Instantiate source blocks (`UniversalSourceBlock`, `SystemVideoSourceBlock`, `RTSPSourceBlock`, …).
4. Instantiate processing blocks — encoders, mixers, overlays, effects (optional).
5. Instantiate sink / renderer blocks (`VideoRendererBlock`, `AudioRendererBlock`, `MP4SinkBlock`, …).
6. Wire blocks with `pipeline.Connect(output, input)` — every data path must be connected explicitly.
7. `StartAsync` → `StopAsync` → `DisposeAsync`, then `DestroySDK` at app exit.

## Common pitfalls

- **No implicit dataflow.** Blocks must be explicitly wired with `pipeline.Connect(output, input)`; adding a block to the pipeline alone does not route media through it.
- **Overlay / dynamic-input order.** Overlays on `OverlayManagerBlock` and dynamic pads on sinks (`MP4SinkBlock` via `IMediaBlockDynamicInputs.CreateNewInput`) must be added before the pipeline starts — adding them after `StartAsync` silently fails or throws.
- **Awaited enumeration only.** `DeviceEnumerator.Shared.VideoSourcesAsync()` / `AudioOutputsAsync()` must be awaited — there is no synchronous variant. Using `.Result` from a UI thread can deadlock.
- **Linux needs system GStreamer.** `VisioForge.CrossPlatform.Core.Linux.x64` expects GStreamer 1.22+ already installed (`apt install gstreamer1.0-*`); the Libav NuGet is supplementary, not a replacement. See [deployment-x/Ubuntu.md](../../deployment-x/Ubuntu/).
- **Lifecycle hygiene.** Always `await pipeline.StopAsync()` and `await pipeline.DisposeAsync()` before creating another pipeline on the same engine. Skipping dispose leaks native handles and can hang on shutdown.

## See also

- **Getting started**
  - Video file player — [GettingStarted/player.md](../GettingStarted/player/)
  - Camera viewer — [GettingStarted/camera.md](../GettingStarted/camera/)
  - Complete pipeline walkthrough — [GettingStarted/pipeline.md](../GettingStarted/pipeline/)
  - Device enumeration — [GettingStarted/device-enum.md](../GettingStarted/device-enum/)
- **Specific pipelines**
  - RTSP / IP camera player — [Guides/rtsp-player-csharp.md](../Guides/rtsp-player-csharp/)
  - Save RTSP stream (passthrough) — [Guides/rtsp-save-original-stream.md](../Guides/rtsp-save-original-stream/)
  - Multi-camera grid — [Guides/multi-camera-rtsp-grid.md](../Guides/multi-camera-rtsp-grid/)
  - USB (UVC) camera on Android — [../general/guides/android-usb-camera.md](../../general/guides/android-usb-camera/)
- **Deployment**
  - Windows — [../deployment-x/Windows.md](../../deployment-x/Windows/)
  - macOS — [../deployment-x/macOS.md](../../deployment-x/macOS/)
  - Ubuntu — [../deployment-x/Ubuntu.md](../../deployment-x/Ubuntu/)
  - Android — [../deployment-x/Android.md](../../deployment-x/Android/)
  - iOS — [../deployment-x/iOS.md](../../deployment-x/iOS/)
- **Install & platform matrix** — [../install/index.md](../../install/), [../platform-matrix.md](../../platform-matrix/)

## FAQ

### How does Media Blocks differ from Media Player SDK?

Media Player SDK is a high-level, single-class player (`MediaPlayerCoreX`) with built-in playback controls — optimal when you just need to play a file or stream. Media Blocks exposes the underlying pipeline so you can insert encoders, effects, multi-output sinks, or custom processing. If you find yourself fighting Media Player SDK to add a step it doesn't expose, switch to Media Blocks.

### Can I run on Linux without GStreamer?

No. The Linux x64 runtime NuGet is a thin bridge to the system GStreamer 1.22+ stack. Install `gstreamer1.0-plugins-base`, `-good`, `-bad`, `-ugly`, and `-libav` from your distro. See [deployment-x/Ubuntu.md](../../deployment-x/Ubuntu/) for the full package list. macOS / Android / iOS do ship a bundled GStreamer via the platform NuGet.

### How do I add a custom video effect?

Use `GLShaderBlock` for a custom GLSL fragment shader (GPU-accelerated) or the pre-built `GL*Block` family (e.g. `GLBlurBlock`, `GLColorBalanceBlock`) for common effects. For CV-based processing, use the `CV*Block` family (e.g. `CVFaceDetectBlock`, `CVEdgeDetectBlock`, `CVDewarpBlock`). All slot between a decoder and renderer like any other block. Full recipe: [Guides/custom-video-effects-csharp.md](../Guides/custom-video-effects-csharp/).

---END OF PAGE---


## Blackmagic Decklink SDI/HDMI Capture and Output in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Decklink/
**Description:** Capture and render SDI/HDMI video with Blackmagic Decklink cards using VisioForge Media Blocks SDK. Multi-device support, format detection, keying.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture
**API:** DecklinkVideoAudioSourceBlock, DecklinkAudioSinkSettings, DecklinkAudioSourceSettings, DecklinkVideoSinkSettings, DecklinkVideoSourceSettings

# Blackmagic Decklink Integration with Media Blocks SDK

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to Decklink Integration

The VisioForge Media Blocks SDK for .NET provides robust support for Blackmagic Decklink devices, enabling developers to implement professional-grade audio and video functionality in their applications. This integration allows for seamless capture and rendering operations using Decklink's high-quality hardware.

Our SDK includes specialized blocks designed specifically for Decklink devices, giving you full access to their capabilities including SDI, HDMI, and other inputs/outputs. These blocks are optimized for performance and offer a straightforward API for implementing complex media workflows.

### Key Capabilities

- **Audio Capture and Rendering**: Capture and output audio through Decklink devices
- **Video Capture and Rendering**: Capture and output video in various formats and resolutions
- **Multiple Device Support**: Work with multiple Decklink devices simultaneously
- **Professional I/O Options**: Utilize SDI, HDMI, and other professional interfaces
- **High-Quality Processing**: Maintain professional video/audio quality throughout the pipeline
- **Combined Audio/Video Blocks**: Simplified handling of synchronized audio and video streams with dedicated source and sink blocks.

## System Requirements

Before using the Decklink blocks, ensure your system meets these requirements:

- **Hardware**: Compatible Blackmagic Decklink device
- **Software**: Blackmagic Decklink SDK or drivers installed

## Decklink Block Types

The SDK provides several block types for working with Decklink devices:

1. **Audio Sink Block**: For audio output to Decklink devices.
2. **Audio Source Block**: For audio capture from Decklink devices.
3. **Video Sink Block**: For video output to Decklink devices.
4. **Video Source Block**: For video capture from Decklink devices.
5. **Video + Audio Sink Block**: For synchronized video and audio output to Decklink devices using a single block.
6. **Video + Audio Source Block**: For synchronized video and audio capture from Decklink devices using a single block.

Each block type is designed to handle specific media operations while maintaining synchronization and quality.

## Working with Decklink Audio Sink Block

The Decklink Audio Sink block enables audio output to Blackmagic Decklink devices. This block handles the complexities of audio timing and device interfacing.

### Device Enumeration

Before creating an audio sink block, you'll need to enumerate available devices:

```
var devices = await DecklinkAudioSinkBlock.GetDevicesAsync();
foreach (var item in devices)
{
    Console.WriteLine($"Found device: {item.Name}, Device Number: {item.DeviceNumber}");
}
```

This code retrieves all available Decklink devices that support audio output functionality.

### Block Creation and Configuration

Once you've identified the target device, you can create and configure the audio sink block:

```
// Get the first available device
var deviceInfo = (await DecklinkAudioSinkBlock.GetDevicesAsync()).FirstOrDefault();

// Create settings for the selected device
DecklinkAudioSinkSettings audioSinkSettings = null;
if (deviceInfo != null)
{
    audioSinkSettings = new DecklinkAudioSinkSettings(deviceInfo);
    // Example: audioSinkSettings.DeviceNumber = deviceInfo.DeviceNumber; (already set by constructor)
    // Further configuration:
    // audioSinkSettings.BufferTime = TimeSpan.FromMilliseconds(100);
    // audioSinkSettings.IsSync = true;
}

// Create the block with configured settings
var decklinkAudioSink = new DecklinkAudioSinkBlock(audioSinkSettings);
```

### Key Audio Sink Settings

The `DecklinkAudioSinkSettings` class includes properties like:

- `DeviceNumber`: The output device instance to use.
- `BufferTime`: Minimum latency reported by the sink (default: 50ms).
- `AlignmentThreshold`: Timestamp alignment threshold (default: 40ms).
- `DiscontWait`: Time to wait before creating a discontinuity (default: 1s).
- `IsSync`: Enables synchronization (default: true).

### Connecting to the Pipeline

The audio sink block includes an `Input` pad that accepts audio data from other blocks in your pipeline:

```
// Example: Connect an audio source/encoder to the Decklink audio sink
audioEncoder.Output.Connect(decklinkAudioSink.Input);
```

## Working with Decklink Audio Source Block

The Decklink Audio Source block enables capturing audio from Blackmagic Decklink devices. It supports various audio formats and configurations.

### Device Enumeration

Enumerate available audio source devices:

```
var devices = await DecklinkAudioSourceBlock.GetDevicesAsync();
foreach (var item in devices)
{
    Console.WriteLine($"Available audio source: {item.Name}, Device Number: {item.DeviceNumber}");
}
```

### Block Creation and Configuration

Create and configure the audio source block:

```
// Get the first available device
var deviceInfo = (await DecklinkAudioSourceBlock.GetDevicesAsync()).FirstOrDefault();

// Create settings for the selected device
DecklinkAudioSourceSettings audioSourceSettings = null;
if (deviceInfo != null)
{
    // create settings object
    audioSourceSettings = new DecklinkAudioSourceSettings(deviceInfo);
    // Further configuration:
    // audioSourceSettings.Channels = DecklinkAudioChannels.Ch2;
    // audioSourceSettings.Connection = DecklinkAudioConnection.Embedded;
    // audioSourceSettings.Format = DecklinkAudioFormat.S16LE; // SampleRate is fixed at 48000
}

// Create the block with the configured settings
var audioSource = new DecklinkAudioSourceBlock(audioSourceSettings);
```

### Key Audio Source Settings

The `DecklinkAudioSourceSettings` class includes properties like:

- `DeviceNumber`: The input device instance to use.
- `Channels`: Audio channels to capture (e.g., `DecklinkAudioChannels.Ch2`, `Ch8`, `Ch16`). Default `Ch2`.
- `Format`: Audio sample format (e.g., `DecklinkAudioFormat.S16LE`). Default `S16LE`. Sample rate is fixed at 48000 Hz.
- `Connection`: Audio connection type (e.g., `DecklinkAudioConnection.Embedded`, `AES`, `Analog`). Default `Auto`.
- `BufferSize`: Internal buffer size in frames (default: 5).
- `DisableAudioConversion`: Set to `true` to disable internal audio conversion. Default `false`.

### Connecting to the Pipeline

The audio source block provides an `Output` pad that can connect to other blocks:

```
// Example: Connect the audio source to an audio encoder or processor
audioSource.Output.Connect(audioProcessor.Input);
```

## Working with Decklink Video Sink Block

The Decklink Video Sink block enables video output to Blackmagic Decklink devices, supporting various video formats and resolutions.

### Device Enumeration

Find available video sink devices:

```
var devices = await DecklinkVideoSinkBlock.GetDevicesAsync();
foreach (var item in devices)
{
    Console.WriteLine($"Available video output device: {item.Name}, Device Number: {item.DeviceNumber}");
}
```

### Block Creation and Configuration

Create and configure the video sink block:

```
// Get the first available device
var deviceInfo = (await DecklinkVideoSinkBlock.GetDevicesAsync()).FirstOrDefault();

// Create settings for the selected device
// Note: Mode is required and must be specified in the constructor
DecklinkVideoSinkSettings videoSinkSettings = null;
if (deviceInfo != null)
{
    // Mode is required - specify the output video resolution and frame rate
    videoSinkSettings = new DecklinkVideoSinkSettings(deviceInfo, DecklinkMode.HD1080i60)
    {
        VideoFormat = DecklinkVideoFormat.YUV_10bit,
        // Optional: Additional configuration
        // KeyerMode = DecklinkKeyerMode.Internal,
        // KeyerLevel = 128,
        // Profile = DecklinkProfileID.Default,
        // TimecodeFormat = DecklinkTimecodeFormat.RP188Any
    };
}

// Create the block with the configured settings
var decklinkVideoSink = new DecklinkVideoSinkBlock(videoSinkSettings);
```

### Key Video Sink Settings

The `DecklinkVideoSinkSettings` class includes properties like:

- `DeviceNumber`: The output device instance to use (read-only, set via constructor).
- `Mode`: Specifies the video resolution and frame rate (e.g., `DecklinkMode.HD1080i60`, `HD720p60`). **Required** - must be specified in the constructor.
- `VideoFormat`: Defines the pixel format using `DecklinkVideoFormat` enum (e.g., `DecklinkVideoFormat.YUV_8bit`, `YUV_10bit`). Default `YUV_8bit`.
- `KeyerMode`: Controls keying/compositing options using `DecklinkKeyerMode` (if supported by the device). Default `Off`.
- `KeyerLevel`: Sets the keyer level (0-255). Default `255`.
- `Profile`: Specifies the Decklink profile to use with `DecklinkProfileID`.
- `TimecodeFormat`: Specifies the timecode format for playback using `DecklinkTimecodeFormat`. Default `RP188Any`.
- `CustomVideoSize`: Optional resize effect to apply before output.
- `CustomFrameRate`: Optional frame rate conversion before output.
- `IsSync`: Enables synchronization (default: true).

**Important**: The `Mode` parameter is required and determines the output frame rate and resolution. If not specified correctly, the Decklink hardware may output at an unexpected frame rate.

## Working with Decklink Video Source Block

The Decklink Video Source block allows capturing video from Blackmagic Decklink devices, supporting various input formats and resolutions.

### Device Enumeration

Enumerate video capture devices:

```
var devices = await DecklinkVideoSourceBlock.GetDevicesAsync();
foreach (var item in devices)
{
    Console.WriteLine($"Available video capture device: {item.Name}, Device Number: {item.DeviceNumber}");
}
```

### Block Creation and Configuration

Create and configure the video source block:

```
// Get the first available device
var deviceInfo = (await DecklinkVideoSourceBlock.GetDevicesAsync()).FirstOrDefault();

// Create settings for the selected device
DecklinkVideoSourceSettings videoSourceSettings = null;
if (deviceInfo != null)
{
    videoSourceSettings = new DecklinkVideoSourceSettings(deviceInfo);

    // Configure video input format and mode
    videoSourceSettings.Mode = DecklinkMode.HD1080i60;
    videoSourceSettings.Connection = DecklinkConnection.SDI;
    // videoSourceSettings.VideoFormat = DecklinkVideoFormat.Auto; // Often used with Mode=Auto
}

// Create the block with configured settings
var videoSourceBlock = new DecklinkVideoSourceBlock(videoSourceSettings);
```

### Key Video Source Settings

The `DecklinkVideoSourceSettings` class includes properties like:

- `DeviceNumber`: The input device instance to use.
- `Mode`: Specifies the expected input resolution and frame rate (e.g., `DecklinkMode.HD1080i60`). Default `Unknown`.
- `Connection`: Defines which physical input to use, using `DecklinkConnection` enum (e.g., `DecklinkConnection.HDMI`, `DecklinkConnection.SDI`). Default `Auto`.
- `VideoFormat`: Specifies the video format type for input, using `DecklinkVideoFormat` enum. Default `Auto` (especially when `Mode` is `Auto`).
- `Profile`: Specifies the Decklink profile using `DecklinkProfileID`. Default `Default`.
- `DropNoSignalFrames`: If `true`, drops frames marked as having no input signal. Default `false`.
- `OutputAFDBar`: If `true`, extracts and outputs AFD/Bar data as Meta. Default `false`.
- `OutputCC`: If `true`, extracts and outputs Closed Captions as Meta. Default `false`.
- `TimecodeFormat`: Specifies the timecode format using `DecklinkTimecodeFormat`. Default `RP188Any`.
- `DisableVideoConversion`: Set to `true` to disable internal video conversion. Default `false`.

## Working with Decklink Video + Audio Source Block

The `DecklinkVideoAudioSourceBlock` simplifies capturing synchronized video and audio streams from a single Decklink device.

### Device Enumeration and Configuration

Device selection is managed through `DecklinkVideoSourceSettings` and `DecklinkAudioSourceSettings`. You would typically enumerate video devices using `DecklinkVideoSourceBlock.GetDevicesAsync()` and audio devices using `DecklinkAudioSourceBlock.GetDevicesAsync()`, then configure the respective settings objects for the chosen device. The `DecklinkVideoAudioSourceBlock` itself also provides `GetDevicesAsync()` which enumerates video sources.

```
// Enumerate video devices (for video part of the combined source)
var videoDeviceInfo = (await DecklinkVideoAudioSourceBlock.GetDevicesAsync()).FirstOrDefault(); // or DecklinkVideoSourceBlock.GetDevicesAsync()
var audioDeviceInfo = (await DecklinkAudioSourceBlock.GetDevicesAsync()).FirstOrDefault(d => d.DeviceNumber == videoDeviceInfo.DeviceNumber); // Example: match by device number

DecklinkVideoSourceSettings videoSettings = null;
if (videoDeviceInfo != null)
{
    videoSettings = new DecklinkVideoSourceSettings(videoDeviceInfo);
    videoSettings.Mode = DecklinkMode.HD1080i60;
    videoSettings.Connection = DecklinkConnection.SDI;
}

DecklinkAudioSourceSettings audioSettings = null;
if (audioDeviceInfo != null)
{
    audioSettings = new DecklinkAudioSourceSettings(audioDeviceInfo);
    audioSettings.Channels = DecklinkAudioChannels.Ch2;
}

// Create the block with configured settings
if (videoSettings != null && audioSettings != null)
{
    var decklinkVideoAudioSource = new DecklinkVideoAudioSourceBlock(videoSettings, audioSettings);

    // Connect outputs
    // decklinkVideoAudioSource.VideoOutput.Connect(videoProcessor.Input);
    // decklinkVideoAudioSource.AudioOutput.Connect(audioProcessor.Input);
}
```

### Block Creation and Configuration

You instantiate `DecklinkVideoAudioSourceBlock` by providing pre-configured `DecklinkVideoSourceSettings` and `DecklinkAudioSourceSettings` objects.

```
// Assuming videoSourceSettings and audioSourceSettings are configured as above
var videoAudioSource = new DecklinkVideoAudioSourceBlock(videoSourceSettings, audioSourceSettings);
```

### Connecting to the Pipeline

The block provides separate `VideoOutput` and `AudioOutput` pads:

```
// Example: Connect to video and audio processors/encoders
videoAudioSource.VideoOutput.Connect(videoEncoder.Input);
videoAudioSource.AudioOutput.Connect(audioEncoder.Input);
```

## Working with Decklink Video + Audio Sink Block

The `DecklinkVideoAudioSinkBlock` simplifies sending synchronized video and audio streams to a single Decklink device.

### Device Enumeration and Configuration

Similar to the combined source, device selection is managed via `DecklinkVideoSinkSettings` and `DecklinkAudioSinkSettings`. Enumerate devices using `DecklinkVideoSinkBlock.GetDevicesAsync()` and `DecklinkAudioSinkBlock.GetDevicesAsync()`.

```
var videoSinkDeviceInfo = (await DecklinkVideoSinkBlock.GetDevicesAsync()).FirstOrDefault();
var audioSinkDeviceInfo = (await DecklinkAudioSinkBlock.GetDevicesAsync()).FirstOrDefault(d => d.DeviceNumber == videoSinkDeviceInfo.DeviceNumber); // Example match

DecklinkVideoSinkSettings videoSinkSettings = null;
if (videoSinkDeviceInfo != null)
{
    // Mode is required - specify the output video resolution and frame rate
    videoSinkSettings = new DecklinkVideoSinkSettings(videoSinkDeviceInfo, DecklinkMode.HD1080i60)
    {
        VideoFormat = DecklinkVideoFormat.YUV_8bit
    };
}

DecklinkAudioSinkSettings audioSinkSettings = null;
if (audioSinkDeviceInfo != null)
{
    audioSinkSettings = new DecklinkAudioSinkSettings(audioSinkDeviceInfo);
}

// Create the block
if (videoSinkSettings != null && audioSinkSettings != null)
{
    var decklinkVideoAudioSink = new DecklinkVideoAudioSinkBlock(videoSinkSettings, audioSinkSettings);

    // Connect inputs
    // videoEncoder.Output.Connect(decklinkVideoAudioSink.VideoInput);
    // audioEncoder.Output.Connect(decklinkVideoAudioSink.AudioInput);
}
```

### Block Creation and Configuration

Instantiate `DecklinkVideoAudioSinkBlock` with configured `DecklinkVideoSinkSettings` and `DecklinkAudioSinkSettings`.

```
// Assuming videoSinkSettings and audioSinkSettings are configured
var videoAudioSink = new DecklinkVideoAudioSinkBlock(videoSinkSettings, audioSinkSettings);
```

### Connecting to the Pipeline

The block provides separate `VideoInput` and `AudioInput` pads:

```
// Example: Connect from video and audio encoders
videoEncoder.Output.Connect(videoAudioSink.VideoInput);
audioEncoder.Output.Connect(videoAudioSink.AudioInput);
```

## Advanced Usage Examples

### Synchronized Audio/Video Capture

**Using separate source blocks:**

```
// Assume videoSourceSettings and audioSourceSettings are configured for the same device/timing
var videoSource = new DecklinkVideoSourceBlock(videoSourceSettings);
var audioSource = new DecklinkAudioSourceBlock(audioSourceSettings);

// Create an MP4 encoder
var mp4Settings = new MP4SinkSettings("output.mp4");
var sink = new MP4SinkBlock(mp4Settings);

// Create video encoder
var videoEncoder = new H264EncoderBlock();

// Create audio encoder
var audioEncoder = new AACEncoderBlock();

// Connect video and audio sources
pipeline.Connect(videoSource.Output, videoEncoder.Input);
pipeline.Connect(audioSource.Output, audioEncoder.Input);

// Connect video encoder to sink
pipeline.Connect(videoEncoder.Output, sink.CreateNewInput(MediaBlockPadMediaType.Video));

// Connect audio encoder to sink
pipeline.Connect(audioEncoder.Output, sink.CreateNewInput(MediaBlockPadMediaType.Audio));

// Start the pipeline
await pipeline.StartAsync();
```

**Using `DecklinkVideoAudioSourceBlock` for simplified synchronized capture:** If you use `DecklinkVideoAudioSourceBlock` (as configured in its dedicated section), the source setup becomes:

```
// Assuming videoSourceSettings and audioSourceSettings are configured for the same device
var videoAudioSource = new DecklinkVideoAudioSourceBlock(videoSourceSettings, audioSourceSettings);

// ... (encoders and sink setup as above) ...

// Connect video and audio from the combined source
pipeline.Connect(videoAudioSource.VideoOutput, videoEncoder.Input);
pipeline.Connect(videoAudioSource.AudioOutput, audioEncoder.Input);

// ... (connect encoders to sink and start pipeline as above) ...
```

This ensures that audio and video are sourced from the Decklink device in a synchronized manner by the SDK.

## Troubleshooting Tips

- **No Devices Found**: Ensure Blackmagic drivers/SDK are installed and up-to-date. Check if the device is recognized by Blackmagic Desktop Video Setup.
- **Format Mismatch**: Verify the device supports your selected video/audio mode, format, and connection type. For sources with `Mode = DecklinkMode.Unknown` (auto-detect), ensure a stable signal is present.
- **Performance Issues**: Check system resources (CPU, RAM, disk I/O). Consider lowering resolution/framerate if issues persist.
- **Signal Detection**: For input devices, check cable connections and ensure the source device is outputting a valid signal.
- **"Unable to build ...Block" errors**: Double-check that all settings are valid for the selected device and mode. Ensure the correct `DeviceNumber` is used if multiple Decklink cards are present.

## Sample Applications

For complete working examples, refer to these sample applications:

- [Decklink Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Decklink%20Demo)

## Conclusion

The Blackmagic Decklink blocks in the VisioForge Media Blocks SDK provide a powerful and flexible way to integrate professional video and audio hardware into your .NET applications. By leveraging the specific source and sink blocks, including the combined audio/video blocks, you can efficiently implement complex capture and playback workflows. Always refer to the specific settings classes for detailed configuration options.

---END OF PAGE---


## Media Demuxer Blocks in C# .NET - MP4, MKV, MPEG-TS
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Demuxers/
**Description:** Separate audio, video, and subtitle streams from MP4, MKV, AVI, and MPEG-TS containers using VisioForge Media Blocks SDK demuxer blocks.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming
**API:** UniversalDemuxBlock, UniversalAutoDemuxerBlock, MPEGTSDemuxBlock, QTDemuxBlock, UniversalSourceBlock, MediaFileInfo

# Demuxer Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Demuxer blocks are essential components in media processing pipelines. They take a multimedia stream, typically from a file or network source, and separate it into its constituent elementary streams, such as video, audio, and subtitles. This allows for individual processing or rendering of each stream. VisioForge Media Blocks SDK .Net provides several demuxer blocks to handle various container formats.

> **Demuxer outputs are encoded.** A demuxer separates the container into its elementary streams; it does not decode them. A decoder block therefore has to sit between a demuxer output and any renderer, sample grabber or video processing block. `UniversalDecoderBlock` picks the decoder from the stream's caps; a codec-specific block such as `H264DecoderBlock` or `HEVCDecoderBlock` works too. Connecting a demuxer straight to a renderer builds and starts without an error and then delivers nothing.

## MPEG-TS Demux Block

The `MPEGTSDemuxBlock` is used to demultiplex MPEG Transport Streams (MPEG-TS). MPEG-TS is a standard format for transmission and storage of audio, video, and Program and System Information Protocol (PSIP) data. It is commonly used in digital television broadcasting and streaming.

### Block info

Name: `MPEGTSDemuxBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | MPEG-TS Data | 1 |
| Output video | Depends on stream content | 0 or 1+ |
| Output audio | Depends on stream content | 0 or 1+ |
| Output subtitle | Depends on stream content | 0 or 1+ |
| Output metadata | Depends on stream content | 0 or 1+ |

### Settings

The `MPEGTSDemuxBlock` is configured using `MPEGTSDemuxSettings`.

Key properties of `MPEGTSDemuxSettings`:

- `Latency` (`TimeSpan`): Gets or sets the latency. Default is 700 milliseconds.
- `ProgramNumber` (int): Gets or sets the program number. Use -1 for default/automatic selection.

### The sample pipeline

This example shows how to connect a source (like `HTTPSourceBlock` for a network stream or `UniversalSourceBlock` for a local file that outputs raw MPEG-TS data) to `MPEGTSDemuxBlock`, and then connect its outputs to respective renderer blocks.

```
graph LR;
    DataSourceBlock -- MPEG-TS Data --> MPEGTSDemuxBlock;
    MPEGTSDemuxBlock -- Video Stream --> VideoDecoderBlock;
    VideoDecoderBlock -- Decoded Video --> VideoRendererBlock;
    MPEGTSDemuxBlock -- Audio Stream --> AudioDecoderBlock;
    AudioDecoderBlock -- Decoded Audio --> AudioRendererBlock;
    MPEGTSDemuxBlock -- Subtitle Stream --> SubtitleOverlayOrRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assume 'dataSourceBlock' is a source block providing MPEG-TS data
// For example, a UniversalSourceBlock reading a .ts file or an HTTP source.
// var dataSourceBlock = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("input.ts"));
// For this example, let's assume dataSourceBlock.Output provides the MPEG-TS stream.

var mpegTSDemuxSettings = new MPEGTSDemuxSettings();
// mpegTSDemuxSettings.ProgramNumber = 1; // Optionally select a specific program

// Create MPEG-TS Demuxer Block
// Constructor parameters control which streams to attempt to render
var mpegTSDemuxBlock = new MPEGTSDemuxBlock(
    renderVideo: true,
    renderAudio: true,
    renderSubtitle: true,
    renderMetadata: false);

// Connect the data source to the demuxer's input
// pipeline.Connect(dataSourceBlock.Output, mpegTSDemuxBlock.Input); // Assuming dataSourceBlock is defined

// Create renderers
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1 is your display control
var audioRenderer = new AudioRendererBlock();
// var subtitleRenderer = ... ; // A block to handle subtitle rendering or overlay

// Connect demuxer outputs
if (mpegTSDemuxBlock.VideoOutput != null)
{
    // The demuxer hands out encoded data, so a decoder goes between it and the renderer.
    var videoDecoder = new UniversalDecoderBlock(MediaBlockPadMediaType.Video);
    pipeline.Connect(mpegTSDemuxBlock.VideoOutput, videoDecoder.Input);
    pipeline.Connect(videoDecoder.Output, videoRenderer.Input);
}

if (mpegTSDemuxBlock.AudioOutput != null)
{
    // The demuxer hands out encoded data, so a decoder goes between it and the renderer.
    var audioDecoder = new UniversalDecoderBlock(MediaBlockPadMediaType.Audio);
    pipeline.Connect(mpegTSDemuxBlock.AudioOutput, audioDecoder.Input);
    pipeline.Connect(audioDecoder.Output, audioRenderer.Input);
}

if (mpegTSDemuxBlock.SubtitleOutput != null)
{
    // pipeline.Connect(mpegTSDemuxBlock.SubtitleOutput, subtitleRenderer.Input); // Connect to a subtitle handler
}

// Start pipeline
// await pipeline.StartAsync(); // Start once dataSourceBlock is connected
```

### Remarks

- Ensure that the input to `MPEGTSDemuxBlock` is raw MPEG-TS data. If you are using a `UniversalSourceBlock` with a `.ts` file, it might already demultiplex the stream. In such cases, `MPEGTSDemuxBlock` might be used if `UniversalSourceBlock` is configured to output the raw container stream or if the stream comes from a source like `SRTRAWSourceBlock`.
- The availability of video, audio, or subtitle outputs depends on the content of the MPEG-TS stream.

### Platforms

Windows, macOS, Linux, iOS, Android.

## QT Demux Block (MP4/MOV)

The `QTDemuxBlock` is designed to demultiplex QuickTime (QT) container formats, which include MP4 and MOV files. These formats are widely used for storing video, audio, and other multimedia content.

### Block info

Name: `QTDemuxBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | MP4/MOV Data | 1 |
| Output video | Depends on stream content | 0 or 1+ |
| Output audio | Depends on stream content | 0 or 1+ |
| Output subtitle | Depends on stream content | 0 or 1+ |
| Output metadata | Depends on stream content | 0 or 1+ |

### Settings

The `QTDemuxBlock` does not have specific settings class beyond the implicit configuration through its constructor parameters (`renderVideo`, `renderAudio`, etc.). The underlying GStreamer element `qtdemux` handles the demultiplexing automatically.

### The sample pipeline

This example shows how to connect a source block that outputs raw MP4/MOV data to `QTDemuxBlock`, and then connect its outputs to respective renderer blocks.

```
graph LR;
    DataSourceBlock -- MP4/MOV Data --> QTDemuxBlock;
    QTDemuxBlock -- Video Stream --> VideoDecoderBlock;
    VideoDecoderBlock -- Decoded Video --> VideoRendererBlock;
    QTDemuxBlock -- Audio Stream --> AudioDecoderBlock;
    AudioDecoderBlock -- Decoded Audio --> AudioRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assume 'dataSourceBlock' is a source block providing MP4/MOV data.
// This could be a StreamSourceBlock feeding raw MP4 data, or a custom source.
// For typical file playback, UniversalSourceBlock directly provides decoded streams.
// QTDemuxBlock is used when you have the container data and need to demux it within the pipeline.
// Example: var fileStream = File.OpenRead("myvideo.mp4");
// var streamSource = new StreamSourceBlock(fileStream); // StreamSourceBlock provides raw data

// Create QT Demuxer Block
// Constructor parameters control which streams to attempt to render
var qtDemuxBlock = new QTDemuxBlock(
    renderVideo: true,
    renderAudio: true,
    renderSubtitle: false,
    renderMetadata: false);

// Connect the data source to the demuxer's input
// pipeline.Connect(streamSource.Output, qtDemuxBlock.Input); // Assuming streamSource is defined

// Create renderers
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1
var audioRenderer = new AudioRendererBlock();

// Connect demuxer outputs
if (qtDemuxBlock.VideoOutput != null)
{
    // The demuxer hands out encoded data, so a decoder goes between it and the renderer.
    var videoDecoder = new UniversalDecoderBlock(MediaBlockPadMediaType.Video);
    pipeline.Connect(qtDemuxBlock.VideoOutput, videoDecoder.Input);
    pipeline.Connect(videoDecoder.Output, videoRenderer.Input);
}

if (qtDemuxBlock.AudioOutput != null)
{
    // The demuxer hands out encoded data, so a decoder goes between it and the renderer.
    var audioDecoder = new UniversalDecoderBlock(MediaBlockPadMediaType.Audio);
    pipeline.Connect(qtDemuxBlock.AudioOutput, audioDecoder.Input);
    pipeline.Connect(audioDecoder.Output, audioRenderer.Input);
}

// Start pipeline
// await pipeline.StartAsync(); // Start once dataSourceBlock is connected and pipeline is built
```

### Remarks

- `QTDemuxBlock` is typically used when you have a stream of MP4/MOV container data that needs to be demultiplexed within the pipeline (e.g., from a `StreamSourceBlock` or a custom data source).
- For playing local MP4/MOV files, `UniversalSourceBlock` is often more convenient as it handles both demuxing and decoding.
- The availability of outputs depends on the actual streams present in the MP4/MOV file.

### Platforms

Windows, macOS, Linux, iOS, Android.

## Universal Demux Block

The `UniversalDemuxBlock` provides a flexible way to demultiplex various media container formats based on provided settings or inferred from the input stream. It can handle formats like AVI, MKV, MP4, MPEG-TS, FLV, OGG, and WebM.

This block requires `MediaFileInfo` to be provided for proper initialization of its output pads, as the number and type of streams can vary greatly between files.

### Block info

Name: `UniversalDemuxBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Various Container Data | 1 |
| Output video | Depends on stream content and `renderVideo` flag | 0 to N |
| Output audio | Depends on stream content and `renderAudio` flag | 0 to N |
| Output subtitle | Depends on stream content and `renderSubtitle` flag | 0 to N |
| Output metadata | Depends on stream content and `renderMetadata` flag | 0 or 1 |

(N is the number of respective streams in the media file)

### Settings

The `UniversalDemuxBlock` is configured using an implementation of `IUniversalDemuxSettings`. The specific settings class depends on the container format you intend to demultiplex.

- `UniversalDemuxerType` (enum): Specifies the type of demuxer to use. Can be `Auto`, `MKV`, `MP4`, `AVI`, `MPEGTS`, `MPEGPS`, `FLV`, `OGG`, `WebM`.
- Based on the `UniversalDemuxerType`, you would create a corresponding settings object:
- `AVIDemuxSettings`
- `FLVDemuxSettings`
- `MKVDemuxSettings`
- `MP4DemuxSettings`
- `MPEGPSDemuxSettings`
- `MPEGTSDemuxSettings` (includes `Latency` and `ProgramNumber` properties)
- `OGGDemuxSettings`
- `WebMDemuxSettings`
- `UniversalDemuxSettings` (for `Auto` type)

The `UniversalDemuxerTypeHelper.CreateSettings(UniversalDemuxerType type)` method can be used to create the appropriate settings object.

### Constructor

`UniversalDemuxBlock(IUniversalDemuxSettings settings, MediaFileInfo info, bool renderVideo = true, bool renderAudio = true, bool renderSubtitle = false, bool renderMetadata = false)` `UniversalDemuxBlock(MediaFileInfo info, bool renderVideo = true, bool renderAudio = true, bool renderSubtitle = false, bool renderMetadata = false)` (uses `UniversalDemuxSettings` for auto type detection)

**Crucially, `MediaFileInfo` must be provided to the constructor.** This object, typically obtained by analyzing the media file beforehand (e.g., using `MediaInfoReader`), informs the block about the number and types of streams, allowing it to create the correct number of output pads.

### The sample pipeline

This example demonstrates using `UniversalDemuxBlock` to demultiplex a file. Note that a data source block providing the raw file data to the `UniversalDemuxBlock` is implied.

```
graph LR;
    DataSourceBlock -- Container Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- Video Stream 1 --> VideoDecoderBlock1;
    VideoDecoderBlock1 -- Decoded Video --> VideoRendererBlock1;
    UniversalDemuxBlock -- Audio Stream 1 --> AudioDecoderBlock1;
    AudioDecoderBlock1 -- Decoded Audio --> AudioRendererBlock1;
    UniversalDemuxBlock -- Subtitle Stream 1 --> SubtitleHandler1;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// 1. Obtain media info for your media file (cross-platform reader)
var mediaInfoReader = new MediaInfoReaderX();
if (!await mediaInfoReader.OpenAsync("path/to/your/video.mkv"))
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var mediaInfo = mediaInfoReader.Info;

// 2. Choose or create Demuxer Settings
// Example: Auto-detect demuxer type
IUniversalDemuxSettings demuxSettings = new UniversalDemuxSettings();
// Or, specify a type, e.g., for an MKV file:
// IUniversalDemuxSettings demuxSettings = new MKVDemuxSettings();
// Or, for MPEG-TS with specific program:
// var mpegTsSettings = new MPEGTSDemuxSettings { ProgramNumber = 1 };
// IUniversalDemuxSettings demuxSettings = mpegTsSettings;

// 3. Create UniversalDemuxBlock
var universalDemuxBlock = new UniversalDemuxBlock(
    demuxSettings,
    mediaInfo,
    renderVideo: true,  // Process video streams
    renderAudio: true,  // Process audio streams
    renderSubtitle: true // Process subtitle streams
    );

// 4. Connect a data source that provides the raw file stream to UniversalDemuxBlock's input.
// This step is crucial and depends on how you get the file data.
// For instance, using a FileSource configured to output raw data, or a StreamSourceBlock.
// Example with a hypothetical RawFileSourceBlock (not a standard block, for illustration):
// var rawFileSource = new RawFileSourceBlock("path/to/your/video.mkv");
// pipeline.Connect(rawFileSource.Output, universalDemuxBlock.Input);

// 5. Connect outputs
// Video outputs (MediaBlockPad[])
var videoOutputs = universalDemuxBlock.VideoOutputs;
if (videoOutputs.Length > 0)
{
    // Example: connect the first video stream
    var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1
    // The demuxer hands out encoded data, so a decoder goes between it and the renderer.
    var videoDecoder = new UniversalDecoderBlock(MediaBlockPadMediaType.Video);
    pipeline.Connect(videoOutputs[0], videoDecoder.Input);
    pipeline.Connect(videoDecoder.Output, videoRenderer.Input);
}

// Audio outputs (MediaBlockPad[])
var audioOutputs = universalDemuxBlock.AudioOutputs;
if (audioOutputs.Length > 0)
{
    // Example: connect the first audio stream
    var audioRenderer = new AudioRendererBlock();
    // The demuxer hands out encoded data, so a decoder goes between it and the renderer.
    var audioDecoder = new UniversalDecoderBlock(MediaBlockPadMediaType.Audio);
    pipeline.Connect(audioOutputs[0], audioDecoder.Input);
    pipeline.Connect(audioDecoder.Output, audioRenderer.Input);
}

// Subtitle outputs (MediaBlockPad[])
var subtitleOutputs = universalDemuxBlock.SubtitleOutputs;
if (subtitleOutputs.Length > 0)
{
    // Example: connect the first subtitle stream to a conceptual handler
    // var subtitleHandler = new MySubtitleHandlerBlock();
    // pipeline.Connect(subtitleOutputs[0], subtitleHandler.Input);
}

// Metadata output (if renderMetadata was true and metadata stream exists)
var metadataOutputs = universalDemuxBlock.MetadataOutputs;
if (metadataOutputs.Length > 0 && metadataOutputs[0] != null)
{
    // Handle metadata stream
}

// Start pipeline after all connections are made
// await pipeline.StartAsync();
```

### Remarks

- **`MediaFileInfo` is mandatory** for `UniversalDemuxBlock` to correctly initialize its output pads based on the streams present in the file.
- The `renderVideo`, `renderAudio`, and `renderSubtitle` flags in the constructor determine if outputs for these stream types will be created and processed. If set to `false`, respective streams will be ignored (or sent to internal null renderers if present in the file but not rendered).
- The `UniversalDemuxBlock` is powerful for scenarios where you need to explicitly manage the demuxing process for various formats or select specific streams from files with multiple tracks.
- For simple playback of common file formats, `UniversalSourceBlock` often provides a more straightforward solution as it integrates demuxing and decoding. `UniversalDemuxBlock` offers more granular control.

### Platforms

Windows, macOS, Linux, iOS, Android. (Platform support for specific formats may depend on underlying GStreamer plugins.)

## Universal Auto Demux Block

The `UniversalAutoDemuxerBlock` automatically detects the container format of the incoming stream and creates the appropriate demuxer on the fly. It uses GStreamer's `typefind` element to identify the media type and then instantiates the matching demuxer element dynamically, exposing the elementary streams (video, audio, subtitle, metadata) on its output pads.

Unlike `UniversalDemuxBlock`, this block does **not** require `MediaFileInfo` or an explicit settings object. The output pads are pre-created from the constructor flags, and the demuxer is selected at runtime once the format is detected. This makes it convenient for sources where the container type is unknown in advance. It supports all common container formats (MP4/MOV, MKV, WebM, AVI, MPEG-TS, MPEG-PS, FLV, OGG, ASF/WMV, WAV, FLAC, DV, and more).

### Block info

Name: `UniversalAutoDemuxerBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Various Container Data | 1 |
| Output video | Depends on stream content and `renderVideo` flag | 0 or 1 |
| Output audio | Depends on stream content and `renderAudio` flag | 0 or 1 |
| Output subtitle | Depends on stream content and `renderSubtitle` flag | 0 or 1 |
| Output metadata | Depends on stream content and `renderMetadata` flag | 0 or 1 |

### Constructor

`UniversalAutoDemuxerBlock(bool renderVideo = true, bool renderAudio = true, bool renderSubtitle = false, bool renderMetadata = false)`

The constructor flags determine which output pads are pre-created. There is no settings class - the demuxer is chosen automatically from the detected container format.

### The sample pipeline

This example shows how to connect a source block that provides raw container data to `UniversalAutoDemuxerBlock`, and then connect its outputs to renderer blocks. The container format does not need to be known beforehand.

```
graph LR;
    DataSourceBlock -- Container Data --> UniversalAutoDemuxerBlock;
    UniversalAutoDemuxerBlock -- Video Stream --> VideoDecoderBlock;
    VideoDecoderBlock -- Decoded Video --> VideoRendererBlock;
    UniversalAutoDemuxerBlock -- Audio Stream --> AudioDecoderBlock;
    AudioDecoderBlock -- Decoded Audio --> AudioRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assume 'dataSourceBlock' is a source block providing raw container data
// (e.g. a StreamSourceBlock or another block that outputs the container stream).
// The container format is detected automatically - no MediaFileInfo required.

// Create the auto demuxer block.
// Constructor flags control which output pads are created.
var autoDemuxBlock = new UniversalAutoDemuxerBlock(
    renderVideo: true,
    renderAudio: true,
    renderSubtitle: false,
    renderMetadata: false);

// Connect the data source to the demuxer's input.
// pipeline.Connect(dataSourceBlock.Output, autoDemuxBlock.Input);

// Create renderers.
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1
var audioRenderer = new AudioRendererBlock();

// Connect demuxer outputs (pads become linked once the format is detected).
if (autoDemuxBlock.VideoOutput != null)
{
    // The demuxer hands out encoded data, so a decoder goes between it and the renderer.
    var videoDecoder = new UniversalDecoderBlock(MediaBlockPadMediaType.Video);
    pipeline.Connect(autoDemuxBlock.VideoOutput, videoDecoder.Input);
    pipeline.Connect(videoDecoder.Output, videoRenderer.Input);
}

if (autoDemuxBlock.AudioOutput != null)
{
    // The demuxer hands out encoded data, so a decoder goes between it and the renderer.
    var audioDecoder = new UniversalDecoderBlock(MediaBlockPadMediaType.Audio);
    pipeline.Connect(autoDemuxBlock.AudioOutput, audioDecoder.Input);
    pipeline.Connect(audioDecoder.Output, audioRenderer.Input);
}

// Start pipeline once the data source is connected.
// await pipeline.StartAsync();
```

### Remarks

- No `MediaFileInfo` and no settings object are required - the container format is detected at runtime via `typefind`, and the matching demuxer is created dynamically.
- Output pads are pre-created from the constructor flags. Use the convenience pads `VideoOutput`, `AudioOutput`, and `SubtitleOutput`, or the `VideoOutputs`, `AudioOutputs`, `SubtitleOutputs`, and `MetadataOutputs` arrays.
- When a flag is `false`, the corresponding stream present in the container is discarded internally.
- Prefer `UniversalDemuxBlock` when you have already analyzed the file and need precise control over multiple streams of the same type. Prefer `UniversalAutoDemuxerBlock` when the container type is unknown in advance and one stream per type is sufficient. For simple playback of common file formats, `UniversalSourceBlock` integrates both demuxing and decoding.

### Platforms

Windows, macOS, Linux, iOS, Android. (Platform support for specific formats may depend on underlying GStreamer plugins.)

---END OF PAGE---


## ElevenLabs Text-to-Speech and Voice Cloning Blocks for .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/ElevenLabs/
**Description:** Add ElevenLabs cloud text-to-speech and real-time voice cloning to your C# .NET audio pipelines with the cross-platform Media Blocks SDK .NET.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, ElevenLabs, Text-to-Speech, Voice Cloning, AI, C#
**API:** ElevenLabsSynthesizerBlock, ElevenLabsSynthesizerSettings, ElevenLabsVoiceClonerBlock, ElevenLabsVoiceClonerSettings, ElevenLabsOverflow

# ElevenLabs Blocks

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Overview

The ElevenLabs blocks bring [ElevenLabs](https://elevenlabs.io/) AI audio directly into your [Media Blocks SDK .NET](https://www.visioforge.com/media-blocks-sdk-net) pipelines. Two cloud-backed blocks are available:

- [`ElevenLabsSynthesizerBlock`](#elevenlabs-synthesizer) — text-to-speech: takes text input and produces speech audio.
- [`ElevenLabsVoiceClonerBlock`](#elevenlabs-voice-cloner) — voice cloning: takes audio input and re-renders it in a cloned voice.

Both blocks call the ElevenLabs cloud API, so they require a valid **ElevenLabs API key** and network access. Get a key from the [ElevenLabs dashboard](https://elevenlabs.io/app). Each block exposes a static `IsAvailable()` method so you can verify the underlying GStreamer ElevenLabs plugin is present before creating an instance.

## ElevenLabs Synthesizer

The `ElevenLabsSynthesizerBlock` converts a text stream into spoken audio using the ElevenLabs text-to-speech API. It has a text input pad and an audio output pad, so you can route the synthesized speech into an encoder, a renderer, or a mixer.

Configure it with `ElevenLabsSynthesizerSettings`. The constructor takes the API key; the most common extra settings are the `VoiceId` (which ElevenLabs voice to use), the `ModelId`, and an optional ISO 639-1 `LanguageCode`.

### Block info

Name: ElevenLabsSynthesizerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | text | one |
| Output audio | audio/x-raw | one |

### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `ApiKey` | `string` | — | ElevenLabs API key (set via the constructor). |
| `VoiceId` | `string` | `"9BWtsMINqrJLrRacOk9x"` | ElevenLabs Voice ID. See the [voice library](https://elevenlabs.io/app/voice-library). |
| `ModelId` | `string` | `"eleven_flash_v2_5"` | ElevenLabs Model ID. |
| `LanguageCode` | `string` | `null` | Optional ISO 639-1 language code, useful with certain models. |
| `Latency` | `uint` | `2000` | Milliseconds of latency to allow ElevenLabs. |
| `MaxOverflow` | `uint` | `2000` | Milliseconds a text cue may overflow its duration (compress mode). |
| `MaxPreviousRequests` | `uint` | `0` | How many previous request IDs to track for continuity. |
| `Overflow` | `ElevenLabsOverflow` | `Clip` | How audio longer than the input text is handled: `Clip`, `Overlap`, or `Shift`. |
| `RetryWithSpeed` | `bool` | `true` | Retry with higher speed when synthesis produces a longer duration. |
| `UseVoiceIdEvents` | `bool` | `true` | Use received `elevenlabs/speaker-voice` events to pick the current voice. |

### The sample pipeline

```
graph LR;
    SubtitleSourceBlock-- text -->ElevenLabsSynthesizerBlock;
    ElevenLabsSynthesizerBlock-- audio -->AudioRendererBlock;
```

### Sample code

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AudioRendering;
using VisioForge.Core.MediaBlocks.ElevenLabs;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.Types.X.ElevenLabs;
using VisioForge.Core.Types.X.Sources;

var pipeline = new MediaBlocksPipeline();

// Text-to-speech settings. Replace with your ElevenLabs API key.
var ttsSettings = new ElevenLabsSynthesizerSettings("YOUR_ELEVENLABS_API_KEY")
{
    VoiceId = "9BWtsMINqrJLrRacOk9x",
    ModelId = "eleven_flash_v2_5",
    Overflow = ElevenLabsOverflow.Clip
};

var synthesizer = new ElevenLabsSynthesizerBlock(ttsSettings);

// Source of text to speak (e.g. a subtitle/text file).
var textSource = new SubtitleSourceBlock(new SubtitleSourceSettings("script.srt"));

// Render the synthesized speech to the default audio output device.
var audioRenderer = new AudioRendererBlock();

pipeline.Connect(textSource.Output, synthesizer.Input);
pipeline.Connect(synthesizer.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

## ElevenLabs Voice Cloner

The `ElevenLabsVoiceClonerBlock` takes an audio stream, clones the speaker's voice with the ElevenLabs API, and produces audio re-rendered in that cloned voice. It has an audio input pad and an audio output pad, so it slots into a pipeline between an audio source and a sink or encoder.

Configure it with `ElevenLabsVoiceClonerSettings`. The constructor takes the API key. By default the block asks ElevenLabs to remove background noise and stores 10 seconds of audio per voice update; set `Speaker` to treat all incoming audio as a single speaker and skip diarization.

### Block info

Name: ElevenLabsVoiceClonerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one |
| Output audio | audio/x-raw | one |

### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `ApiKey` | `string` | — | ElevenLabs API key (set via the constructor). |
| `RemoveBackgroundNoise` | `bool` | `true` | Ask ElevenLabs to remove background noise. |
| `SegmentDuration` | `uint` | `10000` | Milliseconds of audio to store before creating/updating a voice. |
| `Speaker` | `string` | `null` | Optional speaker name. When set, all audio is treated as one speaker (no diarization). |

### The sample pipeline

```
graph LR;
    SystemAudioSourceBlock-- audio -->ElevenLabsVoiceClonerBlock;
    ElevenLabsVoiceClonerBlock-- audio -->AudioRendererBlock;
```

### Sample code

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AudioRendering;
using VisioForge.Core.MediaBlocks.ElevenLabs;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.Types.X.ElevenLabs;

var pipeline = new MediaBlocksPipeline();

// Voice cloning settings. Replace with your ElevenLabs API key.
var clonerSettings = new ElevenLabsVoiceClonerSettings("YOUR_ELEVENLABS_API_KEY")
{
    RemoveBackgroundNoise = true,
    SegmentDuration = 10000,
    Speaker = "narrator"
};

var cloner = new ElevenLabsVoiceClonerBlock(clonerSettings);

// Audio source to clone (system audio capture in this example).
var audioSource = new SystemAudioSourceBlock();

// Render the cloned voice to the default audio output device.
var audioRenderer = new AudioRendererBlock();

pipeline.Connect(audioSource.Output, cloner.Input);
pipeline.Connect(cloner.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

## Availability

Call `ElevenLabsSynthesizerBlock.IsAvailable()` or `ElevenLabsVoiceClonerBlock.IsAvailable()` to verify the ElevenLabs blocks are available in the current environment before creating an instance.

## Platforms

Windows, macOS, Linux, iOS, Android.

---END OF PAGE---


## Build Camera Capture App - Device Setup Guide in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/GettingStarted/camera/
**Description:** Build camera apps with VisioForge Media Blocks SDK — device enumeration, format selection, video rendering, and cross-platform capture support.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Streaming, Webcam, C#
**API:** MediaBlocksPipeline, SystemVideoSourceBlock, VideoRendererBlock, DeviceEnumerator, VideoCaptureDeviceSourceSettings

# Building Camera Applications with Media Blocks SDK

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction

This comprehensive guide demonstrates how to create a fully functional camera viewing application using the Media Blocks SDK .Net. The SDK provides a robust framework for capturing, processing, and displaying video streams across multiple platforms including Windows, macOS, iOS, and Android.

## Architecture Overview

To create a camera viewer application, you'll need to understand two fundamental components:

1. **System Video Source** - Captures the video stream from connected camera devices
2. **Video Renderer** - Displays the captured video on screen with configurable settings

These components work together within a pipeline architecture that manages media processing.

## Essential Media Blocks

To build a camera application, you need to add the following blocks to your pipeline:

- **[System Video Source Block](../../Sources/)** - Connects to and reads from camera devices
- **[Video Renderer Block](../../VideoRendering/)** - Displays the video with configurable rendering options

## Setting Up the Pipeline

### Creating the Base Pipeline

First, create a pipeline object that will manage the media flow:

```
using VisioForge.Core.MediaBlocks;

// Initialize the pipeline
var pipeline = new MediaBlocksPipeline();

// Add error handling
pipeline.OnError += (sender, args) =>
{
    Console.WriteLine($"Pipeline error: {args.Message}");
};
```

### Camera Device Enumeration

Before adding a camera source, you need to enumerate the available devices and select one:

```
// Get all available video devices asynchronously
var videoDevices = await DeviceEnumerator.Shared.VideoSourcesAsync();

// Display available devices (useful for user selection)
foreach (var device in videoDevices)
{
    Console.WriteLine($"Device: {device.Name} [{device.API}]");
}

// Select the first available device
var selectedDevice = videoDevices[0];
```

### Camera Format Selection

Each camera supports different resolutions and frame rates. You can enumerate and select the optimal format:

```
// Display available formats for the selected device
foreach (var format in selectedDevice.VideoFormats)
{
    Console.WriteLine($"Format: {format.Width}x{format.Height} {format.Format}");

    // Display available frame rates for this format
    foreach (var frameRate in format.FrameRateList)
    {
        Console.WriteLine($"  Frame Rate: {frameRate}");
    }
}

// Select the optimal format (in this example, we look for HD resolution)
var hdFormat = selectedDevice.GetHDVideoFormatAndFrameRate(out var frameRate);
var formatToUse = hdFormat ?? selectedDevice.VideoFormats[0];
```

## Configuring Camera Settings

### Creating Source Settings

Configure the camera source settings with your selected device and format:

```
// Create camera settings with the selected device and format
var videoSourceSettings = new VideoCaptureDeviceSourceSettings(selectedDevice)
{
    Format = formatToUse.ToFormat()
};

// Set the desired frame rate (selecting the highest available)
if (formatToUse.FrameRateList.Count > 0)
{
    videoSourceSettings.Format.FrameRate = formatToUse.FrameRateList.Max();
}

// Optional: Enable force frame rate to maintain consistent timing
videoSourceSettings.Format.ForceFrameRate = true;

// Platform-specific settings
#if __ANDROID__
// Android-specific settings
videoSourceSettings.VideoStabilization = true;
#elif __IOS__ && !__MACCATALYST__
// iOS-specific settings
videoSourceSettings.Position = IOSVideoSourcePosition.Back;
videoSourceSettings.Orientation = IOSVideoSourceOrientation.Portrait;
#endif
```

### Creating the Video Source Block

Now create the system video source block with your configured settings:

```
// Create the video source block
var videoSource = new SystemVideoSourceBlock(videoSourceSettings);
```

## Setting Up Video Display

### Creating the Video Renderer

Add a video renderer to display the captured video:

```
// Create the video renderer and connect it to your UI component
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Optional: keep the renderer in sync with the pipeline clock
videoRenderer.IsSync = true;
```

### Advanced Renderer Configuration

`VideoRendererBlock` exposes a handful of flat properties — no nested `Settings` bag:

```
// Enable subtitle overlay if the pipeline carries a subtitle stream
videoRenderer.SubtitleEnabled = true;

// Disable clock-sync to get frames as fast as they arrive (useful for recording scenarios)
videoRenderer.IsSync = false;
```

## Connecting the Pipeline

Connect the video source to the renderer to establish the media flow:

```
// Connect the output of the video source to the input of the renderer
pipeline.Connect(videoSource.Output, videoRenderer.Input);
```

## Managing the Pipeline Lifecycle

### Starting the Pipeline

Start the pipeline to begin capturing and displaying video:

```
// Start the pipeline asynchronously
await pipeline.StartAsync();
```

### Taking Snapshots

Capture still images from the video stream:

```
// Take a snapshot and save it as a JPEG file
await videoRenderer.Snapshot_SaveAsync("camera_snapshot.jpg", SkiaSharp.SKEncodedImageFormat.Jpeg, 90);

// Or get the snapshot as a bitmap for further processing
var bitmap = await videoRenderer.Snapshot_GetAsync();
```

### Stopping the Pipeline

When finished, properly stop the pipeline:

```
// Stop the pipeline asynchronously
await pipeline.StopAsync();
```

## Platform-Specific Considerations

The Media Blocks SDK supports cross-platform development with specific optimizations:

- **Windows**: Supports both Media Foundation and Kernel Streaming APIs
- **macOS/iOS**: Utilizes AVFoundation for optimal performance
- **Android**: Provides access to camera features like stabilization and orientation

## Error Handling and Troubleshooting

Implement proper error handling to ensure a stable application:

```
try
{
    // Pipeline operations
    await pipeline.StartAsync();
}
catch (Exception ex)
{
    Console.WriteLine($"Error starting pipeline: {ex.Message}");
    // Handle the exception appropriately
}
```

## Complete Implementation Example

This example demonstrates a complete camera viewer implementation:

```
using System;
using System.Linq;
using System.Threading.Tasks;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.X.Sources;

public class CameraViewerExample
{
    private MediaBlocksPipeline _pipeline;
    private SystemVideoSourceBlock _videoSource;
    private VideoRendererBlock _videoRenderer;

    public async Task InitializeAsync(IVideoView videoView)
    {
        // Create pipeline
        _pipeline = new MediaBlocksPipeline();
        _pipeline.OnError += (s, e) => Console.WriteLine(e.Message);

        // Enumerate devices
        var devices = await DeviceEnumerator.Shared.VideoSourcesAsync();
        if (devices.Length == 0)
        {
            throw new Exception("No camera devices found");
        }

        // Select device and format
        var device = devices[0];
        var format = device.GetHDOrAnyVideoFormatAndFrameRate(out var frameRate);

        // Create settings
        var settings = new VideoCaptureDeviceSourceSettings(device);
        if (format != null)
        {
            settings.Format = format.ToFormat();
            if (frameRate != null && !frameRate.IsEmpty)
            {
                settings.Format.FrameRate = frameRate;
            }
        }

        // Create blocks
        _videoSource = new SystemVideoSourceBlock(settings);
        _videoRenderer = new VideoRendererBlock(_pipeline, videoView);

        // Build pipeline
        _pipeline.AddBlock(_videoSource);
        _pipeline.AddBlock(_videoRenderer);
        _pipeline.Connect(_videoSource.Output, _videoRenderer.Input);

        // Start pipeline
        await _pipeline.StartAsync();
    }

    public async Task StopAsync()
    {
        if (_pipeline != null)
        {
            await _pipeline.StopAsync();
            _pipeline.Dispose();
        }
    }

    public async Task<bool> TakeSnapshotAsync(string filename)
    {
        return await _videoRenderer.Snapshot_SaveAsync(filename,
            SkiaSharp.SKEncodedImageFormat.Jpeg, 90);
    }
}
```

## Conclusion

With Media Blocks SDK .Net, building powerful camera applications becomes straightforward. The component-based architecture provides flexibility and performance across platforms while abstracting the complexities of camera device integration.

For complete source code examples, please visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Simple%20Capture%20Demo).

---END OF PAGE---


## Media Device Enumeration in C# .NET - Complete Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/GettingStarted/device-enum/
**Description:** List cameras, microphones, speakers, Decklink, NDI, and GenICam devices using VisioForge Media Blocks SDK with cross-platform code examples.
**Tags:** Media Blocks SDK, .NET, DirectShow, Windows, macOS, Linux, Android, iOS, Decklink, NDI Source, USB3 Vision / GigE, ONVIF, NDI, C#
**API:** DeviceEnumerator, VideoCaptureDeviceInfo, AudioCaptureDeviceAPI

# Complete Guide to Media Device Enumeration in .NET

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Media Blocks SDK provides a powerful and efficient way to discover and work with various media devices in your .NET applications. This guide will walk you through the process of enumerating different types of media devices using the SDK's `DeviceEnumerator` class.

## Introduction to Device Enumeration

Device enumeration is a critical first step when developing applications that interact with media hardware. The `DeviceEnumerator` class provides a centralized way to detect and list all available media devices connected to your system.

The SDK uses a singleton pattern for device enumeration, making it easy to access the functionality from anywhere in your code:

```
// Access the shared DeviceEnumerator instance
var enumerator = DeviceEnumerator.Shared;
```

## Discovering Video Input Devices

### Standard Video Sources

To list all available video input devices (webcams, capture cards, virtual cameras):

```
var videoSources = await DeviceEnumerator.Shared.VideoSourcesAsync();

foreach (var device in videoSources)
{
    Debug.WriteLine($"Video device found: {device.Name}");
    // You can access additional properties here if needed
}
```

The `VideoCaptureDeviceInfo` objects returned provide detailed information about each device, including device name, internal identifiers, and API type.

## Working with Audio Devices

### Enumerating Audio Input Sources

To discover microphones and other audio input devices:

```
var audioSources = await DeviceEnumerator.Shared.AudioSourcesAsync();

foreach (var device in audioSources)
{
    Debug.WriteLine($"Audio input device found: {device.Name}");
    // Additional device information can be accessed here
}
```

You can also filter audio devices by their API type:

```
// Get only audio sources for a specific API
var audioSources = await DeviceEnumerator.Shared.AudioSourcesAsync(AudioCaptureDeviceAPI.DirectSound);
```

### Finding Audio Output Devices

For speakers, headphones, and other audio output destinations:

```
var audioOutputs = await DeviceEnumerator.Shared.AudioOutputsAsync();

foreach (var device in audioOutputs)
{
    Debug.WriteLine($"Audio output device found: {device.Name}");
    // Process device information as needed
}
```

Similar to audio sources, you can filter outputs by API:

```
// Get only audio outputs for a specific API
var audioOutputs = await DeviceEnumerator.Shared.AudioOutputsAsync(AudioOutputDeviceAPI.DirectSound);
```

## Professional Blackmagic Decklink Integration

### Decklink Video Input Sources

For professional video workflows using Blackmagic hardware:

```
var decklinkVideoSources = await DeviceEnumerator.Shared.DecklinkVideoSourcesAsync();

foreach (var device in decklinkVideoSources)
{
    Debug.WriteLine($"Decklink video input: {device.Name}");
    // You can work with specific Decklink properties here
}
```

### Decklink Audio Input Sources

To access audio channels from Decklink devices:

```
var decklinkAudioSources = await DeviceEnumerator.Shared.DecklinkAudioSourcesAsync();

foreach (var device in decklinkAudioSources)
{
    Debug.WriteLine($"Decklink audio input: {device.Name}");
    // Process Decklink audio device information
}
```

### Decklink Video Output Destinations

For sending video to Decklink output devices:

```
var decklinkVideoOutputs = await DeviceEnumerator.Shared.DecklinkVideoSinksAsync();

foreach (var device in decklinkVideoOutputs)
{
    Debug.WriteLine($"Decklink video output: {device.Name}");
    // Access output device properties as needed
}
```

### Decklink Audio Output Destinations

For routing audio to Decklink hardware outputs:

```
var decklinkAudioOutputs = await DeviceEnumerator.Shared.DecklinkAudioSinksAsync();

foreach (var device in decklinkAudioOutputs)
{
    Debug.WriteLine($"Decklink audio output: {device.Name}");
    // Work with audio output configuration here
}
```

## Network Device Integration

### NDI Sources Discovery

To find NDI sources available on your network:

```
var ndiSources = await DeviceEnumerator.Shared.NDISourcesAsync();

foreach (var device in ndiSources)
{
    Debug.WriteLine($"NDI source discovered: {device.Name}");
    // Process NDI-specific properties and information
}
```

### ONVIF Network Camera Discovery

To find IP cameras supporting the ONVIF protocol:

```
// Set a timeout for discovery (2 seconds in this example)
var timeout = TimeSpan.FromSeconds(2);
var onvifDevices = await DeviceEnumerator.Shared.ONVIF_ListSourcesAsync(timeout, null);

foreach (var deviceUri in onvifDevices)
{
    Debug.WriteLine($"ONVIF camera found at: {deviceUri}");
    // Connect to the camera using the discovered URI
}
```

## Industrial Camera Support

### Basler Industrial Cameras

For applications requiring Basler industrial cameras:

```
var baslerCameras = await DeviceEnumerator.Shared.BaslerSourcesAsync();

foreach (var device in baslerCameras)
{
    Debug.WriteLine($"Basler camera detected: {device.Name}");
    // Access Basler-specific camera features
}
```

### Allied Vision Industrial Cameras

To work with Allied Vision cameras in your application:

```
var alliedCameras = await DeviceEnumerator.Shared.AlliedVisionSourcesAsync();

foreach (var device in alliedCameras)
{
    Debug.WriteLine($"Allied Vision camera found: {device.Name}");
    // Configure Allied Vision specific parameters
}
```

### Spinnaker SDK Compatible Cameras

For cameras supporting the Spinnaker SDK (Windows only):

```
#if NET_WINDOWS
var spinnakerCameras = await DeviceEnumerator.Shared.SpinnakerSourcesAsync();

foreach (var device in spinnakerCameras)
{
    Debug.WriteLine($"Spinnaker SDK camera: {device.Name}");
    Debug.WriteLine($"Model: {device.Model}, Vendor: {device.Vendor}");
    Debug.WriteLine($"Resolution: {device.WidthMax}x{device.HeightMax}");
    // Work with camera-specific properties
}
#endif
```

### Generic GenICam Standard Cameras

For other industrial cameras supporting the GenICam standard:

```
var genicamCameras = await DeviceEnumerator.Shared.GenICamSourcesAsync();

foreach (var device in genicamCameras)
{
    Debug.WriteLine($"GenICam compatible device: {device.Name}");
    Debug.WriteLine($"Model: {device.Model}, Vendor: {device.Vendor}");
    Debug.WriteLine($"Protocol: {device.Protocol}, Serial: {device.SerialNumber}");
    // Work with standard GenICam features
}
```

## Device Monitoring

The SDK also supports monitoring device connections and disconnections:

```
// Start monitoring for video device changes
await DeviceEnumerator.Shared.StartVideoSourceMonitorAsync();

// Start monitoring for audio device changes
await DeviceEnumerator.Shared.StartAudioSourceMonitorAsync();
await DeviceEnumerator.Shared.StartAudioSinkMonitorAsync();

// Subscribe to device change events
DeviceEnumerator.Shared.OnVideoSourceAdded += (sender, device) =>
{
    Debug.WriteLine($"New video device connected: {device.Name}");
};

DeviceEnumerator.Shared.OnVideoSourceRemoved += (sender, device) =>
{
    Debug.WriteLine($"Video device disconnected: {device.Name}");
};
```

### Knowing when the first enumeration finished

Starting a monitor fills the device list from the notifications the platform sends, so a UI can start one without waiting for it and show its own "enumerating..." state instead. `OnDeviceEnumerationCompleted` says when that first pass is done:

```
DeviceEnumerator.Shared.OnDeviceEnumerationCompleted += (sender, e) =>
{
    // e.Kind is VideoSources, AudioSources or AudioOutputs.
    Debug.WriteLine($"{e.Kind} enumeration finished");
};

// Not awaited: the list fills through OnVideoSourceAdded while the UI stays responsive.
_ = DeviceEnumerator.Shared.StartVideoSourceMonitorAsync();
```

On macOS this matters on the first run of an application: the camera and microphone permission dialogs are answered by the user, and the enumeration completes only once they have been.

On Android there is no video source monitor to start, so only `AudioSources` and `AudioOutputs` are reported there.

## Platform-Specific Considerations

### Windows

On Windows, the SDK can detect USB device connection and removal events at the system level:

```
#if NET_WINDOWS
// Subscribe to system-wide device events
DeviceEnumerator.Shared.OnDeviceAdded += (sender, args) =>
{
    // Refresh device lists when new hardware is connected
    RefreshDeviceLists();
};

DeviceEnumerator.Shared.OnDeviceRemoved += (sender, args) =>
{
    // Update UI when hardware is disconnected
    RefreshDeviceLists();
};
#endif
```

By default, Media Foundation device enumeration is disabled to avoid duplication with DirectShow devices. You can enable it if needed:

```
#if NET_WINDOWS
// Enable Media Foundation device enumeration if required
DeviceEnumerator.Shared.IsEnumerateMediaFoundationDevices = true;
#endif
```

### macOS and Mac Catalyst

Enumerating devices asks for camera and microphone access, and starting the audio device provider waits behind that prompt. The app bundle must therefore declare both usage descriptions in its `Info.plist`, or the system terminates the process the first time access is requested — it does not merely deny it:

```
<key>NSCameraUsageDescription</key>
<string>Why your app needs the camera.</string>
<key>NSMicrophoneUsageDescription</key>
<string>Why your app needs the microphone.</string>
```

Prefer the asynchronous methods here: the synchronous `AudioSources()` / `AudioOutputs()` start the CoreAudio device provider and can block the calling thread until the user has answered the prompt.

### iOS and Android

On mobile platforms, the SDK handles the required permission requests when enumerating devices:

```
#if __IOS__ || __ANDROID__
// This will automatically request camera permissions if needed
var videoSources = await DeviceEnumerator.Shared.VideoSourcesAsync();

// This will automatically request microphone permissions if needed
var audioSources = await DeviceEnumerator.Shared.AudioSourcesAsync();
#endif
```

## Best Practices for Device Enumeration

When working with device enumeration in production applications:

1. Always handle cases where no devices are found
2. Consider caching device lists when appropriate to improve performance
3. Implement proper exception handling for device access failures
4. Provide clear user feedback when required devices are missing
5. Use the async methods to avoid blocking the UI thread during enumeration
6. Clean up resources by calling `Dispose()` when you're done with the DeviceEnumerator

```
// Proper cleanup when done
DeviceEnumerator.Shared.Dispose();
```

---END OF PAGE---


## Media Pipeline Quick Start - Install and Setup in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/GettingStarted/
**Description:** Get started with VisioForge Media Blocks SDK — installation, pipeline architecture, block connections, and multimedia processing tutorials.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming
**API:** MediaBlocksPipeline, IMediaBlock, MediaBlockPad, IMediaBlocksPipeline, MediaBlock

# Media Blocks SDK .Net - Developer Quick Start Guide

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction

This guide provides a comprehensive walkthrough for integrating the Media Blocks SDK .Net into your applications. The SDK is built around a modular pipeline architecture, enabling you to create, connect, and manage multimedia processing blocks for video, audio, and more. Whether you're building video processing tools, streaming solutions, or multimedia applications, this guide will help you get started quickly and correctly.

## SDK Installation Process

The SDK is distributed as a NuGet package for easy integration into your .Net projects. Install it using:

```
dotnet add package VisioForge.DotNet.MediaBlocks
```

For platform-specific requirements and additional installation details, refer to the [detailed installation guide](../../install/).

## Core Concepts and Architecture

### MediaBlocksPipeline

- The central class for managing the flow of media data between processing blocks.
- Handles block addition, connection, state management, and event handling.
- Implements `IMediaBlocksPipeline` and exposes events such as `OnError`, `OnStart`, `OnPause`, `OnResume`, `OnStop`, and `OnLoop`.

### MediaBlock and Interfaces

- Each processing unit is a `MediaBlock` (or a derived class), implementing the `IMediaBlock` interface.
- Key interfaces:
- `IMediaBlock`: Base interface for all blocks. Defines properties for `Name`, `Type`, `Input`, `Inputs`, `Output`, `Outputs`, and methods for pipeline context and YAML export.
- `IMediaBlockDynamicInputs`: For blocks that support dynamic input creation (e.g., mixers).
- `IMediaBlockInternals`/`IMediaBlockInternals2`: For internal pipeline management, building, and post-connection logic.
- `IMediaBlockRenderer`: For blocks that render media (e.g., video/audio renderers), with a property to control stream synchronization.
- `IMediaBlockSink`/`IMediaBlockSource`: For blocks that act as sinks (outputs) or sources (inputs).
- `IMediaBlockSettings`: For settings objects that can create blocks.

### Pads and Media Types

- Blocks are connected via `MediaBlockPad` objects, which have a direction (`In`/`Out`) and a media type (`Video`, `Audio`, `Subtitle`, `Metadata`, `Auto`).
- Pads can be connected/disconnected, and their state can be queried.

### Block Types

- The SDK provides a wide range of built-in block types (see `MediaBlockType` enum in the source code) for sources, sinks, renderers, effects, and more.

## Creating and Managing a Pipeline

### 1. Initialize the SDK (if required)

```
using VisioForge.Core;

// Initialize the SDK at application startup
VisioForgeX.InitSDK();
```

### 2. Create a Pipeline and Blocks

```
using VisioForge.Core.MediaBlocks;

// Create a new pipeline instance
var pipeline = new MediaBlocksPipeline();

// Example: Create a virtual video source and a video renderer
var virtualSource = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // VideoView1 is your UI control

// Add blocks to the pipeline
pipeline.AddBlock(virtualSource);
pipeline.AddBlock(videoRenderer);
```

### 3. Connect Blocks

```
// Connect the output of the source to the input of the renderer
pipeline.Connect(virtualSource.Output, videoRenderer.Input);
```

- You can also use `pipeline.Connect(sourceBlock, targetBlock)` to connect default pads, or connect multiple pads for complex graphs.
- For blocks supporting dynamic inputs, use the `IMediaBlockDynamicInputs` interface.

### 4. Start and Stop the Pipeline

```
// Start the pipeline asynchronously
await pipeline.StartAsync();

// ... later, stop processing
await pipeline.StopAsync();
```

### 5. Resource Cleanup

```
// Dispose of the pipeline when done
pipeline.Dispose();
```

### 6. SDK Cleanup (if required)

```
// Release all SDK resources at application shutdown
VisioForgeX.DestroySDK();
```

## Error Handling and Events

- Subscribe to pipeline events for robust error and state management:

```
pipeline.OnError += (sender, args) =>
{
    Console.WriteLine($"Pipeline error: {args.Message}");
    // Implement your error handling logic here
};

pipeline.OnStart += (sender, args) =>
{
    Console.WriteLine("Pipeline started");
};

pipeline.OnStop += (sender, args) =>
{
    Console.WriteLine("Pipeline stopped");
};
```

## Advanced Features

- **Dynamic Block Addition/Removal:** You can add or remove blocks at runtime as needed.
- **Pad Management:** Use `MediaBlockPad` methods to query and manage pad connections.
- **Hardware/Software Decoder Selection:** Use helper methods in `MediaBlocksPipeline` for hardware acceleration.
- **Segment Playback:** Set `StartPosition` and `StopPosition` properties for partial playback.
- **Debugging:** Export pipeline graphs for debugging using provided methods.

## Example: Minimal Pipeline Setup

```
using VisioForge.Core.MediaBlocks;

var pipeline = new MediaBlocksPipeline();
var source = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());
var renderer = new VideoRendererBlock(pipeline, videoViewControl);

pipeline.AddBlock(source);
pipeline.AddBlock(renderer);
pipeline.Connect(source.Output, renderer.Input);
await pipeline.StartAsync();
// ...
await pipeline.StopAsync();
pipeline.Dispose();
```

## Reference: Key Interfaces

- `IMediaBlock`: Base interface for all blocks.
- `IMediaBlockDynamicInputs`: For blocks with dynamic input support.
- `IMediaBlockInternals`, `IMediaBlockInternals2`: For internal pipeline logic.
- `IMediaBlockRenderer`: For renderer blocks.
- `IMediaBlockSink`, `IMediaBlockSource`: For sink/source blocks.
- `IMediaBlockSettings`: For block settings objects.
- `IMediaBlocksPipeline`: Main pipeline interface.
- `MediaBlockPad`, `MediaBlockPadDirection`, `MediaBlockPadMediaType`: For pad management.

## Further Reading and Samples

- [Complete Pipeline Implementation](pipeline/)
- [Media Player Development Guide](player/)
- [Camera Viewer Application Tutorial](camera/)
- [GitHub repository with code samples](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK)

For a full list of block types and advanced usage, consult the SDK API reference and source code.

---END OF PAGE---


## Media Pipeline Architecture and Block Connections in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/GettingStarted/pipeline/
**Description:** Create media pipelines for playback, recording, and streaming with modular blocks and resource management in VisioForge Media Blocks SDK.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Streaming, Recording, Encoding, MP4, C#
**API:** MediaBlocksPipeline, MediaBlockPadMediaType, IMediaBlock, MP4SinkBlock, MediaBlockType

# Media Blocks Pipeline: Core Functionality

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Overview of Pipeline and Block Structure

The Media Blocks SDK is built around the `MediaBlocksPipeline` class, which manages a collection of modular processing blocks. Each block implements the `IMediaBlock` interface or one of its specialized variants. Blocks are connected via input and output pads, allowing for flexible media processing chains.

### Main Block Interfaces

- **IMediaBlock**: Base interface for all blocks. Exposes properties for name, type, input/output pads, and methods for YAML conversion and pipeline context retrieval.
- **IMediaBlockDynamicInputs**: For blocks (like muxers) that can create new inputs dynamically. Methods: `CreateNewInput(mediaType)` and `GetInput(mediaType)`.
- **IMediaBlockInternals**: Internal methods for pipeline integration (e.g., `SetContext`, `Build`, `CleanUp`, `GetElement`, `GetCore`).
- **IMediaBlockInternals2**: For post-connection logic (`PostConnect()`).
- **IMediaBlockRenderer**: For renderer blocks, exposes `IsSync` property.
- **IMediaBlockSettings**: For settings/configuration objects that can create a block (`CreateBlock()`).
- **IMediaBlockSink**: For sink blocks, exposes filename/URL getter/setter.
- **IMediaBlockSource**: For source blocks (currently only commented-out pad accessors).

### Pads and Media Types

- **MediaBlockPad**: Represents a connection point (input/output) on a block. Has direction (`In`/`Out`), media type (`Video`, `Audio`, `Subtitle`, `Metadata`, `Auto`), and connection logic.
- **Pad connection**: Use `pipeline.Connect(outputPad, inputPad)` or `pipeline.Connect(block1.Output, block2.Input)`. For dynamic inputs, use `CreateNewInput()` on the sink block.

## Setting Up Your Pipeline Environment

### Creating a New Pipeline Instance

The first step in working with Media Blocks is instantiating a pipeline object:

```
using VisioForge.Core.MediaBlocks;

// Create a standard pipeline instance
var pipeline = new MediaBlocksPipeline();

// Optionally, you can assign a name to your pipeline for easier identification
pipeline.Name = "MainVideoPlayer";
```

### Implementing Robust Error Handling

Media applications must handle various error scenarios that may occur during operation. Implementing proper error handling ensures your application remains stable:

```
// Subscribe to error events to capture and handle exceptions
pipeline.OnError += (sender, args) =>
{
    // Log the error message
    Debug.WriteLine($"Pipeline error occurred: {args.Message}");

    // Implement appropriate error recovery based on the message
    if (args.Message.Contains("Access denied"))
    {
        // Handle permission issues
    }
    else if (args.Message.Contains("File not found"))
    {
        // Handle missing file errors
    }
};
```

## Managing Media Timing and Navigation

### Retrieving Duration and Position Information

Accurate timing control is essential for media applications:

```
// Get the total duration of the media (returns TimeSpan.Zero for live streams)
var duration = await pipeline.DurationAsync();
Console.WriteLine($"Media duration: {duration.TotalSeconds} seconds");

// Get the current playback position
var position = await pipeline.Position_GetAsync();
Console.WriteLine($"Current position: {position.TotalSeconds} seconds");
```

### Implementing Seeking Functionality

Enable your users to navigate through media content with seeking operations:

```
// Basic seeking to a specific time position
await pipeline.Position_SetAsync(TimeSpan.FromSeconds(10));

// Seeking with keyframe alignment for more efficient navigation
await pipeline.Position_SetAsync(TimeSpan.FromMinutes(2), seekToKeyframe: true);

// Read the current position back (e.g. for a progress bar)
var current = await pipeline.Position_GetAsync();
```

## Controlling Pipeline Execution Flow

### Starting Media Playback

Control the playback of media with these essential methods:

```
// Start playback immediately
await pipeline.StartAsync();

// Preload media without starting playback (useful for reducing startup delay)
await pipeline.StartAsync(onlyPreload: true);
await pipeline.ResumeAsync(); // Start the preloaded pipeline when ready
```

### Managing Playback States

Monitor and control the pipeline's current execution state:

```
// Check the current state of the pipeline
var state = pipeline.State;
if (state == PlaybackState.Play)
{
    Console.WriteLine("Pipeline is currently playing");
}

// Subscribe to important state change events
pipeline.OnStart += (sender, args) =>
{
    Console.WriteLine("Pipeline playback has started");
    UpdateUIForPlaybackState();
};

pipeline.OnStop += (sender, args) =>
{
    Console.WriteLine("Pipeline playback has stopped");
    Console.WriteLine($"Stopped at position: {args.Position.TotalSeconds} seconds");
    ResetPlaybackControls();
};

pipeline.OnPause += (sender, args) =>
{
    Console.WriteLine("Pipeline playback is paused");
    UpdatePauseButtonState();
};

pipeline.OnResume += (sender, args) =>
{
    Console.WriteLine("Pipeline playback has resumed");
    UpdatePlayButtonState();
};
```

### Pausing and Resuming Operations

Implement pause and resume functionality for better user experience:

```
// Pause the current playback
await pipeline.PauseAsync();

// Resume playback from paused state
await pipeline.ResumeAsync();
```

### Stopping Pipeline Execution

Properly terminate pipeline operations:

```
// Standard stop operation
await pipeline.StopAsync();

// Force stop in time-sensitive scenarios (may affect output file integrity)
await pipeline.StopAsync(force: true);
```

## Building Media Processing Chains

### Connecting Media Processing Blocks

The true power of the Media Blocks SDK comes from connecting specialized blocks to create processing chains:

```
// Basic connection between two blocks
pipeline.Connect(block1.Output, block2.Input);

// Connect blocks with specific media types
pipeline.Connect(videoSource.GetOutputPadByType(MediaBlockPadMediaType.Video),
                 videoEncoder.GetInputPadByType(MediaBlockPadMediaType.Video));
```

Different blocks may have multiple specialized inputs and outputs:

- Standard I/O: `Input` and `Output` properties
- Media-specific I/O: `VideoOutput`, `AudioOutput`, `VideoInput`, `AudioInput`
- Arrays of I/O: `Inputs[]` and `Outputs[]` for complex blocks

### Working with Dynamic Input Blocks

Some advanced sink blocks dynamically create inputs on demand:

```
// Create a specialized MP4 muxer for recording — ctor takes the output filename (or MP4SinkSettings)
var mp4Muxer = new MP4SinkBlock("output_recording.mp4");

// Request a new video input from the muxer
var videoInput = mp4Muxer.CreateNewInput(MediaBlockPadMediaType.Video);

// Connect a video source to the newly created input
pipeline.Connect(videoSource.Output, videoInput);

// Similarly for audio
var audioInput = mp4Muxer.CreateNewInput(MediaBlockPadMediaType.Audio);
pipeline.Connect(audioSource.Output, audioInput);
```

This flexibility enables complex media processing scenarios with multiple input streams.

## Proper Resource Management

### Disposing Pipeline Resources

Media applications can consume significant system resources. Always properly dispose of pipeline objects:

```
// Synchronous disposal pattern
try
{
    // Use pipeline
}
finally
{
    pipeline.Dispose();
}
```

For modern applications, use the asynchronous pattern to prevent UI freezing:

```
// Asynchronous disposal (preferred for UI applications)
try
{
    // Use pipeline
}
finally
{
    await pipeline.DisposeAsync();
}
```

### Using 'using' Statements for Automatic Cleanup

Leverage C# language features for automatic resource management:

```
// Automatic disposal with 'using' statement
using (var pipeline = new MediaBlocksPipeline())
{
    // Configure and use pipeline
    await pipeline.StartAsync();
    // Pipeline will be automatically disposed when exiting this block
}

// C# 8.0+ using declaration
using var pipeline = new MediaBlocksPipeline();
// Pipeline will be disposed when the containing method exits
```

## Advanced Pipeline Features

### Playback Rate Control

Adjust playback speed for slow-motion or fast-forward effects:

```
// Get current playback rate
double currentRate = await pipeline.Rate_GetAsync();

// Set playback rate (1.0 is normal speed)
await pipeline.Rate_SetAsync(0.5);  // Slow motion (half speed)
await pipeline.Rate_SetAsync(2.0);  // Double speed
```

### Loop Playback Configuration

Implement continuous playback functionality:

```
// Enable looping for continuous playback
pipeline.Loop = true;

// Listen for loop events
pipeline.OnLoop += (sender, args) =>
{
    Console.WriteLine("Media has looped back to start");
    UpdateLoopCounter();
};
```

### Debug Mode for Development

Enable debugging features during development:

```
// Enable debug mode for more detailed logging
pipeline.Debug_Mode = true;
pipeline.Debug_Dir = Path.Combine(Environment.GetFolderPath(
    Environment.SpecialFolder.MyDocuments), "PipelineDebugLogs");
```

## Block Types Reference

The SDK provides a wide range of block types for sources, processing, and sinks. See the `MediaBlockType` enum in the source code for a full list of available block types.

## Notes

- The pipeline supports both synchronous and asynchronous methods for starting, stopping, and disposing. Prefer asynchronous methods in UI or long-running applications.
- Events are available for error handling, state changes, and stream information.
- Use the correct interface for each block type to access specialized features (e.g., dynamic inputs, rendering, settings).

---END OF PAGE---


## Build a Video Player in C# .NET — Step-by-Step Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/GettingStarted/player/
**Description:** Step-by-step C# tutorial for building a video player with VisioForge Media Blocks SDK — source blocks, audio/video rendering, and playback controls.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, C#
**API:** MediaBlocksPipeline, UniversalSourceSettings, UniversalSourceBlock, VideoRendererBlock, DeviceEnumerator

# Building a Feature-Rich Video Player with Media Blocks SDK

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

This detailed tutorial walks you through the process of creating a professional-grade video player application using Media Blocks SDK .Net. By following these instructions, you'll understand how to implement key functionalities including media loading, playback control, and audio-video rendering.

## Essential Components for Your Player Application

To construct a fully functional video player, your application pipeline requires these critical building blocks:

- [Universal source](../../Sources/) - This versatile component handles media input from various sources, allowing your player to read and process video files from local storage or network streams.
- [Video renderer](../../VideoRendering/) - The visual component responsible for displaying video frames on screen with proper timing and formatting.
- [Audio renderer](../../AudioRendering/) - Manages sound output, ensuring synchronized audio playback alongside your video content.

## Setting Up the Media Pipeline

### Creating the Foundation

The first step in developing your player involves establishing the media pipeline—the core framework that manages data flow between components.

```
using VisioForge.Core.MediaBlocks;

var pipeline = new MediaBlocksPipeline();
```

### Implementing Error Handling

Robust error management is essential for a reliable player application. Subscribe to the pipeline's error events to capture and respond to exceptions.

```
pipeline.OnError += (sender, args) =>
{
    Console.WriteLine(args.Message);
    // Additional error handling logic can be implemented here
};
```

### Setting Up Event Listeners

For complete control over your player's lifecycle, implement event handlers for critical state changes:

```
pipeline.OnStart += (sender, args) =>
{
    // Execute code when pipeline starts
    Console.WriteLine("Playback started");
};

pipeline.OnStop += (sender, args) =>
{
    // Execute code when pipeline stops
    Console.WriteLine("Playback stopped");
};
```

## Configuring Media Blocks

### Initializing the Source Block

The Universal Source Block serves as the entry point for media content. Configure it with the path to your media file:

```
var sourceSettings = await UniversalSourceSettings.CreateAsync(filePath);
var fileSource = new UniversalSourceBlock(sourceSettings);
```

During initialization, the SDK automatically analyzes the file to extract crucial metadata about video and audio streams, enabling proper configuration of downstream components.

### Setting Up Video Display

To render video content on screen, create and configure a Video Renderer Block:

```
var videoRenderer = new VideoRendererBlock(_pipeline, VideoView1);
```

The renderer requires two parameters: a reference to your pipeline and the UI control where video frames will be displayed.

### Configuring Audio Output

For audio playback, you'll need to select and initialize an appropriate audio output device:

```
var audioRenderers = await DeviceEnumerator.Shared.AudioOutputsAsync();
var audioRenderer = new AudioRendererBlock(audioRenderers[0]);
```

This code retrieves available audio output devices and configures the first available option for playback.

## Establishing Component Connections

Once all blocks are configured, you must establish connections between them to create a cohesive media flow:

```
pipeline.Connect(fileSource.VideoOutput, videoRenderer.Input);
pipeline.Connect(fileSource.AudioOutput, audioRenderer.Input);
```

These connections define the path data takes through your application:

- Video data flows from the source to the video renderer
- Audio data flows from the source to the audio renderer

For files containing only video or audio, you can selectively connect only the relevant outputs.

### Validating Media Content

Before playback, you can inspect available streams using the Universal Source Settings:

```
var mediaInfo = await sourceSettings.ReadInfoAsync();
bool hasVideo = mediaInfo.VideoStreams.Count > 0;
bool hasAudio = mediaInfo.AudioStreams.Count > 0;
```

## Controlling Media Playback

### Starting Playback

To begin media playback, call the pipeline's asynchronous start method:

```
await pipeline.StartAsync();
```

Once executed, your application will begin rendering video frames and playing audio through the configured outputs.

### Managing Playback State

To halt playback, invoke the pipeline's stop method:

```
await pipeline.StopAsync();
```

This gracefully terminates all media processing and releases associated resources.

## Advanced Implementation

For a complete implementation example with additional features like seeking, volume control, and full-screen support, refer to our comprehensive source code on [GitHub](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Simple%20Player%20Demo%20WPF).

The repository contains working demonstrations for various platforms including WPF, Windows Forms, and cross-platform .NET applications.

## See Also

- [C# Video Player (WinForms / WPF)](../../../mediaplayer/guides/video-player-csharp/) — the Media Player SDK alternative with one-line setup for Windows desktop apps
- [Avalonia Cross-Platform Player](../../../mediaplayer/guides/avalonia-player/) — the same pipeline approach for Windows, macOS, and Linux desktop targets
- [.NET MAUI Player](../../../mediaplayer/guides/maui-player/) — mobile + desktop from one codebase (iOS, Android, macOS, Windows)

---END OF PAGE---


## Write Audio Metadata Tags in C# .NET - ID3, Vorbis
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/audio-metadata-tags/
**Description:** Add ID3, Vorbis Comments, and MP4 metadata to audio files using VisioForge Media Blocks SDK. Code examples for MP3, OGG, M4A, and WMA tagging.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, GStreamer, Encoding, Metadata, MP4, WMV, OGG, AAC, MP3, Vorbis, WMA, C#
**API:** MediaFileTags, MP3OutputBlock, OGGVorbisOutputBlock, M4AOutputBlock, WMVOutputBlock, MediaBlocksPipeline, SystemAudioSourceBlock

# Write Audio Tags with Media Blocks SDK

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Table of Contents

- [Write Audio Tags with Media Blocks SDK](#write-audio-tags-with-media-blocks-sdk)
- [Table of Contents](#table-of-contents)
- [Overview](#overview)
- [Core Features](#core-features)
- [Supported Audio Formats](#supported-audio-formats)
- [Prerequisites](#prerequisites)
- [MediaFileTags: The Unified Interface](#mediafiletags-the-unified-interface)
- [Code Examples by Format](#code-examples-by-format)
  - [MP3 Output with ID3 Tags](#mp3-output-with-id3-tags)
  - [OGG Vorbis Output with Vorbis Comments](#ogg-vorbis-output-with-vorbis-comments)
  - [M4A Output with MP4 Metadata](#m4a-output-with-mp4-metadata)
  - [WMV/WMA Output with ASF Metadata](#wmvwma-output-with-asf-metadata)
- [Complete Audio Recording Example](#complete-audio-recording-example)
- [Advanced Tag Scenarios](#advanced-tag-scenarios)
  - [Album Artwork Support](#album-artwork-support)
  - [Runtime Tag Modification](#runtime-tag-modification)
  - [Multi-Track Albums](#multi-track-albums)
- [Best Practices](#best-practices)
  - [Tag Data Quality](#tag-data-quality)
  - [Performance Considerations](#performance-considerations)
  - [Format-Specific Guidelines](#format-specific-guidelines)
- [Troubleshooting](#troubleshooting)
  - [Common Issues and Solutions](#common-issues-and-solutions)
  - [Debug Tag Writing](#debug-tag-writing)
- [Tag Format Specifications](#tag-format-specifications)
  - [ID3 Tags (MP3)](#id3-tags-mp3)
  - [Vorbis Comments (OGG)](#vorbis-comments-ogg)
  - [MP4 Metadata (M4A)](#mp4-metadata-m4a)
  - [ASF Attributes (WMV/WMA)](#asf-attributes-wmvwma)

## Overview

The VisioForge Media Blocks SDK supports writing audio metadata tags to output files across all major audio formats. Whether you're building a music production application, podcast recorder, or audio content management system, you can embed rich metadata into your audio files using a unified programming interface.

This guide demonstrates how to add metadata tags like artist, album, title, year, genre, and more to MP3, OGG Vorbis, M4A, and WMV/WMA audio files using format-appropriate tagging mechanisms while maintaining industry standards compliance.

## Core Features

- **Universal tag support**: Write metadata to MP3 (ID3), OGG (Vorbis Comments), M4A (MP4 atoms), and WMV (ASF attributes)
- **Comprehensive metadata**: 20+ tag fields including title, artist, album, year, track numbers, lyrics, and album artwork
- **Standards compliant**: Uses native container tag mechanisms for optimal compatibility
- **Unified API**: Single `MediaFileTags` instance works across all output formats
- **Runtime flexibility**: Modify tags before pipeline execution

## Supported Audio Formats

| Format | Container | Tag System | Standards |
| --- | --- | --- | --- |
| **MP3** | MPEG-1 Layer 3 | ID3v1/ID3v2 | ISO/IEC 11172-3, ID3v2.4 |
| **OGG Vorbis** | OGG | Vorbis Comments | Xiph.Org specification |
| **M4A** | MP4/MPEG-4 | MP4 metadata atoms | ISO Base Media File Format |
| **WMV/WMA** | ASF | ASF metadata attributes | Microsoft ASF specification |

## Prerequisites

- VisioForge Media Blocks SDK .NET
- .NET Framework 4.7.2+ or .NET Core 3.1+ or .NET 5+
- Basic understanding of audio processing pipelines

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Outputs;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Sources;
```

## MediaFileTags: The Unified Interface

The `MediaFileTags` class provides a unified interface for audio metadata across all supported formats. It contains common metadata fields and is mapped to the appropriate tag format for each output container by the specific output block.

```
// Create audio metadata
var audioTags = new MediaFileTags
{
    // Basic metadata
    Title = "Bohemian Rhapsody",
    Performers = new[] { "Queen" },
    Album = "A Night at the Opera",
    Year = 1975,

    // Track information
    Track = 11,
    TrackCount = 12,
    Disc = 1,
    DiscCount = 1,

    // Genre and categorization
    Genres = new[] { "Progressive Rock", "Opera Rock" },

    // Extended metadata
    Composers = new[] { "Freddie Mercury" },
    Conductor = "Roy Thomas Baker",
    Comment = "6-minute epic masterpiece",
    Copyright = "© 1975 Queen Productions Ltd.",

    // Technical metadata
    BeatsPerMinute = 72,
    Grouping = "Epic Songs",

    // Lyrics (for supported formats)
    Lyrics = @"Is this the real life?
Is this just fantasy?
Caught in a landslide
No escape from reality..."
};
```

All string-array fields (`Performers`, `Composers`, `Genres`, `AlbumArtists`) accept multiple values and are written as repeated frames on formats that support them (Vorbis Comments, ID3v2). Numeric fields (`Year`, `Track`, `TrackCount`, `Disc`, `DiscCount`, `BeatsPerMinute`) are `uint`.

## Code Examples by Format

### MP3 Output with ID3 Tags

MP3 files use ID3 tags (both v1 and v2) for metadata storage. `MP3OutputBlock` writes standards-compliant ID3 tags via the GStreamer `id3mux` element.

```
public async Task CreateMP3WithTags()
{
    // Configure MP3 encoder settings
    var mp3Settings = new MP3EncoderSettings
    {
        Bitrate = 320,                              // Kbit/s
        RateControl = MP3EncoderRateControl.CBR    // CBR / ABR / VBR
    };

    // Create metadata tags
    var tags = new MediaFileTags
    {
        Title = "Summer Vibes",
        Performers = new[] { "Indie Artist" },
        Album = "Seasonal Collection",
        Year = 2025,
        Track = 3,
        TrackCount = 10,
        Genres = new[] { "Indie Pop", "Electronic" },
        Comment = "Recorded in home studio",
        Copyright = "© 2025 Independent Label"
    };

    // Create MP3 output block with tags
    var mp3Output = new MP3OutputBlock("output.mp3", mp3Settings, tags);

    // Alternative: set tags after creation via the Tags property
    // var mp3Output = new MP3OutputBlock("output.mp3", mp3Settings);
    // mp3Output.Tags = tags;

    // Build the pipeline
    var pipeline = new MediaBlocksPipeline();

    // Add an audio source (microphone, file, etc.)
    var audioSource = new SystemAudioSourceBlock();

    // Connect source directly to MP3 output
    pipeline.Connect(audioSource.Output, mp3Output.Input);

    // Start recording with metadata
    await pipeline.StartAsync();

    // Recording writes ID3 tags into the MP3 file
    await Task.Delay(TimeSpan.FromSeconds(30));

    await pipeline.StopAsync();
}
```

### OGG Vorbis Output with Vorbis Comments

OGG Vorbis files use Vorbis Comments for metadata, which are embedded directly in the audio stream by the Vorbis encoder.

```
public async Task CreateOGGWithTags()
{
    // Configure Vorbis encoder settings.
    // Quality is int in the range [-1..10] (default 4). Used when RateControl = Quality.
    var vorbisSettings = new VorbisEncoderSettings
    {
        Quality = 8,
        RateControl = VorbisEncoderRateControl.Quality
    };

    // Create metadata
    var tags = new MediaFileTags
    {
        Title = "Acoustic Session",
        Performers = new[] { "Folk Artist", "Guest Vocalist" },
        AlbumArtists = new[] { "Folk Artist" },
        Album = "Live Sessions",
        Year = 2025,
        Track = 1,
        Genres = new[] { "Folk", "Acoustic" },
        Composers = new[] { "Folk Artist", "Traditional" },
        Comment = "Recorded live at Studio A",
        Conductor = "Sound Engineer",
        Grouping = "Live Recordings",
        Lyrics = @"In the quiet of the morning
When the world begins to wake
There's a song within the silence..."
    };

    // Create OGG output block with Vorbis comments
    var oggOutput = new OGGVorbisOutputBlock("output.ogg", vorbisSettings, tags);

    // Build and execute the pipeline
    var pipeline = new MediaBlocksPipeline();

    // Use UniversalSourceBlock to decode any file format into raw audio
    var sourceSettings = await UniversalSourceSettings.CreateAsync("input.wav");
    var fileSource = new UniversalSourceBlock(sourceSettings);

    pipeline.Connect(fileSource.AudioOutput, oggOutput.Input);

    await pipeline.StartAsync();
    await pipeline.WaitForStopAsync();   // Wait for EOS
}
```

### M4A Output with MP4 Metadata

M4A files use MP4 metadata atoms, compatible with iTunes and most media players. The default `M4AOutputBlock` ctor picks a default AAC encoder; use the 3-arg overload to pick a specific AAC implementation (`AVENCAACEncoderSettings`, `VOAACEncoderSettings`, or `MFAACEncoderSettings` on Windows).

```
public async Task CreateM4AWithTags()
{
    // Create podcast metadata
    var tags = new MediaFileTags
    {
        Title = "Episode 42: The Future of AI",
        Performers = new[] { "Tech Podcast Host" },
        Album = "Weekly Tech Talk",
        Year = 2025,
        Track = 42,
        Genres = new[] { "Technology", "Podcast" },
        Comment = "Special guest interview with AI researcher",
        Copyright = "© 2025 Tech Media Network",
        Subtitle = "Exploring artificial intelligence trends",
        Grouping = "Season 3"
    };

    // Option A: simplest — default AAC encoder picked internally
    var m4aOutput = new M4AOutputBlock("podcast_episode_42.m4a", tags);

    // Option B: pick a specific AAC encoder and sink settings
    // var sinkSettings = new MP4SinkSettings("podcast_episode_42.m4a");
    // var aacSettings = new AVENCAACEncoderSettings { Bitrate = 256 }; // 256 Kbit/s
    // var m4aOutput = new M4AOutputBlock(sinkSettings, aacSettings, tags);

    // Pipeline setup for podcast recording
    var pipeline = new MediaBlocksPipeline();
    var micSource = new SystemAudioSourceBlock();

    pipeline.Connect(micSource.Output, m4aOutput.Input);

    await pipeline.StartAsync();
}
```

### WMV/WMA Output with ASF Metadata

Windows Media formats use ASF (Advanced Systems Format) metadata attributes. `WMVOutputBlock` accepts a `MediaFileTags` parameter and handles both audio-only and audio+video outputs.

```
public async Task CreateWMVWithTags()
{
    // Create presentation metadata
    var tags = new MediaFileTags
    {
        Title = "Q4 Business Review",
        Performers = new[] { "CEO", "CFO", "VP Sales" },
        Album = "Corporate Presentations 2025",
        Year = 2025,
        Genres = new[] { "Business", "Corporate" },
        Comment = "Quarterly financial review and outlook",
        Copyright = "© 2025 Business Corp. Confidential",
        Conductor = "Meeting Organizer",
        Grouping = "Executive Presentations"
    };

    // Simplest form — default encoders, just filename + tags.
    // WMVOutputBlock will use the default WMV/WMA encoder settings internally.
    var wmvOutput = new WMVOutputBlock("presentation.wmv", tags);

    // Alternative: pass explicit sink/video/audio settings objects
    // var asfSettings = new ASFSinkSettings("presentation.wmv");
    // var wmvSettings = WMVEncoderBlock.GetDefaultSettings();
    // var wmaSettings = WMAEncoderBlock.GetDefaultSettings();
    // var wmvOutput = new WMVOutputBlock(asfSettings, wmvSettings, wmaSettings, tags);

    // Setup for video + audio recording
    var pipeline = new MediaBlocksPipeline();

    // Video source — pick the first available device
    var videoDevice = (await DeviceEnumerator.Shared.VideoSourcesAsync())[0];
    var videoSource = new SystemVideoSourceBlock(new VideoCaptureDeviceSourceSettings(videoDevice));

    // Audio source
    var audioSource = new SystemAudioSourceBlock();

    // Create dynamic input pads on the WMV output
    var videoPad = wmvOutput.CreateNewInput(MediaBlockPadMediaType.Video);
    var audioPad = wmvOutput.CreateNewInput(MediaBlockPadMediaType.Audio);

    pipeline.Connect(videoSource.Output, videoPad);
    pipeline.Connect(audioSource.Output, audioPad);

    await pipeline.StartAsync();
}
```

## Complete Audio Recording Example

Record the same audio source to multiple tagged output formats simultaneously:

```
public class AudioRecorderWithTags
{
    public async Task RecordAudioWithMetadata()
    {
        // Rich metadata shared across every output file
        var sessionTags = new MediaFileTags
        {
            Title = "Studio Session #1",
            Performers = new[] { "John Doe", "Jane Smith" },
            Album = "Demo Recordings",
            Year = 2025,
            Track = 1,
            Genres = new[] { "Rock", "Alternative" },
            Composers = new[] { "John Doe" },
            Comment = "First studio recording session",
            Copyright = "© 2025 Demo Productions",
            BeatsPerMinute = 120,
            Grouping = "Demo Sessions"
        };

        // MP3 output (CBR 320 Kbit/s + ID3 tags)
        var mp3Output = new MP3OutputBlock(
            "session1.mp3",
            new MP3EncoderSettings { Bitrate = 320, RateControl = MP3EncoderRateControl.CBR },
            sessionTags);

        // OGG Vorbis output (highest quality + Vorbis Comments)
        var oggOutput = new OGGVorbisOutputBlock(
            "session1.ogg",
            new VorbisEncoderSettings { Quality = 10, RateControl = VorbisEncoderRateControl.Quality },
            sessionTags);

        // M4A output (default AAC + MP4 atoms)
        var m4aOutput = new M4AOutputBlock("session1.m4a", sessionTags);

        // Pipeline with a single audio source fanned out to all three files
        var pipeline = new MediaBlocksPipeline();
        var audioSource = new SystemAudioSourceBlock();

        // Connecting the same source pad to multiple sinks auto-inserts a tee
        pipeline.Connect(audioSource.Output, mp3Output.Input);
        pipeline.Connect(audioSource.Output, oggOutput.Input);
        pipeline.Connect(audioSource.Output, m4aOutput.Input);

        Console.WriteLine("Starting recording with metadata...");
        await pipeline.StartAsync();

        await Task.Delay(TimeSpan.FromMinutes(3));

        Console.WriteLine("Stopping recording...");
        await pipeline.StopAsync();

        Console.WriteLine("Recording complete — files written with metadata:");
        Console.WriteLine("- session1.mp3 (ID3 tags)");
        Console.WriteLine("- session1.ogg (Vorbis comments)");
        Console.WriteLine("- session1.m4a (MP4 metadata)");
    }
}
```

## Advanced Tag Scenarios

### Album Artwork Support

Attach album artwork to supported formats (MP3, M4A, WMV). On Windows, `MediaFileTags.Pictures` accepts `System.Drawing.Bitmap[]`; cross-platform builds use `IBitmap[]`.

```
var tags = new MediaFileTags
{
    Title = "Album Title Track",
    Performers = new[] { "Artist Name" },
    Album = "Album Name"
};

// Attach album artwork (Windows — System.Drawing)
#if NET_WINDOWS
if (File.Exists("album_cover.jpg"))
{
    var albumArt = new System.Drawing.Bitmap("album_cover.jpg");
    tags.Pictures = new[] { albumArt };
    tags.Pictures_Descriptions = new[] { "Front Cover" };
}
#endif

var mp3Output = new MP3OutputBlock(
    "track.mp3",
    new MP3EncoderSettings { Bitrate = 320, RateControl = MP3EncoderRateControl.CBR },
    tags);
```

### Runtime Tag Modification

Set or modify tags before starting the pipeline — once a pipeline has started, the tag payload for that output is already being emitted.

```
var mp3Settings = new MP3EncoderSettings { Bitrate = 320, RateControl = MP3EncoderRateControl.CBR };
var mp3Output = new MP3OutputBlock("output.mp3", mp3Settings);

// Assign tags via the Tags property before StartAsync
mp3Output.Tags = new MediaFileTags
{
    Title = "Live Recording",
    Performers = new[] { "Artist" }
};

// Tweak fields right up until start
mp3Output.Tags.Comment = $"Recorded on {DateTime.Now:yyyy-MM-dd}";
mp3Output.Tags.Year = (uint)DateTime.Now.Year;

await pipeline.StartAsync();
```

### Multi-Track Albums

Create consistent metadata across album tracks by using a shared base tag object:

```
public class AlbumRecorder
{
    private readonly MediaFileTags _baseAlbumTags;
    private readonly MP3EncoderSettings _mp3Settings =
        new MP3EncoderSettings { Bitrate = 320, RateControl = MP3EncoderRateControl.CBR };

    public AlbumRecorder()
    {
        _baseAlbumTags = new MediaFileTags
        {
            Album = "My Album",
            AlbumArtists = new[] { "Main Artist" },
            Year = 2025,
            Genres = new[] { "Pop", "Electronic" },
            TrackCount = 12,
            Copyright = "© 2025 Record Label"
        };
    }

    public MP3OutputBlock CreateTrackOutput(int trackNumber, string title, string[] performers)
    {
        var trackTags = new MediaFileTags
        {
            // Inherit album-level metadata
            Album = _baseAlbumTags.Album,
            AlbumArtists = _baseAlbumTags.AlbumArtists,
            Year = _baseAlbumTags.Year,
            Genres = _baseAlbumTags.Genres,
            TrackCount = _baseAlbumTags.TrackCount,
            Copyright = _baseAlbumTags.Copyright,

            // Track-specific metadata
            Track = (uint)trackNumber,
            Title = title,
            Performers = performers
        };

        return new MP3OutputBlock($"track_{trackNumber:D2}.mp3", _mp3Settings, trackTags);
    }
}
```

## Best Practices

### Tag Data Quality

- **Consistent encoding**: Use UTF-8 encoding for international characters
- **Complete information**: Fill in as many relevant tag fields as possible
- **Standardized genres**: Use recognized genre names for better compatibility
- **Proper copyright**: Include appropriate copyright notices

### Performance Considerations

- **Tag size**: Keep text fields reasonable in length to avoid bloating files
- **Image compression**: Compress album artwork appropriately (JPEG recommended)
- **Reuse instances**: When creating multiple files, share base tag objects and only override per-track fields

### Format-Specific Guidelines

```
// MP3: ID3v2 supports extensive metadata
var mp3Tags = new MediaFileTags
{
    Title = "Song Title",
    Subtitle = "Song Subtitle",     // ID3v2 TIT3 frame
    Lyrics = "Full lyrics text",    // USLT frame
    BeatsPerMinute = 128            // TBPM frame
};

// OGG: Vorbis comments are flexible and handle multi-value fields natively
var oggTags = new MediaFileTags
{
    Composers = new[] { "Composer 1", "Composer 2" },
    Performers = new[] { "Artist 1", "Artist 2" }
};

// M4A: iTunes-compatible metadata
var m4aTagsForPodcast = new MediaFileTags
{
    Title = "Episode Title",
    Album = "Podcast Series Name",  // Shows as "Album" in iTunes
    Performers = new[] { "Host Name" }, // Shows as "Artist"
    Genres = new[] { "Podcast" },
    Comment = "Episode description"
};
```

## Troubleshooting

### Common Issues and Solutions

**Tags not appearing in media players:**

- Ensure the output format supports the specific tag fields you're using
- Verify the media player supports the tag format (some players prefer ID3v2.3 over ID3v2.4)
- Check that text encoding is correct (UTF-8 recommended)

**File size unexpectedly large:**

- Reduce album artwork resolution (600×600 is usually enough)
- Avoid extremely long text fields in comments or lyrics
- Use appropriate image compression for artwork

**Encoding errors:**

- Validate that special characters are properly encoded
- Ensure file paths are accessible and writable
- Check that encoder settings are compatible with your system

### Debug Tag Writing

Subscribe to the pipeline's `OnError` event to see encoder/muxer failures during tag writing. There is no "tag messages only" stream — inspect the produced file with a tag reader (TagLib, MediaInfo, or the SDK's own `MediaInfoReader`) to confirm what was written.

```
var pipeline = new MediaBlocksPipeline();

pipeline.OnError += (sender, e) =>
{
    Console.WriteLine($"Pipeline error: {e.Message}");
};

// Continue with pipeline setup...
```

## Tag Format Specifications

### ID3 Tags (MP3)

- **ID3v1**: Basic 128-byte structure with limited fields
- **ID3v2**: Extensible format supporting Unicode, multiple values, and custom frames
- **Common frames**: TIT2 (Title), TPE1 (Artist), TALB (Album), TDRC (Year), TCON (Genre)

### Vorbis Comments (OGG)

- **Format**: UTF-8 text in NAME=VALUE format
- **Standard fields**: TITLE, ARTIST, ALBUM, DATE, GENRE, TRACKNUMBER
- **Flexible**: Arbitrary field names and multiple values are allowed

### MP4 Metadata (M4A)

- **Atoms**: iTunes-style metadata stored in MP4 atoms
- **Common atoms**: ©nam (Title), ©ART (Artist), ©alb (Album), ©day (Year)
- **Binary data**: Embedded artwork goes in the `covr` atom

### ASF Attributes (WMV/WMA)

- **Structure**: Key-value pairs in the ASF header
- **Standard attributes**: Title, Author, Copyright, Description
- **Extended**: Custom attributes are supported

---

This guide covers writing audio metadata tags with the VisioForge Media Blocks SDK. The unified `MediaFileTags` class simplifies the code while keeping each container's native tag format (ID3, Vorbis Comments, MP4 atoms, ASF) intact. For more advanced audio-processing scenarios, explore the complete [VisioForge Media Blocks SDK documentation](../../).

---END OF PAGE---


## C# Barcode and QR Code Scanner from Live Video in .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/barcode-qr-reader-guide/
**Description:** Build a C# barcode scanner and QR code reader from live video using webcams, IP cameras, or RTSP streams with VisioForge Media Blocks SDK.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Streaming, Barcode / QR, Webcam, IP Camera, Screen Capture, RTSP, ONVIF, MP4, C#, Entitlements
**API:** BarcodeDetectorBlock, MediaBlocksPipeline, InputOutput, BarcodeDetectorEventArgs, UniversalSourceBlock

# How to Build a C# Barcode Scanner and QR Code Reader in .NET

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction

Need to read barcodes or scan QR codes from a live camera feed in C#? Unlike image-only barcode libraries, VisioForge Media Blocks SDK scans barcodes directly from real-time video streams — [webcams](../../../videocapture/guides/save-webcam-video/), [IP cameras](../../../videocapture/video-sources/ip-cameras/), [RTSP sources](../../../general/network-streaming/rtsp/), video files, and screen capture. This makes it the ideal .NET barcode scanner SDK for surveillance, inventory, and automation applications that process live video.

This guide walks you through building a cross-platform C# barcode reader and QR code scanner that runs on Windows, Android, iOS, macOS, and Linux using .NET MAUI, Avalonia, or WPF.

## Why Use Video-Based Barcode Scanning?

### Key Advantages over Image-Only Libraries

- **Real-time video stream scanning**: Detect barcodes continuously from webcam, IP camera, or RTSP feeds — not just static images
- **Cross-platform .NET support**: Single codebase for Windows, Android, iOS, macOS, and Linux with MAUI, Avalonia, WPF, WinForms, Blazor, and console apps
- **Pipeline architecture**: Combine barcode detection with video preview, recording, and other processing in one pipeline
- **Multiple input sources**: Scan from cameras, video files, screen capture, or [network streams](../../../general/network-streaming/rtsp/)
- **Comprehensive format support**: QR codes, DataMatrix, Code128, Code39, EAN-13, UPC-A, PDF417, Aztec, and many other 1D/2D barcode formats
- **Event-driven API**: Simple `OnBarcodeDetected` event delivers barcode type, value, and timestamp

## Supported Barcode and QR Code Formats

The C# barcode scanner supports a wide range of 1D and 2D barcode formats:

### 2D Barcodes

- **QR Code**: Most popular 2D barcode format, widely used in mobile applications
- **DataMatrix**: Compact format ideal for small items
- **PDF417**: Used in driver's licenses and boarding passes
- **Aztec**: Compact format used in transportation tickets

### 1D Barcodes

- **Code 128**: High-density format for alphanumeric data
- **Code 39**: Simple alphanumeric format
- **EAN-13/EAN-8**: European Article Number for retail products
- **UPC-A/UPC-E**: Universal Product Code for retail
- **Codabar**: Used in libraries and blood banks
- **ITF**: Interleaved 2 of 5 for shipping and distribution

## Barcode Scanner Pipeline Architecture

The Media Blocks SDK uses a pipeline-based architecture where video frames flow through connected blocks for real-time barcode detection:

```
graph LR;
    A[Video Source] --> B[Barcode Detector];
    B --> C[Video Renderer];
    B -- Detection Event --> D[Type + Value];
```

This modular approach allows you to:

- Easily swap input sources (camera, file, stream)
- Add additional processing blocks (filters, encoders)
- Route output to multiple destinations simultaneously

## How to Read Barcodes from Camera in C

Build a barcode scanner that reads from a webcam or camera device in C# step by step.

### Step 1: Setting Up the Project

First, ensure you have the necessary NuGet packages installed:

```
# For Windows applications
dotnet add package VisioForge.CrossPlatform.Core.Windows.x64
dotnet add package VisioForge.CrossPlatform.Libav.Windows.x64

# For Android applications
dotnet add package VisioForge.CrossPlatform.Core.Android

# For iOS applications
dotnet add package VisioForge.CrossPlatform.Core.iOS

# For macOS applications
dotnet add package VisioForge.CrossPlatform.Core.macCatalyst
```

Add the required namespaces to your code:

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X;
using VisioForge.Core.Types.X.Sources;
```

### Step 2: Initializing the SDK

Before using any SDK features, initialize the VisioForge engine:

```
// Initialize the SDK (required on first use)
await VisioForgeX.InitSDKAsync();
```

This initialization step builds the internal registry and prepares the engine. It only needs to be done once when your application starts.

### Step 3: Enumerating Video Sources

Before capturing video, you need to discover available cameras:

```
// Start monitoring for video sources
await DeviceEnumerator.Shared.StartVideoSourceMonitorAsync();

// Get list of available cameras
var cameras = await DeviceEnumerator.Shared.VideoSourcesAsync();

// Display available cameras
foreach (var camera in cameras)
{
    Console.WriteLine($"Camera: {camera.DisplayName}");

    // List supported formats
    foreach (var format in camera.VideoFormats)
    {
        Console.WriteLine($"  Format: {format.Name}");
    }
}
```

### Step 4: Creating the Pipeline

Create a pipeline and configure the necessary blocks:

```
// Create the pipeline
var pipeline = new MediaBlocksPipeline();
pipeline.OnError += Pipeline_OnError;

// Configure video source
var device = cameras.First();
var formatItem = device.GetHDOrAnyVideoFormatAndFrameRate(out var frameRate);

var videoSourceSettings = new VideoCaptureDeviceSourceSettings(device)
{
    Format = formatItem.ToFormat()
};
videoSourceSettings.Format.FrameRate = frameRate;

// Create video source block
var videoSource = new SystemVideoSourceBlock(videoSourceSettings);

// Create barcode detector block
var barcodeDetector = new BarcodeDetectorBlock(BarcodeDetectorMode.InputOutput);
barcodeDetector.OnBarcodeDetected += BarcodeDetector_OnBarcodeDetected;

// Create video renderer block (for preview)
var videoRenderer = new VideoRendererBlock(pipeline, videoView);

// Connect the blocks
pipeline.Connect(videoSource.Output, barcodeDetector.Input);
pipeline.Connect(barcodeDetector.Output, videoRenderer.Input);
```

### Step 5: Handling Barcode Detection Events

Implement the event handler to process detected barcodes:

```
private void BarcodeDetector_OnBarcodeDetected(object sender, BarcodeDetectorEventArgs e)
{
    // This event is called when a barcode is detected
    Console.WriteLine($"Detected: {e.BarcodeType} = {e.Value}");

    // Update UI (use dispatcher for thread safety)
    Dispatcher.Invoke(() =>
    {
        BarcodeTypeLabel.Text = e.BarcodeType;
        BarcodeValueLabel.Text = e.Value;
        LastDetectionTime.Text = DateTime.Now.ToString("HH:mm:ss.fff");
    });
}
```

### Step 6: Starting and Stopping the Pipeline

Control the pipeline lifecycle:

```
// Start scanning
await pipeline.StartAsync();

// Stop scanning
await pipeline.StopAsync();

// Pause scanning
await pipeline.PauseAsync();

// Resume scanning
await pipeline.ResumeAsync();
```

### Step 7: Cleanup

Properly dispose of resources when done:

```
// Remove event handlers
barcodeDetector.OnBarcodeDetected -= BarcodeDetector_OnBarcodeDetected;
pipeline.OnError -= Pipeline_OnError;

// Stop and cleanup
await pipeline.StopAsync();
pipeline.ClearBlocks();
pipeline.Dispose();

// Destroy SDK (on application exit)
VisioForgeX.DestroySDK();
```

## Advanced Barcode Reading Features

### Duplicate Detection Prevention

To prevent multiple detections of the same barcode:

```
private Dictionary<string, DateTime> _recentDetections = new();
private TimeSpan _deduplicationWindow = TimeSpan.FromSeconds(2);

private void BarcodeDetector_OnBarcodeDetected(object sender, BarcodeDetectorEventArgs e)
{
    string key = $"{e.BarcodeType}:{e.Value}";

    // Check if this barcode was recently detected
    if (_recentDetections.TryGetValue(key, out var lastTime))
    {
        if (DateTime.Now - lastTime < _deduplicationWindow)
        {
            return; // Skip duplicate
        }
    }

    // Record this detection
    _recentDetections[key] = DateTime.Now;

    // Process the barcode
    ProcessBarcode(e.BarcodeType, e.Value);
}
```

### Scan Barcodes from Video Files, Screen Capture, and RTSP Streams

The SDK supports various input sources beyond local cameras:

#### Read Barcodes from Video File

```
var fileSettings = await UniversalSourceSettings.CreateAsync(
    @"C:\Videos\barcode-video.mp4");
var fileSource = new UniversalSourceBlock(fileSettings);

pipeline.Connect(fileSource.VideoOutput, barcodeDetector.Input);
```

#### Scan Barcodes from Screen Capture

```
// ScreenSourceBlock takes an IScreenCaptureSourceSettings — on Windows
// use ScreenCaptureD3D11SourceSettings (Windows 8+). MonitorIndex selects the monitor.
var screenSource = new ScreenSourceBlock(
    new ScreenCaptureD3D11SourceSettings
    {
        MonitorIndex = 0, // Primary monitor
        FrameRate = new VideoFrameRate(10), // 10 FPS
        CaptureCursor = false
    });

pipeline.Connect(screenSource.Output, barcodeDetector.Input);
```

#### Scan Barcodes from RTSP IP Camera Stream

```
var streamSettings = await UniversalSourceSettings.CreateAsync(
    "rtsp://camera-ip:554/stream");
var streamSource = new UniversalSourceBlock(streamSettings);

pipeline.Connect(streamSource.VideoOutput, barcodeDetector.Input);
```

### Detection History Tracking

Maintain a history of detected barcodes:

```
public class BarcodeDetection
{
    public string Type { get; set; }
    public string Value { get; set; }
    public DateTime Timestamp { get; set; }
}

private ObservableCollection<BarcodeDetection> _detectionHistory = new();
private int _maxHistorySize = 100;

private void BarcodeDetector_OnBarcodeDetected(object sender, BarcodeDetectorEventArgs e)
{
    var detection = new BarcodeDetection
    {
        Type = e.BarcodeType,
        Value = e.Value,
        Timestamp = DateTime.Now
    };

    // Add to beginning of list
    _detectionHistory.Insert(0, detection);

    // Maintain maximum size
    while (_detectionHistory.Count > _maxHistorySize)
    {
        _detectionHistory.RemoveAt(_detectionHistory.Count - 1);
    }
}
```

### Error Handling

Implement robust error handling:

```
private void Pipeline_OnError(object sender, ErrorsEventArgs e)
{
    Debug.WriteLine($"Pipeline Error: {e.Message}");

    // Show user-friendly message
    Dispatcher.Invoke(() =>
    {
        mmLog.Text += e.Message + Environment.NewLine;
    });
}
```

## Platform Setup: Android, iOS, and macOS Barcode Scanning

### Android Camera Permissions

On Android, you must request camera permissions before scanning barcodes:

```
private async Task<bool> RequestCameraPermissionAsync()
{
    var status = await Permissions.CheckStatusAsync<Permissions.Camera>();

    if (status != PermissionStatus.Granted)
    {
        status = await Permissions.RequestAsync<Permissions.Camera>();
    }

    return status == PermissionStatus.Granted;
}
```

Add to AndroidManifest.xml:

```
<uses-permission android:name="android.permission.CAMERA" />
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" />
```

### iOS Camera Permissions

Add to Info.plist:

```
<key>NSCameraUsageDescription</key>
<string>This app needs camera access to scan barcodes and QR codes</string>
```

### macOS Camera Permissions

For macOS and Mac Catalyst, add to Entitlements.plist:

```
<key>com.apple.security.device.camera</key>
<true/>
```

## Optimizing Barcode Scanner Performance in .NET

### Frame Rate Optimization

Balance barcode detection speed and CPU usage:

```
// Lower frame rate for better performance
videoSourceSettings.Format.FrameRate = new VideoFrameRate(15); // 15 FPS instead of 30

// For screen capture, use even lower frame rates
screenSourceSettings.FrameRate = new VideoFrameRate(5); // 5 FPS
```

### Resolution Considerations

Lower resolution can improve performance without significantly affecting detection:

```
// Choose a lower resolution format
var format = device.VideoFormats
    .Where(f => f.Width <= 1280 && f.Height <= 720)
    .OrderByDescending(f => f.Width * f.Height)
    .FirstOrDefault();
```

### Detector Mode Selection

The `BarcodeDetectorBlock` supports different modes:

```
// InputOutput mode: Passes video through for preview (default)
var detector = new BarcodeDetectorBlock(BarcodeDetectorMode.InputOutput);

// InputOnly mode: No video output, better performance
var detector = new BarcodeDetectorBlock(BarcodeDetectorMode.InputOnly);
```

## Barcode Scanner for .NET MAUI, Avalonia, and WPF

### .NET MAUI Barcode Scanner

```
public partial class MainPage : ContentPage
{
    private MediaBlocksPipeline _pipeline;
    private BarcodeDetectorBlock _barcodeDetector;

    public MainPage()
    {
        InitializeComponent();
        Loaded += MainPage_Loaded;
    }

    private async void MainPage_Loaded(object sender, EventArgs e)
    {
        await VisioForgeX.InitSDKAsync();

        #if __ANDROID__ || __IOS__ || __MACCATALYST__
        await RequestCameraPermissionAsync();
        #endif

        _pipeline = new MediaBlocksPipeline();
        // ... setup pipeline
    }
}
```

### Avalonia Barcode Scanner

```
public partial class MainWindow : Window
{
    private MediaBlocksPipeline _pipeline;
    private BarcodeDetectorBlock _barcodeDetector;

    public MainWindow()
    {
        InitializeComponent();
        Loaded += MainWindow_Loaded;
    }

    private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
    {
        await VisioForgeX.InitSDKAsync();

        _pipeline = new MediaBlocksPipeline();
        // ... setup pipeline
    }
}
```

## Barcode Scanner Use Cases: Inventory, Ticketing, and Payments

### Inventory Management with Barcode Scanning

Track products in warehouses using barcode scanning:

```
private async void ProcessInventoryBarcode(string barcodeValue)
{
    // Look up product in database
    var product = await _database.GetProductByBarcodeAsync(barcodeValue);

    if (product != null)
    {
        // Update inventory count
        product.Quantity++;
        await _database.SaveChangesAsync();

        // Show confirmation
        StatusLabel.Text = $"Added: {product.Name}";
    }
    else
    {
        StatusLabel.Text = "Product not found";
    }
}
```

### QR Code Ticket Scanning for Events

Scan QR code tickets at event entrances:

```
private async void ProcessTicketBarcode(string ticketCode)
{
    var ticket = await _ticketService.ValidateTicketAsync(ticketCode);

    if (ticket.IsValid && !ticket.IsUsed)
    {
        await _ticketService.MarkAsUsedAsync(ticketCode);
        PlaySuccessSound();
        ShowGreenLight();
    }
    else
    {
        PlayErrorSound();
        ShowRedLight();
        StatusLabel.Text = ticket.IsUsed ? "Already used" : "Invalid ticket";
    }
}
```

### QR Code Payment Processing

Scan QR codes for mobile payments:

```
private async void ProcessPaymentQRCode(string qrData)
{
    if (IsPaymentQRCode(qrData))
    {
        var paymentInfo = ParsePaymentData(qrData);

        // Show payment confirmation dialog
        var result = await DisplayAlert(
            "Confirm Payment",
            $"Pay ${paymentInfo.Amount} to {paymentInfo.Recipient}?",
            "Pay",
            "Cancel");

        if (result)
        {
            await ProcessPaymentAsync(paymentInfo);
        }
    }
}
```

## Troubleshooting C# Barcode Scanner Issues

### Issue: No Barcodes Detected

**Solutions:**

1. Ensure adequate lighting - barcodes need clear visibility
2. Check camera focus - some cameras need time to focus
3. Verify barcode is within camera field of view
4. Try adjusting camera distance (15-30cm typically optimal)
5. Check that the barcode format is supported

### Issue: Multiple Detections of Same Barcode

**Solution:** Implement duplicate detection prevention (shown earlier)

### Issue: Poor Performance

**Solutions:**

1. Lower video resolution
2. Reduce frame rate
3. Use `BarcodeDetectorMode.InputOnly` if preview isn't needed
4. Close other applications to free system resources

### Issue: Camera Not Found

**Solutions:**

1. Verify camera permissions are granted
2. Check that camera is not in use by another application
3. Restart the device
4. Try enumerating devices after a short delay

## Best Practices

1. **Always Initialize SDK Early**: Call `InitSDKAsync()` during application startup
2. **Request Permissions First**: Check and request camera permissions before accessing camera
3. **Handle Errors Gracefully**: Implement proper error handling for all pipeline operations
4. **Dispose Resources Properly**: Always clean up pipeline and blocks when done
5. **Test on Target Devices**: Performance varies by device - test on actual hardware
6. **Provide Visual Feedback**: Show users when barcodes are detected successfully
7. **Consider Offline Scenarios**: Cache necessary data for offline barcode processing
8. **Implement Logging**: Log detection events for debugging and analytics

## Sample Projects

Complete sample projects are available in the SDK:

- **WPF Barcode Detection**: [Barcode Detection WPF Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Barcode%20Detection%20Demo)
- **WPF DataMatrix Detection**: [DataMatrix Detection WPF Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/DataMatrix%20Detection%20Demo)

These samples demonstrate:

- Complete UI implementation
- Camera selection and configuration
- Real-time barcode detection
- Detection history tracking
- Error handling
- Cross-platform compatibility

## Frequently Asked Questions

### What barcode formats can I scan from a camera in C#?

The SDK supports all major 1D and 2D barcode formats including QR Code, DataMatrix, PDF417, Aztec, Code 128, Code 39, EAN-13, EAN-8, UPC-A, UPC-E, Codabar, and ITF. All formats can be scanned in real time from any video source — webcam, IP camera, RTSP stream, or video file.

### Can I scan QR codes from an IP camera or RTSP stream?

Yes. Use `UniversalSourceBlock` with an RTSP URI to connect to any IP camera and scan barcodes from the live video stream. The pipeline handles decoding, buffering, and frame delivery automatically. See the [RTSP streaming guide](../../../general/network-streaming/rtsp/) for connection details.

### Does the barcode scanner work on Android, iOS, and macOS?

Yes. The `BarcodeDetectorBlock` is fully cross-platform. .NET MAUI apps run on Android and iOS; Avalonia apps run on macOS and Linux. Each platform requires camera permissions — see the [Platform Setup](#platform-setup-android-ios-and-macos-barcode-scanning) section for details.

### How do I prevent duplicate barcode detections?

Implement a time-based deduplication window. Store each detected barcode value with a timestamp and skip detections that match a recent entry within a configurable interval (typically 2 seconds). See the [Duplicate Detection Prevention](#duplicate-detection-prevention) code example above.

### What frame rate do I need for reliable barcode scanning?

For most use cases, 10–15 FPS provides reliable detection with low CPU usage. Static barcodes (warehouse labels, product shelves) work well at 5 FPS. Fast-moving barcodes on a conveyor belt may need 25–30 FPS. Use the lowest frame rate that gives reliable results to minimize resource consumption.

## See Also

- [Webcam Video Capture in C#](../../../videocapture/guides/save-webcam-video/) — capture and record webcam video using the same SDK
- [RTSP Streaming and IP Camera Capture](../../../general/network-streaming/rtsp/) — connect to IP cameras for barcode scanning from network streams
- [IP Camera Sources](../../../videocapture/video-sources/ip-cameras/) — configure ONVIF and RTSP camera sources
- [Pre-Event Recording](../pre-event-recording/) — combine barcode detection with motion-triggered recording
- [Special Blocks Reference](../../Special/) — BarcodeDetectorBlock API reference
- [Getting Started with Media Blocks](../../GettingStarted/) — pipeline fundamentals
- [Platform-Specific Deployment](../../../deployment-x/) — native dependency packages for all platforms

---END OF PAGE---


## Custom GStreamer MediaBlock Guide for C# .NET Pipelines
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/custom-mediablock-from-gstreamer-element/
**Description:** Wrap any GStreamer element as a MediaBlock in C# .NET using CustomMediaBlock or a typed subclass, with a videobalance grayscale example.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, GStreamer, Effects, Custom Block, C#
**API:** MediaBlock, IMediaBlockInternals, CustomMediaBlock, CustomMediaBlockSettings, MediaBlockPad

# Build your own MediaBlock from a GStreamer element in C# .NET

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Media Blocks SDK already ships 70+ typed blocks for common video, audio, encoding, and streaming tasks. Sometimes, though, you need a GStreamer element that the SDK does not wrap yet — a third-party plugin, an experimental element from `gst-plugins-bad`, or simply something you wrote yourself. This guide shows how to integrate any single GStreamer element into a `MediaBlocksPipeline` as a first-class block.

Why grayscale?

The worked example wraps `videobalance` with `saturation = 0` to convert video to grayscale. **The SDK already ships `GrayscaleBlock` and `VideoBalanceBlock`** built on the same element — you don't need to re-create them in production code. We use grayscale because it is the smallest possible example that exercises the full pattern: one element, one property, sink/src pads. Once you understand it, you can wrap any GStreamer element the same way.

## Two approaches

| Approach | When to use it |
| --- | --- |
| **A.** Use the built-in `CustomMediaBlock` — pass the element name and properties as data. | One-off use, prototyping, or wrapping any element from anywhere in the call chain. No subclassing, no new types. |
| **B.** Write a typed `MediaBlock` subclass. | You want a reusable, strongly typed block with a static `IsAvailable()` check, a settings class, IntelliSense, and the same feel as built-in blocks. |

Both approaches share the same idea: a MediaBlock owns a `Gst.Element`, puts it into the pipeline's `Gst.Pipeline`, and exposes the element's static `sink` and `src` pads as `MediaBlockPad` instances that `MediaBlocksPipeline.Connect(...)` can wire together.

```
flowchart LR
    Source[Source<br/>Block] -- Output --> InP[ Sink<br/>MediaBlockPad ]
    subgraph Custom["Your custom MediaBlock"]
        InP --> Elem[ Gst.Element<br/>e.g. videobalance ]
        Elem --> OutP[ Src<br/>MediaBlockPad ]
    end
    OutP -- Input --> Renderer[Encoder /<br/>Renderer]
```

## Approach A — `CustomMediaBlock` (no subclassing)

`CustomMediaBlock` is the public, generic wrapper that does everything described above without you having to write a class. Pass it the GStreamer element name and a list of pads, set properties via a string-keyed dictionary, add it to the pipeline, and connect it.

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.Types.X.Special;

var settings = new CustomMediaBlockSettings("videobalance");
settings.Pads.Add(new CustomMediaBlockPad(MediaBlockPadDirection.In,  MediaBlockPadMediaType.Video));
settings.Pads.Add(new CustomMediaBlockPad(MediaBlockPadDirection.Out, MediaBlockPadMediaType.Video));
settings.ElementParams["saturation"] = 0.0;          // videobalance.saturation is a double

var grayscale = new CustomMediaBlock(settings);

pipeline.AddBlock(grayscale);
pipeline.Connect(source.Output,    grayscale.Input);
pipeline.Connect(grayscale.Output, encoder.Input);
```

That is the whole block. `CustomMediaBlock.Build()` is invoked by the pipeline during `StartAsync` and does the work: creates the `videobalance` element via `Gst.ElementFactory.Make`, applies every entry in `ElementParams` with `SetProperty`, adds the element to the pipeline, and binds the sink/src pads.

### Supported property types

`ElementParams` accepts the following CLR types and maps them to the matching `GLib.Value`:

| CLR type | GStreamer property kind |
| --- | --- |
| `int` | `gint`, `enum` |
| `uint` | `guint`, `flags` |
| `long` | `gint64` |
| `ulong` | `guint64` |
| `float` | `gfloat` |
| `double` | `gdouble` (most of `videobalance`, `gamma`, audio volumes, etc.) |
| `string` | `gchararray` |
| `bool` | implicit via `GLib.Value` |
| `Enum` | converted to `int` |

Match the GStreamer property type **exactly**. `videobalance.saturation` is a `gdouble` — pass `0.0`, not `0` (int) and not `0.0f` (float). Mis-typed properties are a silent no-op.

### Wrapping multi-element chains: bin syntax

If your transformation needs more than one GStreamer element, you can pass a bin description in `[ ... ]` instead of a single element name. The block parses it with `Gst.Parse.BinFromDescription` and adds the resulting bin:

```
var settings = new CustomMediaBlockSettings("[ videoconvert ! videobalance saturation=0 ! videoconvert ]");
settings.Pads.Add(new CustomMediaBlockPad(MediaBlockPadDirection.In,  MediaBlockPadMediaType.Video));
settings.Pads.Add(new CustomMediaBlockPad(MediaBlockPadDirection.Out, MediaBlockPadMediaType.Video));
var block = new CustomMediaBlock(settings);
```

### Dynamic pads (demuxer-like elements)

For elements that create their src pads at runtime (e.g. `decodebin`, `tsdemux`), set `UsePadAddedEvent = true` on the settings. `CustomMediaBlock` inserts an `identity` per declared output pad and links them as the element fires `pad-added`.

### Late tweaks via `OnElementAdded`

If you need to touch the raw `Gst.Element` after creation but before the pipeline starts (signal handlers, structure caps, properties that don't fit the `ElementParams` map), subscribe to `OnElementAdded`:

```
var block = new CustomMediaBlock(settings);
block.OnElementAdded += (s, element) =>
{
    element.SetProperty("brightness", new GLib.Value(0.1));
    // … any other tweak
};
```

### When `CustomMediaBlock` is not enough

You want a typed block when:

- You will use it in many places and want IntelliSense for properties.
- You want a static `IsAvailable()` to fail fast on systems where the plugin is missing.
- You want a settings class with validation, defaults, and XML docs.
- You want the block to look and feel like every other SDK block in someone else's code review.

That is **Approach B**.

## Approach B — a typed `MediaBlock` subclass

A custom block is `MediaBlock` + `IMediaBlockInternals` + two `MediaBlockPad`s. The pattern is small enough to memorise. Below is the complete `MyGrayscaleBlock` from the [`CustomGrayscaleBlock` console sample](#sample-app); read it once, then the step-by-step breakdown after it.

```
using System;
using Gst;
using VisioForge.Core.MediaBlocks;

public class MyGrayscaleBlock : MediaBlock, IMediaBlockInternals
{
    private const string TAG = "MyGrayscaleBlock";

    private Element _element;
    private readonly MediaBlockPad _inputPad;
    private readonly MediaBlockPad _outputPad;

    public override MediaBlockType Type => MediaBlockType.Custom;
    public override MediaBlockPad Input => _inputPad;
    public override MediaBlockPad[] Inputs => new[] { _inputPad };
    public override MediaBlockPad Output => _outputPad;
    public override MediaBlockPad[] Outputs => new[] { _outputPad };

    public MyGrayscaleBlock()
    {
        Name = "MyGrayscale";
        _inputPad  = new MediaBlockPad(this, MediaBlockPadDirection.In,  MediaBlockPadMediaType.Video);
        _outputPad = new MediaBlockPad(this, MediaBlockPadDirection.Out, MediaBlockPadMediaType.Video);
    }

    public static bool IsAvailable()
    {
        var factory = ElementFactory.Find("videobalance");
        if (factory == null) return false;
        factory.Dispose();
        return true;
    }

    public override bool Build()
    {
        if (_isBuilt) return true;

        _element = ElementFactory.Make("videobalance", $"videobalance_{Guid.NewGuid():N}");
        if (_element == null)
        {
            Context?.Error(TAG, "Build", "Unable to create videobalance element.");
            return false;
        }

        _element.SetProperty("saturation", new GLib.Value(0.0));
        _pipelineCtx.Pipeline.Add(_element);

        var sink = _element.GetStaticPad("sink");
        var src  = _element.GetStaticPad("src");
        if (sink == null || src == null)
        {
            Context?.Error(TAG, "Build", "Unable to retrieve videobalance static pads.");
            _pipelineCtx.Pipeline.Remove(_element);
            _element.Dispose();
            _element = null;
            return false;
        }

        _inputPad.SetInternalPad(sink);
        _outputPad.SetInternalPad(src);

        _isBuilt = true;
        return true;
    }

    void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
    {
        SetPipeline(pipeline);
        Context = pipeline.GetContext();
    }

    bool IMediaBlockInternals.Build() => Build();
    Gst.Element IMediaBlockInternals.GetElement() => _element;
    VisioForge.Core.GStreamer.Base.BaseElement IMediaBlockInternals.GetCore() => null;

    public void CleanUp()
    {
        _element?.Dispose();
        _element = null;
    }

    protected override void Dispose(bool disposing)
    {
        if (disposing) CleanUp();
        base.Dispose(disposing);
    }
}
```

### Step by step

#### 1. Inherit `MediaBlock`, implement `IMediaBlockInternals`

`MediaBlock` is the public, non-abstract base class. `IMediaBlockInternals` is the public interface the pipeline calls into during preload, build, and teardown. You implement both.

#### 2. Declare the pads in the constructor

A `MediaBlockPad` is the MediaBlocks-level pad. The pipeline connects two `MediaBlockPad`s with `pipeline.Connect(a, b)`; under the covers each one forwards to an underlying GStreamer pad you assign in `Build()` via `SetInternalPad`.

```
_inputPad  = new MediaBlockPad(this, MediaBlockPadDirection.In,  MediaBlockPadMediaType.Video);
_outputPad = new MediaBlockPad(this, MediaBlockPadDirection.Out, MediaBlockPadMediaType.Video);
```

Use `MediaBlockPadMediaType.Audio` for audio elements (e.g. `audioconvert`, `volume`), or one pad of each kind for elements that touch both streams.

#### 3. Override `Type`, `Input/Inputs`, `Output/Outputs`

`MediaBlockType.Custom` is the catch-all enum value for user-authored blocks. The four pad properties return your single pads (singular) or single-element arrays (plural) — the SDK uses one or the other depending on how it is enumerating blocks.

#### 4. Implement `Build()`

This is where the GStreamer side comes alive. `Build()` runs during `pipeline.StartAsync(...)` (or `StartAsync(onlyPreload: true)`), **not in your constructor**. Inside it:

1. Guard `_isBuilt` to make repeat calls a no-op.
2. Create the element with `ElementFactory.Make(name, uniqueInstanceName)`. Pass a unique instance name (`Guid.NewGuid().ToString("N")` works) — GStreamer requires unique element names within a pipeline.
3. Null-check the element. `null` means the plugin is missing or the factory is unavailable on this platform.
4. Apply properties with `element.SetProperty("name", new GLib.Value(...))`. Match the property's GStreamer type exactly (see the supported types table above).
5. **Add the element to the pipeline before retrieving its pads.** The pipeline reference is exposed via the protected field `_pipelineCtx.Pipeline`.
6. Retrieve the element's static pads with `element.GetStaticPad("sink")` / `GetStaticPad("src")` and bind them with `MediaBlockPad.SetInternalPad(...)`.

#### 5. Static `IsAvailable()`

Conventionally every SDK block exposes a static `IsAvailable()` that checks the registry for the underlying element. Callers use this to decide between alternatives or fail fast with a useful diagnostic.

```
public static bool IsAvailable()
{
    var factory = ElementFactory.Find("videobalance");
    if (factory == null) return false;
    factory.Dispose();
    return true;
}
```

#### 6. `IMediaBlockInternals.SetContext`

The pipeline calls this when the block is added. It wires the block to its parent pipeline and stores the GStreamer-level `Context` for error reporting:

```
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
{
    SetPipeline(pipeline);
    Context = pipeline.GetContext();
}
```

`SetPipeline` is a protected method on `MediaBlock` that stores a weak reference to the pipeline and populates the protected `_pipelineCtx` field your `Build()` uses.

#### 7. `CleanUp()` and `Dispose`

`CleanUp()` is called by the pipeline during teardown. Dispose the underlying element and clear the reference. Forward `Dispose(bool)` to `CleanUp` for normal IDisposable lifecycle:

```
public void CleanUp()
{
    _element?.Dispose();
    _element = null;
}

protected override void Dispose(bool disposing)
{
    if (disposing) CleanUp();
    base.Dispose(disposing);
}
```

#### 8. `GetElement` / `GetCore`

`GetElement` exposes the raw `Gst.Element` for advanced inspection. `GetCore` exposes the internal `BaseElement` wrapper used by built-in blocks; user code does not have one, so return `null`.

### Using your block

Once the class compiles, it slots into a pipeline like any other block:

```
var grayscale = new MyGrayscaleBlock();

pipeline.AddBlock(source);
pipeline.AddBlock(grayscale);
pipeline.AddBlock(encoder);
pipeline.AddBlock(sink);

pipeline.Connect(source.Output,    grayscale.Input);
pipeline.Connect(grayscale.Output, encoder.Input);
```

## Adding properties and settings

`MyGrayscaleBlock` hardcodes `saturation = 0`. To expose configurable properties, the SDK convention is a separate settings class passed to the block's constructor:

```
public class MyVideoBalanceSettings
{
    public double Brightness { get; set; } = 0.0;   // -1.0 to 1.0
    public double Contrast   { get; set; } = 1.0;   // 0.0 to 2.0
    public double Saturation { get; set; } = 1.0;   // 0.0 to 2.0 (0 = grayscale)
    public double Hue        { get; set; } = 0.0;   // -1.0 to 1.0
}

public class MyVideoBalanceBlock : MediaBlock, IMediaBlockInternals
{
    public MyVideoBalanceSettings Settings { get; }

    public MyVideoBalanceBlock(MyVideoBalanceSettings settings)
    {
        Settings = settings ?? new MyVideoBalanceSettings();
        // … pads as before
    }

    public override bool Build()
    {
        // … create element as before
        _element.SetProperty("brightness", new GLib.Value(Settings.Brightness));
        _element.SetProperty("contrast",   new GLib.Value(Settings.Contrast));
        _element.SetProperty("saturation", new GLib.Value(Settings.Saturation));
        _element.SetProperty("hue",        new GLib.Value(Settings.Hue));
        // … add to pipeline, bind pads
    }
}
```

For real-time property updates, store a reference to `_element` and expose `Update(Settings settings)` that calls `SetProperty` on a live element. The SDK's `VideoBalanceBlock` uses an `OnUpdate` event on its settings class for this — read it for a fuller example.

## Discovering elements and their properties

Use the `gstreamer-doc` agent skill — or, on Windows, the local `gst-inspect-1.0.exe` at `C:\gstreamer\1.0\msvc_x86_64\bin\gst-inspect-1.0.exe` — to inspect any element before wrapping it:

```
gst-inspect-1.0.exe videobalance
```

The output lists every property (with its GStreamer type and range) and both pad templates (with their caps). Confirm:

- The element exists in the GStreamer install your customers will have.
- The properties you intend to set are named exactly what you think.
- The sink/src pad caps accept `video/x-raw` or whatever your upstream produces — most simple video effects negotiate `video/x-raw` agnostically and need no extra `capsfilter`.

## Lifecycle and caveats

- **`Build()` runs during pipeline preload, not in the constructor.** Do not touch the underlying element from your block's constructor — it doesn't exist yet.
- **Add the element to `_pipelineCtx.Pipeline` *before* you call `GetStaticPad`.** Pads exist as soon as the factory creates the element, but the pipeline manages lifecycle from the moment `Add` is called.
- **Match GStreamer property types exactly.** A `gdouble` property set with an `int` value is a silent no-op. `gst-inspect-1.0` tells you the type.
- **Use unique element instance names.** Two elements with the same name in one `Gst.Pipeline` is an error.
- **Don't use `ConfigureAwait(false)` in SDK-adjacent code.** Project convention; the SDK enforces it.
- **Custom elements with dynamic pads** (decoders, demuxers) belong in `CustomMediaBlock` with `UsePadAddedEvent = true`, not in a hand-written subclass — the bookkeeping for `pad-added` is non-trivial.

## When to prefer a different block type

`MediaBlock` is the right base when you want to **wrap a GStreamer element**. The SDK has two related public blocks for different use cases:

| Block | Use it when |
| --- | --- |
| [`CustomMediaBlock`](../../Special/) | You want Approach A from this guide — wrap a single element or a bin description without subclassing. |
| `CustomTransformBlock` | You want a managed-side transform: input samples arrive in your code via an event, and you push output samples back. No GStreamer-level transformation element. |
| `DataProcessorBlock` | You want to read or modify raw video/audio buffers in managed code without producing different output (pure inspection, frame counting, metadata extraction). |
| `SuperMediaBlock` | You want to group several existing blocks into a single composite block with shared lifecycle. |

## Sample app

The companion sample `CustomGrayscaleBlock` lives in the SDK samples tree under [`Media Blocks SDK/Console/CustomGrayscaleBlock`](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/Console/CustomGrayscaleBlock). It runs both approaches back-to-back and writes one MP4 per approach so you can compare them.

Files:

- `Program.cs` — builds both pipelines.
- `MyGrayscaleBlock.cs` — the typed subclass from this guide.
- `CustomGrayscaleBlock.csproj` — cross-platform console project.

## See also

- [Custom Video Effects and OpenGL Shaders](../custom-video-effects-csharp/) — the SDK's catalog of built-in effect blocks, including the production `GrayscaleBlock` and `VideoBalanceBlock`.
- [Special blocks](../../Special/) — `CustomMediaBlock`, `CustomTransformBlock`, `DataProcessorBlock`, `SuperMediaBlock`.
- [Video Processing blocks](../../VideoProcessing/) — the full set of typed effect blocks.

---END OF PAGE---


## Custom Video Effects and OpenGL Shaders in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/custom-video-effects-csharp/
**Description:** Apply real-time video effects, GLSL shaders, LUT color grading, and pan/zoom animations in C# .NET with VisioForge Media Blocks SDK and GPU acceleration.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Encoding, Effects, Webcam, C#
**API:** LUTProcessorBlock, MediaBlocksPipeline, GLUploadBlock, GLDownloadBlock, GLShaderBlock

# Custom Video Effects and OpenGL Shaders in C# .NET

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VisioForge Media Blocks SDK provides 70+ video processing blocks for real-time effects, GPU-accelerated OpenGL shaders, professional LUT color grading, and animated pan/zoom transformations. Effects are applied by inserting processing blocks into the pipeline between a video source and a renderer or encoder.

## Built-in Video Effects

[MediaBlocksPipeline](#)

All built-in effects follow the same pipeline pattern — insert the effect block between your source and renderer:

```
VideoSource → EffectBlock → VideoRenderer
```

### Gaussian Blur

Apply blur or sharpening with configurable sigma. Positive values blur, negative values sharpen:

```
using VisioForge.Core.MediaBlocks.VideoProcessing;

// Blur with sigma 1.2 (higher = more blur)
var blur = new GaussianBlurBlock(1.2);

pipeline.Connect(videoSource.Output, blur.Input);
pipeline.Connect(blur.Output, videoRenderer.Input);
```

### Noise Reduction (Smooth Filter)

OpenCV-based noise reduction with edge-preserving smoothing:

```
using VisioForge.Core.Types.X.VideoEffects;

var smoothSettings = new SmoothVideoEffect()
{
    FilterSize = 5,       // kernel size (larger = stronger smoothing)
    Tolerance = 128,      // contrast threshold (0-255)
    LumaOnly = true       // smooth brightness only, preserve color
};

var smooth = new SmoothBlock(smoothSettings);

pipeline.Connect(videoSource.Output, smooth.Input);
pipeline.Connect(smooth.Output, videoRenderer.Input);
```

### Color Balance

Adjust brightness, contrast, saturation, and hue in real time:

```
var balance = new VideoBalanceBlock(new VideoBalanceVideoEffect
{
    Brightness = 0.1,    // -1.0 to 1.0 (0 = no change)
    Contrast = 1.2,      // 0.0 to infinity (1 = no change)
    Saturation = 1.5,    // 0.0 to infinity (1 = no change)
    Hue = 0.0            // -1.0 to 1.0 (0 = no change)
});

pipeline.Connect(videoSource.Output, balance.Input);
pipeline.Connect(balance.Output, videoRenderer.Input);
```

### Preset Color Effects

Apply artistic color presets (sepia, heat map, cross-processing, etc.):

```
var colorFx = new ColorEffectsBlock(ColorEffectsPreset.Sepia);

pipeline.Connect(videoSource.Output, colorFx.Input);
pipeline.Connect(colorFx.Output, videoRenderer.Input);
```

## GPU-Accelerated Effects with OpenGL

[MediaBlocksPipeline](#)

OpenGL effects run on the GPU for significantly better performance with HD/4K video. They require uploading video frames to GPU memory and downloading them back:

```
VideoSource → GLUploadBlock → GLEffectBlock → GLDownloadBlock → VideoRenderer
```

### Using Built-in OpenGL Effects

The SDK includes 25+ GPU-accelerated effects:

```
using VisioForge.Core.MediaBlocks.OpenGL;

var glUpload = new GLUploadBlock();
var glBlur = new GLBlurBlock();
var glDownload = new GLDownloadBlock();

pipeline.Connect(videoSource.Output, glUpload.Input);
pipeline.Connect(glUpload.Output, glBlur.Input);
pipeline.Connect(glBlur.Output, glDownload.Input);
pipeline.Connect(glDownload.Output, videoRenderer.Input);
```

### Available OpenGL Effects

| Effect Block | Description |
| --- | --- |
| `GLBlurBlock` | 9x9 separable convolution blur |
| `GLColorBalanceBlock` | Brightness, contrast, hue, saturation |
| `GLGrayscaleBlock` | Grayscale conversion |
| `GLSepiaBlock` | Sepia tone |
| `GLSobelBlock` | Sobel edge detection |
| `GLLaplacianBlock` | Laplacian edge detection |
| `GLFishEyeBlock` | Fisheye lens distortion |
| `GLBulgeBlock` | Bulge distortion |
| `GLTwirlBlock` | Twirl/swirl effect |
| `GLMirrorBlock` | Mirror reflection |
| `GLSqueezeBlock` | Squeeze distortion |
| `GLStretchBlock` | Stretch distortion |
| `GLHeatBlock` | Heat map visualization |
| `GLGlowLightingBlock` | Glow/lighting effect |
| `GLLightTunnelBlock` | Light tunnel effect |
| `GLSinCityBlock` | Sin City (selective desaturation) |
| `GLXRayBlock` | X-ray visualization |
| `GLLumaCrossProcessingBlock` | Luma cross-processing |
| `GLFlipBlock` | GPU flip/mirror |
| `GLDeinterlaceBlock` | GPU deinterlacing |
| `GLTransformationBlock` | Affine transformations |
| `GLAlphaBlock` | Alpha channel / chroma key |
| `GLEquirectangularViewBlock` | 360 equirectangular projection |

## Custom GLSL Shaders

[MediaBlocksPipeline](#)

Write custom GLSL fragment and vertex shaders and apply them to live video in real time. The `GLShaderBlock` executes your shader on the GPU for every video frame.

### Pipeline Architecture

```
SystemVideoSourceBlock → GLUploadBlock → GLShaderBlock → GLDownloadBlock → VideoRendererBlock
```

### Complete Example

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.OpenGL;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.X.OpenGL;
using VisioForge.Core.Types.X.Sources;

await VisioForgeX.InitSDKAsync();

var pipeline = new MediaBlocksPipeline();

// Video source (webcam)
var videoDevices = await DeviceEnumerator.Shared.VideoSourcesAsync();
var videoSource = new SystemVideoSourceBlock(
    new VideoCaptureDeviceSourceSettings(videoDevices[0]));

// Upload frames to GPU memory
var glUpload = new GLUploadBlock();

// Custom GLSL shader — grayscale conversion
var vertexShader = @"
#version 100
#ifdef GL_ES
precision mediump float;
#endif
attribute vec4 a_position;
attribute vec2 a_texcoord;
varying vec2 v_texcoord;
void main() {
    gl_Position = a_position;
    v_texcoord = a_texcoord;
}";

var fragmentShader = @"
#version 100
#ifdef GL_ES
precision mediump float;
#endif
varying vec2 v_texcoord;
uniform sampler2D tex;
void main() {
    vec4 color = texture2D(tex, v_texcoord);
    float gray = dot(color.rgb, vec3(0.299, 0.587, 0.114));
    gl_FragColor = vec4(vec3(gray), color.a);
}";

var shader = new GLShader(vertexShader, fragmentShader);
var shaderBlock = new GLShaderBlock(new GLShaderSettings(shader));

// Download frames back from GPU
var glDownload = new GLDownloadBlock();

// Video renderer
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Build pipeline
pipeline.Connect(videoSource.Output, glUpload.Input);
pipeline.Connect(glUpload.Output, shaderBlock.Input);
pipeline.Connect(shaderBlock.Output, glDownload.Input);
pipeline.Connect(glDownload.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Switching Shaders at Runtime

You can change the shader while the pipeline is running:

```
// Invert color shader
var invertFragment = @"
#version 100
#ifdef GL_ES
precision mediump float;
#endif
varying vec2 v_texcoord;
uniform sampler2D tex;
void main() {
    vec4 color = texture2D(tex, v_texcoord);
    gl_FragColor = vec4(vec3(1.0) - color.rgb, color.a);
}";

shaderBlock.Settings.Fragment = invertFragment;
shaderBlock.Update();  // apply changes without restarting pipeline
```

## Shader Uniforms for Dynamic Effects

[MediaBlocksPipeline](#)

Pass parameters to GLSL shaders at runtime using the `Uniforms` dictionary. This enables dynamic, real-time control over shader behavior.

### Two-Pass Gaussian Blur with Adjustable Radius

```
// Horizontal blur pass
var horizontalSettings = new GLShaderSettings(vertexShader, horizontalFragmentShader);
horizontalSettings.Uniforms["blur_radius"] = 2.0f;
horizontalSettings.Uniforms["tex_width"] = 1920.0f;
var blurH = new GLShaderBlock(horizontalSettings);

// Vertical blur pass
var verticalSettings = new GLShaderSettings(vertexShader, verticalFragmentShader);
verticalSettings.Uniforms["blur_radius"] = 2.0f;
verticalSettings.Uniforms["tex_height"] = 1080.0f;
var blurV = new GLShaderBlock(verticalSettings);

// Pipeline: Source → Upload → H-Blur → V-Blur → Download → Renderer
pipeline.Connect(videoSource.Output, glUpload.Input);
pipeline.Connect(glUpload.Output, blurH.Input);
pipeline.Connect(blurH.Output, blurV.Input);
pipeline.Connect(blurV.Output, glDownload.Input);
pipeline.Connect(glDownload.Output, videoRenderer.Input);
```

### Updating Uniforms at Runtime

```
// Adjust blur radius in response to a slider change
float newRadius = 5.0f;

blurH.Settings.Uniforms["blur_radius"] = newRadius;
blurH.Update();

blurV.Settings.Uniforms["blur_radius"] = newRadius;
blurV.Update();
```

## LUT Color Grading

[MediaBlocksPipeline](#)

Apply professional color grading using 3D Look-Up Table (LUT) files. The `LUTProcessorBlock` transforms every pixel's color through a 3D color cube for cinematic color effects.

### Supported LUT Formats

| Format | Extension | Origin |
| --- | --- | --- |
| Iridas/Resolve | `.cube` | DaVinci Resolve, Adobe |
| After Effects | `.3dl` | Adobe After Effects |
| DaVinci | `.dat` | DaVinci Resolve |
| Pandora | `.m3d` | Pandora |
| CineSpace | `.csp` | CineSpace |

### Basic LUT Application

```
using VisioForge.Core.MediaBlocks.VideoProcessing;
using VisioForge.Core.Types.X.VideoEffects;

var lutPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "cinematic.cube");
var lutProcessor = new LUTProcessorBlock(new LUTVideoEffect(lutPath));

pipeline.Connect(videoSource.Output, lutProcessor.Input);
pipeline.Connect(lutProcessor.Output, videoRenderer.Input);
```

### Side-by-Side Comparison

Use a `TeeBlock` to show original and graded video side by side:

```
using VisioForge.Core.MediaBlocks.Special;

var tee = new TeeBlock(2, MediaBlockPadMediaType.Video);

var lutProcessor = new LUTProcessorBlock(new LUTVideoEffect(lutPath));

// Original output
var rendererOriginal = new VideoRendererBlock(pipeline, null);

// Graded output
var rendererGraded = new VideoRendererBlock(pipeline, null);

pipeline.Connect(videoSource.Output, tee.Input);
pipeline.Connect(tee.Outputs[0], lutProcessor.Input);
pipeline.Connect(lutProcessor.Output, rendererGraded.Input);
pipeline.Connect(tee.Outputs[1], rendererOriginal.Input);
```

### Interpolation Modes

The `LUTVideoEffect` supports three interpolation modes for quality/performance trade-offs:

- **Tetrahedral** — highest quality, best for final output
- **Trilinear** — good balance of quality and speed
- **NearestNeighbor** — fastest, lowest quality

## Pan, Zoom, and Ken Burns Animations

[MediaBlocksPipeline](#)

The `PanZoomBlock` provides static and animated pan/zoom transformations — ideal for Ken Burns effects, region-of-interest viewing, and dynamic video framing.

### Pipeline Setup

```
using VisioForge.Core.MediaBlocks.VideoProcessing;
using VisioForge.Core.Types.X.VideoEffects;

var panZoom = new PanZoomBlock();

pipeline.Connect(fileSource.VideoOutput, panZoom.Input);
pipeline.Connect(panZoom.Output, videoRenderer.Input);
```

### Static Zoom

Zoom into a specific point in the frame:

```
// 2x zoom centered on the middle of the frame
panZoom.SetZoom(new VideoStreamZoomSettings(
    zoomX: 2.0,     // horizontal zoom factor
    zoomY: 2.0,     // vertical zoom factor
    centerX: 0.5,   // center point X (0.0 - 1.0)
    centerY: 0.5    // center point Y (0.0 - 1.0)
));
```

### Static Pan

Shift the visible region:

```
// Pan 100 pixels right, 50 pixels down
panZoom.SetPan(new VideoStreamPanSettings(100, 50));
```

### Dynamic Zoom (Ken Burns Effect)

Animate a smooth zoom transition over a time range:

```
// Slowly zoom from 1x to 2x over 5 seconds starting at current position
var startTime = await pipeline.Position_GetAsync();
var endTime = startTime + TimeSpan.FromSeconds(5);

panZoom.SetDynamicZoom(new VideoStreamDynamicZoomSettings(
    startZoomX: 1.0, startZoomY: 1.0,   // start at normal size
    stopZoomX: 2.0,  stopZoomY: 2.0,     // end at 2x zoom
    startTime: startTime,
    stopTime: endTime
));
```

### Dynamic Pan

Animate a smooth pan movement:

```
panZoom.SetDynamicPan(new VideoStreamDynamicPanSettings(
    startPanX: 0, startPanY: 0,       // start position
    stopPanX: 200, stopPanY: 100,     // end position
    startTime: startTime,
    stopTime: endTime
));
```

### Rect Crop and Pan

Focus on a specific rectangular region of the video:

```
// Show only the region starting at (50, 50) with 400x300 size
panZoom.SetRect(VideoStreamRectSettings.FromPositionAndSize(50, 50, 400, 300));
```

### Resetting Pan/Zoom

Clear all pan/zoom settings to return to the original view:

```
panZoom.SetZoom(null);
panZoom.SetDynamicZoom(null);
panZoom.SetPan(null);
panZoom.SetDynamicPan(null);
panZoom.SetRect(null);
```

## Chaining Multiple Effects

Connect multiple effect blocks in series to build complex processing chains:

```
VideoSource → GaussianBlurBlock → VideoBalanceBlock → LUTProcessorBlock → VideoRenderer
```

```
var blur = new GaussianBlurBlock(0.8);
var balance = new VideoBalanceBlock(new VideoBalanceVideoEffect
{
    Brightness = 0.05,
    Contrast = 1.1
});
var lut = new LUTProcessorBlock(new LUTVideoEffect("cinematic.cube"));

pipeline.Connect(videoSource.Output, blur.Input);
pipeline.Connect(blur.Output, balance.Input);
pipeline.Connect(balance.Output, lut.Input);
pipeline.Connect(lut.Output, videoRenderer.Input);
```

For GPU-accelerated chains, keep frames in GPU memory between effects:

```
pipeline.Connect(videoSource.Output, glUpload.Input);
pipeline.Connect(glUpload.Output, glBlur.Input);
pipeline.Connect(glBlur.Output, glColorBalance.Input);
pipeline.Connect(glColorBalance.Output, glDownload.Input);
pipeline.Connect(glDownload.Output, videoRenderer.Input);
```

## Troubleshooting

### OpenGL Effects Not Working

**Symptom:** Pipeline fails to start or video appears black when using GL effects.

**Solutions:**

- Verify GPU drivers are up to date — OpenGL effects require hardware OpenGL support
- Ensure `GLUploadBlock` and `GLDownloadBlock` are used to transfer frames to/from GPU memory
- Fall back to CPU-based equivalents (e.g., `GaussianBlurBlock` instead of `GLBlurBlock`) on systems without GPU support
- Check `GLShaderBlock.IsAvailable()` before creating OpenGL blocks

### LUT File Not Loading

**Symptom:** `LUTProcessorBlock` throws an exception or has no visible effect.

**Solutions:**

- Verify the LUT file path is correct and the file exists
- Ensure the file format is supported (`.cube`, `.3dl`, `.dat`, `.m3d`, `.csp`)
- Check `LUTProcessorBlock.IsAvailable()` before creating the block
- Use an absolute path or `Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "file.cube")`

### High CPU Usage with Effects

**Symptom:** Performance degrades when applying multiple effects.

**Solutions:**

- Switch from CPU effects to OpenGL GPU-accelerated equivalents
- Reduce video resolution before applying effects (use `VideoResizeBlock`)
- Minimize the number of chained effects — combine operations in a single custom shader when possible
- For two-pass blur, use the single-pass simple blur as a faster alternative

## Frequently Asked Questions

### How do I apply a custom GLSL shader to live video in C#?

Create a `GLShaderBlock` with your vertex and fragment shader source code, then insert it between `GLUploadBlock` and `GLDownloadBlock` in your pipeline. The standard vertex shader passes through position and texture coordinates. Your fragment shader receives the video frame as `uniform sampler2D tex` and outputs to `gl_FragColor`. Use `shaderBlock.Update()` to change shaders at runtime without restarting the pipeline. See the [Custom GLSL Shaders](#custom-glsl-shaders) section for a complete example.

### What LUT file formats does the SDK support for color grading?

The `LUTProcessorBlock` supports five industry-standard 3D LUT formats: Iridas/Resolve `.cube`, After Effects `.3dl`, DaVinci `.dat`, Pandora `.m3d`, and CineSpace `.csp`. The `.cube` format is the most widely used and is exported by DaVinci Resolve, Adobe Premiere, and most color grading tools. Three interpolation modes are available: Tetrahedral (highest quality), Trilinear, and NearestNeighbor.

### Can I chain multiple video effects together in a pipeline?

Yes. Connect effect blocks in series: `Source → Effect1 → Effect2 → Effect3 → Renderer`. Each block processes the output of the previous one. For GPU-accelerated chains, keep frames in OpenGL memory by connecting GL effect blocks directly without inserting `GLDownloadBlock` / `GLUploadBlock` between them — only upload at the start and download at the end.

### How do I create a Ken Burns pan/zoom animation?

Use `PanZoomBlock` with `SetDynamicZoom()` to animate a smooth zoom transition over time. Pass a `VideoStreamDynamicZoomSettings` with start/stop zoom factors and start/stop timestamps. The block interpolates between the values automatically. Combine with `SetDynamicPan()` for simultaneous pan and zoom animation. See the [Pan, Zoom, and Ken Burns Animations](#pan-zoom-and-ken-burns-animations) section for code examples.

### What platforms support OpenGL video effects?

OpenGL effects are supported on Windows, Linux, macOS, and Android — any platform with OpenGL ES 2.0 or higher support. On iOS and macOS, the SDK also provides Metal-accelerated equivalents (`MetalVideoFilterBlock`) for native GPU performance. CPU-based effects (`GaussianBlurBlock`, `SmoothBlock`, `ColorEffectsBlock`, etc.) work on all platforms including iOS.

## See Also

- [Video Processing Blocks Reference](../../VideoProcessing/) — complete list of 70+ processing blocks
- [OpenGL Effects Reference](../../OpenGL/) — GPU-accelerated OpenGL effect settings and types
- [Video Effects Overview](../../../general/video-effects/) — Classic and Cross-Platform effect categories
- [Effects Reference (100+ effects)](../../../general/video-effects/effects-reference/) — detailed parameters for all effects
- [Deployment Guide](../../../deployment-x/) — platform-specific runtime packages
- [Code Samples on GitHub](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK) — shader and effects demos
- [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) — product page and downloads

---END OF PAGE---


## KLV / MISB Metadata in MPEG-TS Streams with C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/klv-metadata-mpegts-csharp/
**Description:** Extract, decode, and mux KLV (MISB 0601 / STANAG 4609) metadata in MPEG-TS streams from C# with the Media Blocks SDK .NET — UAV, ISR, and surveillance video.
**Tags:** Media Blocks SDK, .NET, MPEG-TS, KLV, MISB, STANAG 4609, C#
**API:** MPEGTSDemuxBlock, KLVFileSinkBlock, KLVDecoder, KLVParser, KLVMetadata

# KLV / MISB Metadata in MPEG-TS with C# .NET

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Overview

KLV (Key-Length-Value) is the binary metadata encoding used by MISB / STANAG 4609 MPEG-TS streams to carry geospatial and sensor telemetry alongside video — UAV/drone, ISR, and surveillance feeds. The Media Blocks SDK .NET lets you:

1. **Extract** the KLV metadata stream from an MPEG-TS file.
2. **Parse** MISB ST 0601 elements (or read raw key/value items).
3. **Embed** a KLV payload into an MPEG-TS output.

```
graph LR;
    BasicFileSourceBlock-->MPEGTSDemuxBlock;
    MPEGTSDemuxBlock-- MetadataOutput -->KLVFileSinkBlock;
    MPEGTSDemuxBlock-- VideoOutput -->VideoRendererBlock;
```

The KLV blocks live in `VisioForge.Core.MediaBlocks.Sinks` / `VisioForge.Core.MediaBlocks.Sources`; the decoders live in `VisioForge.Core.Metadata` and `VisioForge.Core.Metadata.KLV`. KLV demux/extract works on Windows, Linux, and macOS.

## Prerequisites

Install the Media Blocks SDK NuGet package and the platform runtime package (for example `VisioForge.CrossPlatform.Core.Windows.x64`). Call `VisioForgeX.InitSDKAsync()` once at startup.

## Extract KLV from an MPEG-TS file

Demux the transport stream and route its **metadata pad** to a `KLVFileSinkBlock`, which writes the `meta/x-klv` packets to a `.klv` file. Pass `renderMetadata: true` so the demuxer exposes its `MetadataOutput` pad.

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;

await VisioForgeX.InitSDKAsync();

var pipeline = new MediaBlocksPipeline();

var fileSource = new BasicFileSourceBlock("mission.ts");

// renderVideo: false, renderMetadata: true -> we only want the KLV metadata pad.
var demux = new MPEGTSDemuxBlock(false, renderMetadata: true);

var klvSink = new KLVFileSinkBlock("mission_metadata.klv");

pipeline.Connect(fileSource.Output, demux.Input);
pipeline.Connect(demux.MetadataOutput, klvSink.Input);

await pipeline.StartAsync();
```

To preview the video at the same time, also connect `demux.VideoOutput` to a `VideoRendererBlock` (build the demuxer with `renderVideo: true`).

## Parse the extracted KLV

For **standard MISB KLV** extracted from an MPEG-TS stream, use `KLVParser`. It decodes MISB ST 0601 local-set elements (precision time stamp, platform/sensor position and orientation, frame-center geolocation, target location, and 100+ more) and handles the **BER-encoded lengths** that MISB packets use:

```
using VisioForge.Core.Metadata.KLV;

var klv = new KLVParser("mission_metadata.klv"); // also accepts a Stream
foreach (var element in klv.Elements)
{
    Console.WriteLine(element.ToString());
}
```

`KLVDecoder` is a lighter raw reader that walks 16-byte keys each followed by a **fixed 4-byte little-endian length**. It does NOT decode BER lengths, so use it only for KLV stored in that fixed-length layout — not for standard MISB transport-stream KLV (use `KLVParser` for that):

```
using VisioForge.Core.Metadata;

// DecodeFromBytes(byte[]) is the in-memory equivalent of DecodeFromFile.
foreach (KLVItem item in KLVDecoder.DecodeFromFile("fixed_length.klv"))
{
    // item.Key   - 16-byte universal key as a hex string
    // item.Value - raw value bytes
    Console.WriteLine($"{item.Key} ({item.Value.Length} bytes)");
}
```

## Embed a KLV payload into an MPEG-TS output

To attach a KLV payload to an MPEG-TS file, set the `MPEGTSSinkSettings.Metadata` property to a `KLVMetadata` source. `KLVMetadata` accepts a `.klv` file path or a `byte[]`.

```
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.Types.X.Metadata;
using VisioForge.Core.Types.X.Sinks;

var tsSettings = new MPEGTSSinkSettings("output.ts")
{
    Metadata = new KLVMetadata("mission_metadata.klv"),
};

var tsSink = new MPEGTSSinkBlock(tsSettings);
// Connect your video (and audio) producers to tsSink, then start the pipeline.
```

Static payload, not a re-timed metadata track

`KLVMetadata` loads the whole `.klv` as a single `byte[]`, and the muxer embeds it without per-packet timestamps. This attaches a **static** KLV payload to the output — it does not reconstruct the original frame-accurate, PCR/PTS-synchronized metadata track. For applications that need per-frame KLV synchronized to the video, drive the KLV from a live source as it is produced rather than re-embedding a flat file.

## Record live KLV while capturing (Video Capture SDK)

When capturing a MISB IP-camera/UAV feed with the [Video Capture SDK .NET](https://www.visioforge.com/video-capture-sdk-net) `VideoCaptureCore` engine, enable KLV on the MPEG-TS output to pass the metadata through to the recording:

```
// In-process MF muxer output:
videoCapture.Output_Format = new MPEGTSOutput { KLVEnabled = true };

// Or external ffmpeg.exe pipe output:
videoCapture.Network_Streaming_Output = new FFMPEGEXEOutput
{
    OutputMuxer = OutputMuxer.MPEGTS,
    KLVEnabled = true,
    UsePipe = true,
};
```

Subscribe to `VideoCaptureCore.OnDataFrameBuffer` and filter for `DataFrameType.KLV` to read the live KLV packets as they arrive. See the `ip-camera-klv-mpegts-recorder` code snippet under [`Video Capture SDK/_CodeSnippets`](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/_CodeSnippets).

## Demos

- **KLV Demo** (WPF) — [KLV Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/KLV%20Demo) — extract KLV from an MPEG-TS file and parse MISB 0601 elements in a viewer.
- **ip-camera-klv-mpegts-recorder** (code snippet) — [ip-camera-klv-mpegts-recorder](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/_CodeSnippets/ip-camera-klv-mpegts-recorder) — capture a MISB IP camera and record/restream KLV in MPEG-TS.

## See also

- [MPEG-TS Stream Analyzer Block](../../Special/TSAnalyzerBlock/) — PAT/PMT/PCR, per-PID bitrate, and TR 101 290 compliance.
- [Record a UDP MPEG-TS Stream Without Re-encoding](../udp-mpegts-record-without-reencoding/)
- [Media Demuxer Blocks](../../Demuxers/)
- [Sinks — KLV File Sink](../../Sinks/#klv-file-sink)

---END OF PAGE---


## Live Subtitles and Speech-to-Text in C# .NET (Whisper)
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/live-subtitles-whisper-csharp/
**Description:** Transcribe audio and video to text or live subtitles in C# with the Media Blocks SDK .NET using a local Whisper model and Silero VAD — no cloud, fully offline.
**Tags:** Media Blocks SDK, .NET, Whisper, Speech-to-Text, Subtitles, VAD, C#
**API:** SpeechToTextBlock, SpeechToTextSettings, SileroVadSettings, SubtitleRenderer, SubtitleStyle, SubtitleWriter, SubtitleFormat, SpeechRecognizedEventArgs

# Live Subtitles and Speech-to-Text in C# .NET

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Overview

`SpeechToTextBlock` adds **local, offline speech recognition** to any Media Blocks pipeline. It runs the [Whisper](https://github.com/openai/whisper) ASR model (through [Whisper.net](https://github.com/sandrohanea/whisper.net), the whisper.cpp / GGML backend) on the CPU or an NVIDIA GPU (CUDA), with optional [Silero VAD](https://github.com/snakers4/silero-vad) voice-activity detection to split speech into clean segments. Nothing is sent to the cloud.

The block sits **inline** in the audio path — audio passes through unchanged — and raises an `OnSpeechRecognized` event with timed text segments. Use it to:

1. **Transcribe a media file** to text, SRT, or VTT (lossless, paced to the transcriber).
2. **Caption a live source** (microphone, capture card, RTSP camera) in real time.

```
graph LR;
    Source-->SpeechToTextBlock;
    SpeechToTextBlock-->AudioRendererBlock;
    SpeechToTextBlock-. OnSpeechRecognized .->App[Your app];
```

The block lives in the `VisioForge.Core.MediaBlocks.AI` namespace and ships in the **VisioForge AI Whisper** add-on — NuGet package `VisioForge.DotNet.Core.AI.Whisper` (assembly `VisioForge.Core.AI.Whisper`), built on `Whisper.net`. It needs the usual platform runtime package (for example `VisioForge.CrossPlatform.Core.Windows.x64`) and works on Windows, Linux, and macOS.

## Models

The Whisper GGML weights and the Silero VAD model are **downloaded at runtime** — neither is shipped inside the NuGet packages. Cache them once and reuse the local files:

- **Whisper GGML model** (`ggml-*.bin`): download with Whisper.net's `WhisperGgmlDownloader`, or fetch a `ggml-*.bin` from the whisper.cpp model repository.
- **Silero VAD model** (`silero_vad.onnx`, MIT): from the [silero-vad](https://github.com/snakers4/silero-vad) repository.

```
using Whisper.net.Ggml;

// Download the "base" Whisper model to a local cache the first time, then reuse it.
var modelsDir = Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "VisioForge", "models");
Directory.CreateDirectory(modelsDir);

var whisperModelPath = Path.Combine(modelsDir, "ggml-base.bin");
if (!File.Exists(whisperModelPath))
{
    using var modelStream = await WhisperGgmlDownloader.Default.GetGgmlModelAsync(GgmlType.Base);
    using var fileStream = File.Create(whisperModelPath);
    await modelStream.CopyToAsync(fileStream);
}

// Silero VAD model — download silero_vad.onnx into the same cache (see "Models" above).
var sileroModelPath = Path.Combine(modelsDir, "silero_vad.onnx");
```

Pick the model size by the accuracy/speed/RAM trade-off you need. `SpeechToTextSettings.ModelSize` is informational (it lets your app label or choose a download); the file actually loaded is always `WhisperModelPath`.

| `WhisperModelSize` | Notes |
| --- | --- |
| `Tiny` / `TinyQuantized` | Fastest, lowest accuracy. |
| `Base` | Good real-time CPU default. |
| `Small` / `Medium` | Higher accuracy, heavier. |
| `LargeV3` / `LargeV3Turbo` | Highest accuracy; GPU recommended. |

## Transcribe a media file

Transcription is lossless: the block paces the source to exactly the transcription throughput, so nothing is dropped and the pipeline runs as fast as Whisper can keep up. Pair it with a non-synced sink so no real-time clock caps the speed.

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AI;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Special; // NullRendererBlock
using VisioForge.Core.Types;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.AI;
using VisioForge.Core.Types.X.Sources;

await VisioForgeX.InitSDKAsync();

var pipeline = new MediaBlocksPipeline();

var settings = new SpeechToTextSettings(whisperModelPath)
{
    Language = "auto",                          // ISO 639-1 code ("en", "es", "fr") or "auto"
    Provider = OnnxExecutionProvider.Auto,      // CUDA when available, else CPU
    EnableVad = true,                           // segment speech with Silero VAD
    OutputSrtPath = "subtitles.srt",            // optional side-car SRT (VTT via OutputVttPath)
};
settings.Vad.ModelPath = sileroModelPath;       // path to silero_vad.onnx

// Audio-only source from a file.
var source = new UniversalSourceBlock(
    await UniversalSourceSettings.CreateAsync("input.mp4", renderVideo: false, renderAudio: true));

var stt = new SpeechToTextBlock(settings);
stt.OnSpeechRecognized += (s, e) =>
{
    foreach (var seg in e.Segments)
    {
        if (!string.IsNullOrWhiteSpace(seg.Text))
        {
            Console.WriteLine($"[{seg.StartTime:hh\\:mm\\:ss}] {seg.Text.Trim()}");
        }
    }
};

// Non-synced null sink: no real-time clock, so the run is bounded only by transcription speed.
var sink = new NullRendererBlock(MediaBlockPadMediaType.Audio) { IsSync = false };

pipeline.Connect(source.AudioOutput, stt.Input);
pipeline.Connect(stt.Output, sink.Input);

await pipeline.StartAsync();
```

Setting `OutputSrtPath` (or `OutputVttPath`) makes the block write a subtitle file directly as final segments are recognized — no extra code needed.

## Caption a live source

The same block captions a live capture device — connect a microphone source instead of a file. The block transcribes inline and never drops audio: it paces the source to Whisper. Whisper Base runs well above real time, so a typical microphone is not throttled; if the model is slower than real time the source is held back to transcription speed rather than losing samples.

```
using VisioForge.Core.MediaBlocks.AudioRendering;
using VisioForge.Core.MediaBlocks.Sources;

// Pick the first system microphone.
var audioDevices = await SystemAudioSourceBlock.GetDevicesAsync();
var mic = new SystemAudioSourceBlock(audioDevices[0].CreateSourceSettings());

var settings = new SpeechToTextSettings(whisperModelPath)
{
    Language = "en",
    Provider = OnnxExecutionProvider.Auto,
    EnableVad = true,
};
settings.Vad.ModelPath = sileroModelPath;

var stt = new SpeechToTextBlock(settings);
stt.OnSpeechRecognized += (s, e) =>
{
    // Raised on the GStreamer streaming thread — marshal to the UI thread before touching UI.
    foreach (var seg in e.Segments)
    {
        Console.WriteLine(seg.Text);
    }
};

var audioRenderer = new AudioRendererBlock();

pipeline.Connect(mic.Output, stt.Input);          // audio passes through the block unchanged
pipeline.Connect(stt.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

## Render live subtitles on video

`SpeechToTextBlock` is audio-only, so it does not draw captions itself. For on-screen subtitles, add an `OverlayManagerBlock` to the video branch and connect `SpeechToTextBlock.OnSpeechRecognized` to `SubtitleRenderer.OnSpeechRecognized`.

```
using SkiaSharp;
using VisioForge.Core.AI.Whisper.Subtitles;
using VisioForge.Core.MediaBlocks.VideoProcessing;
using VisioForge.Core.MediaBlocks.VideoRendering;

var overlay = new OverlayManagerBlock();
var videoRenderer = new VideoRendererBlock(pipeline, videoView) { IsSync = false };

var subtitleRenderer = new SubtitleRenderer(
    overlay,
    new SubtitleStyle
    {
        X = 40,
        Y = 380,
        FontName = "Arial",
        FontSize = 30,
        Color = SKColors.White,
        MinDisplay = TimeSpan.FromSeconds(1.5),
        MaxDisplay = TimeSpan.FromSeconds(6),
    });

stt.OnSpeechRecognized += subtitleRenderer.OnSpeechRecognized;

pipeline.Connect(source.VideoOutput, overlay.Input);
pipeline.Connect(overlay.Output, videoRenderer.Input);
```

`SubtitleRenderer` drives a single text overlay, shows the latest recognized caption, and hides it automatically after the segment duration clamped to `MinDisplay..MaxDisplay`. `OnSpeechRecognized` is raised on the GStreamer streaming thread; marshal to the UI thread before touching UI-only objects if your platform requires it. Dispose the renderer when stopping the pipeline so the overlay and timer are removed.

| `SubtitleStyle` property | Default | Description |
| --- | --- | --- |
| `FontName` / `FontSize` | `Arial` / `32` | Text font. |
| `Color` | `White` | Text color. |
| `X` / `Y` | `50` / `50` | Overlay position in pixels. |
| `MinDisplay` / `MaxDisplay` | `1.5 s` / `6 s` | Minimum and maximum on-screen time for each caption. |

## Recognition results

`OnSpeechRecognized` is raised on the **GStreamer streaming thread** and carries a `SpeechRecognizedEventArgs`:

- `Segments` — a `SpeechSegment[]` (one event may carry several segments).
- `Timestamp` — the media time the segments belong to.

Each `SpeechSegment` has:

| Property | Description |
| --- | --- |
| `Text` | The recognized text. |
| `StartTime` / `EndTime` | Span on the media timeline (ready for SRT/VTT or an overlay schedule). |
| `Language` | Detected/used language (ISO 639-1), or `null`. |
| `Confidence` | Average token confidence (0..1), or 0 when the model does not report it. |
| `IsFinal` | Always `true` today (reserved for future interim hypotheses). |

## Key settings

| Property | Default | Description |
| --- | --- | --- |
| `WhisperModelPath` | — | Absolute path to the Whisper GGML model (`ggml-*.bin`). Required. |
| `Language` | `"auto"` | ISO 639-1 code or `"auto"` for detection. |
| `Task` | `Transcribe` | `Transcribe` (source language) or `Translate` (to English). |
| `Provider` | `Auto` | `CPU` or `CUDA` are meaningful (GGML has no DirectML); `Auto` picks CUDA when present, else CPU. |
| `DeviceId` | `0` | GPU device id when a GPU provider is used. |
| `Threads` | `0` | CPU threads; `0` lets Whisper.net choose. |
| `EnableVad` | `true` | Use Silero VAD to segment speech. Disable for fixed-window chunking. |
| `Vad` | (defaults) | `SileroVadSettings` — set `Vad.ModelPath` to `silero_vad.onnx`. |
| `FixedWindowSeconds` | `5` | Window length when `EnableVad = false` (clamped to 1–30 s). |
| `OutputSrtPath` | `null` | Optional side-car `.srt` written as segments finalize. |
| `OutputVttPath` | `null` | Optional side-car `.vtt` (WebVTT). |

`SileroVadSettings` exposes `SpeechThreshold` (0.5), `MinSilenceMs` (100), `MinSpeechMs` (250), `SpeechPadMs` (30), and `MaxSpeechMs` (15000) to tune segmentation, plus its own `Provider`/`DeviceId`.

Call the static `SpeechToTextBlock.IsAvailable()` to verify the AI Whisper redistributable is present before building a pipeline.

## Subtitle files

The easiest way to create side-car subtitles is to set `OutputSrtPath` or `OutputVttPath` in `SpeechToTextSettings`. The block creates a `SubtitleWriter` internally and writes final segments as they are recognized.

Use `SubtitleWriter` directly when you want to route recognized text yourself:

```
using VisioForge.Core.AI.Whisper.Subtitles;

// Keep the writer alive for the whole pipeline run; dispose it when you stop the pipeline.
var writer = new SubtitleWriter("captions.vtt", SubtitleFormat.Vtt);

stt.OnSpeechRecognized += (sender, e) =>
{
    foreach (var segment in e.Segments)
    {
        writer.Add(segment);
    }
};
```

`SubtitleFormat.Srt` writes numbered SubRip cues with `HH:MM:SS,mmm` timestamps. `SubtitleFormat.Vtt` writes a `WEBVTT` header and `HH:MM:SS.mmm` timestamps. `SubtitleWriter.Add()` ignores empty and non-final segments. `FormatSrtTimestamp()` and `FormatVttTimestamp()` are public helpers for custom writers.

## Demos

- **Live Subtitles** (Console) — [Live Subtitles](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/Console/Live%20Subtitles) — lossless file transcription with progress reporting.
- **Live Subtitles Demo** (WPF) — [Live Subtitles Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Live%20Subtitles%20Demo) — live microphone/camera captioning with an on-screen overlay.
- **Live Subtitles MB** (MAUI) — [Live Subtitles MB](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/MAUI/Live%20Subtitles%20MB).

## See also

- [AI in VisioForge .NET SDK](../../../general/ai/)
- [ElevenLabs Text-to-Speech and Voice Cloning](../../ElevenLabs/)

---END OF PAGE---


## MPEG-TS Analysis in C# .NET: VisioForge vs ffprobe
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/mpeg-ts-analysis-vs-ffprobe/
**Description:** In-process .NET MPEG-TS analysis with live ETSI TR 101 290 monitoring — how the Media Blocks SDK TS Analyzer compares to ffprobe and broadcast analyzers.
**Tags:** Media Blocks SDK, .NET, MPEG-TS, Analysis, TR 101 290, ffprobe, Streaming, C#
**API:** TSAnalyzerBlock, TSAnalyzerReport, TSAnalyzerSettings

# MPEG-TS Analysis in C#: VisioForge vs ffprobe

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Why this matters

ffprobe is a superb command-line tool for a quick look at a media file. But the moment you need transport-stream analysis **inside a .NET application** — a live monitoring dashboard, an ingest validator, an automated QC gate — the CLI model starts working against you: you have to spawn a separate process, capture its text or JSON output, parse it, and you still only get a one-shot snapshot with no compliance framework.

The [Media Blocks SDK .NET](https://www.visioforge.com/media-blocks-sdk-net) `TSAnalyzerBlock` is built for exactly that job. It is an **in-process, live, broadcast-grade MPEG-TS monitor** that reports strongly-typed results continuously, with full ETSI **TR 101 290** Priority 1/2/3 compliance — something ffprobe simply does not provide.

## What sets the TS Analyzer apart

### 1. In-process, strongly-typed — no CLI, no text parsing

You connect a source block to the analyzer and read a `TSAnalyzerReport` object. No `Process.Start`, no stdout capture, no brittle string/JSON parsing, no version-dependent output format to track. Every metric is a typed property you can bind, log, or assert on directly.

### 2. Live and event-driven

ffprobe is one-shot: it runs, prints, exits. The `TSAnalyzerBlock` raises `OnAnalysisUpdated` on a configurable cadence (every second by default) for the entire life of the stream — perfect for real-time dashboards, drift detection, and alerting. A final report is delivered at end-of-stream.

### 3. Broadcast-grade TR 101 290 — built in

The analyzer evaluates the full TR 101 290 Priority 1/2/3 check list (sync loss, PAT/PMT/PID errors, continuity-count errors, transport errors, CRC errors, PCR/PTS errors, SDT/EIT/TDT/NIT errors) and returns each check with its priority, error count, and pass/fail status. ffprobe has no equivalent compliance framework — you would have to build one yourself on top of its output.

### 4. Passthrough mode — analyze while you record or relay

In `InputOutput` mode the original transport stream is forwarded unchanged to the next block, so you can validate a feed **at the same time** as you record or restream it — zero re-mux, one pipeline. ffprobe sits outside your media path entirely.

### 5. One API, any source, every platform

File, UDP (unicast and multicast), and SRT all feed the same analyzer through the same API, on Windows, macOS, Linux, iOS, and Android.

## Feature comparison

The matrix below reflects the **current** capabilities of the `TSAnalyzerBlock`. ✅ = supported, ⚠️ = partial/indirect, ❌ = not available.

| Capability | VisioForge TS Analyzer | ffprobe |
| --- | --- | --- |
| Packet size 188/192 auto-detect | ✅ | ✅ |
| PAT/PMT, programs, PCR PID | ✅ | ✅ |
| stream\_type → codec | ✅ | ✅ |
| Per-PID bitrate + packet count | ✅ | ⚠️ |
| Per-PID instantaneous + peak bitrate | ✅ | ❌ |
| Continuity-counter errors | ✅ | ⚠️ |
| PCR interval min/avg/max + discontinuities | ✅ | ❌ |
| PCR jitter (max) + repetition >40 ms | ✅ | ❌ |
| PCR accuracy / drift (ppm) | ⚠️ | ❌ |
| Transport-error indicator | ✅ | ⚠️ |
| Null % / stuffing / effective bitrate | ✅ | ❌ |
| Scrambling (TSC + free\_CA\_mode) | ✅ | ⚠️ |
| PTS/DTS presence + A/V sync offset | ✅ | ✅ |
| SDT → service name / provider / type | ✅ | ⚠️ |
| Audio language (ISO 639, PMT) | ✅ | ✅ |
| NIT network name; TDT/TOT stream UTC | ✅ | ⚠️ |
| EIT → EPG events | ✅ (opt-in) | ⚠️ |
| Unreferenced PID detection | ✅ | ❌ |
| Codec resolution / profile / level / chroma / aspect | ✅ (H.264/HEVC/MPEG-2) | ✅ |
| CRC-32 PSI validation | ✅ | ⚠️ |
| **Structured TR 101 290 P1/P2/P3** | ✅ | ❌ |
| **In-process .NET API (no CLI / parsing)** | ✅ | ❌ |
| **Live continuous monitoring (events)** | ✅ | ❌ |
| **Passthrough (analyze while recording/relaying)** | ✅ | ❌ |
| Cross-platform (Windows/macOS/Linux/mobile) | ✅ | ✅ |

A few honest notes so the table stays trustworthy. Codec coverage is per-attribute, not uniform: **resolution** is parsed for H.264, HEVC, and MPEG-2; **profile, level, and chroma** for H.264/HEVC only; **aspect ratio and frame rate** from the MPEG-1/2 sequence header (not yet from the H.264/HEVC VUI). The PCR clock **drift in ppm** field is reserved and not yet computed (jitter and repetition are). ffprobe also remains excellent at exhaustive per-codec metadata and supports a far wider range of container/codec formats beyond MPEG-TS.

## When to use which

- **Reach for ffprobe** when you want a quick terminal check of an arbitrary media file, or you are scripting a one-off in a shell and the format may not be MPEG-TS.
- **Reach for the `TSAnalyzerBlock`** when transport-stream analysis needs to live **inside your .NET app** — continuous monitoring, TR 101 290 compliance gating, live dashboards/alerts, or analyzing a feed while you simultaneously record or relay it.

They are not mutually exclusive: many teams use ffprobe at the desk and ship VisioForge in the product.

## Next steps

- [MPEG-TS Stream Analyzer Block](../../Special/TSAnalyzerBlock/) — the full block reference: modes, settings, and the complete report model.
- [Analyze and validate an MPEG-TS stream in C#](../mpeg-ts-stream-validation-csharp/) — a step-by-step task guide.

---END OF PAGE---


## Analyze and Validate MPEG-TS Transport Streams in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/mpeg-ts-stream-validation-csharp/
**Description:** Step-by-step C# guide to analyze a file or live UDP/SRT MPEG-TS stream, read ETSI TR 101 290 results, and alert on errors with the Media Blocks SDK .NET.
**Tags:** Media Blocks SDK, .NET, MPEG-TS, Analysis, TR 101 290, UDP, SRT, C#
**API:** TSAnalyzerBlock, TSAnalyzerSettings, TSAnalyzerReport, UDPRAWMPEGTSSourceBlock

# Analyze and Validate MPEG-TS Streams in C# .NET

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Overview

This guide shows how to analyze and validate an MPEG-TS transport stream from C# using the [Media Blocks SDK .NET](https://www.visioforge.com/media-blocks-sdk-net) `TSAnalyzerBlock`. You will:

1. Analyze a local `.ts` / `.m2ts` file and read the final report.
2. Monitor a **live** `udp://` or `srt://` feed with periodic updates.
3. Read **ETSI TR 101 290** results and raise an alert when the stream is non-compliant.
4. Analyze a feed **while you record it** using passthrough mode.

For the full API reference (every setting and report field), see the [MPEG-TS Stream Analyzer Block](../../Special/TSAnalyzerBlock/) page.

## Prerequisites

Install the Media Blocks SDK NuGet package and the platform runtime package:

- `VisioForge.DotNet.MediaBlocks`
- A platform runtime, e.g. `VisioForge.CrossPlatform.Core.Windows.x64` on Windows.

Initialize the SDK once at startup:

```
using VisioForge.Core;

await VisioForgeX.InitSDKAsync();
```

The namespaces used throughout this guide:

```
using System;
using System.Linq;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.Types.X;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.Special;
```

## 1. Analyze a file

For a file, run the pipeline to end-of-stream and read the final report. Connect the analyzer in `Input` mode (terminal):

```
var pipeline = new MediaBlocksPipeline();

var source = new BasicFileSourceBlock("stream.ts");
var analyzer = new TSAnalyzerBlock(TSAnalyzerMode.Input);

// Signal completion when the pipeline stops on its own (end-of-stream).
var completed = new TaskCompletionSource<bool>();
pipeline.OnStop += (s, e) => completed.TrySetResult(true);

pipeline.Connect(source.Output, analyzer.Input);

await pipeline.StartAsync();
await completed.Task;             // wait for end-of-stream
await pipeline.StopAsync();

TSAnalyzerReport report = analyzer.GetReport();

Console.WriteLine($"Packet size: {report.PacketSize}  |  total: {report.TotalBitrateKbps:F0} kbps");
Console.WriteLine($"Programs: {report.Programs.Count}  |  PAT: {(report.HasPAT ? "yes" : "no")}");

foreach (var program in report.Programs)
{
    var name = string.IsNullOrEmpty(program.ServiceName) ? "(no name)" : program.ServiceName;
    Console.WriteLine($"Program {program.ProgramNumber} \"{name}\" (PMT {program.PmtPid}, PCR {program.PcrPid})");

    foreach (var es in program.Streams)
    {
        var lang = string.IsNullOrEmpty(es.Language) ? "" : $" [{es.Language}]";
        Console.WriteLine($"    PID {es.Pid}  {es.Kind}  {es.Codec}{lang}");
    }
}
```

## 2. Monitor a live stream

For a live `udp://` or `srt://` feed, subscribe to `OnAnalysisUpdated` and read each periodic snapshot. Set `StatisticsInterval` to control the cadence.

```
var pipeline = new MediaBlocksPipeline();

// Live UDP multicast (raw MPEG-TS, no demux)
var source = new UDPRAWMPEGTSSourceBlock(new UDPRAWMPEGTSSourceSettings("udp://239.0.0.1:1234"));

var analyzer = new TSAnalyzerBlock(
    TSAnalyzerMode.Input,
    new TSAnalyzerSettings { StatisticsInterval = TimeSpan.FromSeconds(1) });

analyzer.OnAnalysisUpdated += (sender, e) =>
{
    if (e.IsFinal)
    {
        return;     // end-of-stream report; periodic snapshots have IsFinal == false
    }

    TSAnalyzerReport report = e.Report;
    Console.WriteLine(
        $"{report.TotalBitrateKbps:F0} kbps total, " +
        $"{report.EffectiveBitrateKbps:F0} kbps effective, " +
        $"programs: {report.Programs.Count}");
};

pipeline.Connect(source.Output, analyzer.Input);

await pipeline.StartAsync();
// ... keep running while you monitor ...
```

To feed SRT instead of UDP, swap the source:

```
var srtSettings = await SRTSourceSettings.CreateAsync(new Uri("srt://server:9000"), ignoreMediaInfoReader: true);
var source = new SRTRAWSourceBlock(srtSettings);
```

> **Threading.** Periodic `OnAnalysisUpdated` callbacks run on a background timer thread. In a UI app, marshal to the UI thread before updating controls — e.g. `Dispatcher.BeginInvoke(() => UpdateUI(e.Report));` in WPF.

## 3. Read TR 101 290 and alert on errors

The TR 101 290 report groups errors by priority. A common pattern is to alert whenever a Priority 1 (critical) error appears, and to log the individual failing checks:

```
analyzer.OnAnalysisUpdated += (sender, e) =>
{
    var tr = e.Report.Tr101290;
    if (tr == null || tr.AllOk)
    {
        return;     // TR 101 290 disabled, or the stream is fully compliant
    }

    if (tr.P1Count > 0)
    {
        RaiseAlert($"Critical TR 101 290 (P1) errors: {tr.P1Count}");
    }

    foreach (var check in tr.Checks.Where(c => c.Count > 0))
    {
        Console.WriteLine($"P{check.Priority} {check.Name}: {check.Count}");
    }
};
```

`tr.P1Count` / `P2Count` / `P3Count` give you the per-priority totals; `tr.Checks` lets you drill into a specific failing measurement (for example `PCR_repetition_error` or `Continuity_count_error`). Use `tr.AllOk` as a single-line compliance gate.

## 4. Analyze while recording (passthrough)

To validate a feed and record it in the same pipeline, create the analyzer in `InputOutput` mode and connect its `Output` to a sink. The transport stream is forwarded unchanged, so the recording is a bit-exact copy:

```
var pipeline = new MediaBlocksPipeline();

var source = new UDPRAWMPEGTSSourceBlock(new UDPRAWMPEGTSSourceSettings("udp://239.0.0.1:1234"));

// Passthrough analyzer: forwards the stream while analyzing it
var analyzer = new TSAnalyzerBlock(TSAnalyzerMode.InputOutput);
analyzer.OnAnalysisUpdated += (s, e) => { /* monitor while recording */ };

var sink = new MPEGTSSinkBlock(new MPEGTSSinkSettings("recording.ts"));

pipeline.Connect(source.Output, analyzer.Input);
pipeline.Connect(analyzer.Output, sink.Input);

await pipeline.StartAsync();
```

## Troubleshooting

- **`HasPAT` is false / no programs.** The input is probably not a valid MPEG-TS byte stream, or the packet size was misdetected. Force it via `TSAnalyzerSettings.PacketSize` (`Size188` or `Size192`), or check the source URI.
- **Many `PCR_repetition_error` entries on a valid file.** This is expected when the muxer emits PCR slower than the 40 ms TR 101 290 limit (common for file-oriented muxing). The stream still plays; it is simply not 40 ms-PCR compliant.
- **`GetReport()` returns null.** The block has not been built yet — call it after `StartAsync()`.
- **No multicast packets received.** Verify `AutoJoinMulticast` is `true` (the default) and set `MulticastInterface` if the host has multiple network interfaces.
- **High CPU on a heavy stream.** Disable stages you do not need via `TSAnalyzerSettings` — `ParseEPG` is off by default; you can also turn off `ParseCodecDetails` or `TrackPtsDts`.

## Frequently asked questions

### How do I analyze a live UDP multicast MPEG-TS stream in C#?

Create a `UDPRAWMPEGTSSourceBlock` with a `udp://group:port` URI, connect its `Output` to a `TSAnalyzerBlock` in `Input` mode, and subscribe to `OnAnalysisUpdated` for periodic snapshots. See [section 2](#2-monitor-a-live-stream).

### Can I check ETSI TR 101 290 compliance from .NET?

Yes. With `ValidateTR101290` enabled (the default), `report.Tr101290` exposes the Priority 1/2/3 check list with per-check counts and pass/fail status, plus `P1Count`/`P2Count`/`P3Count` totals and an `AllOk` flag. See [section 3](#3-read-tr-101-290-and-alert-on-errors).

### Can I record a stream and analyze it at the same time?

Yes. Use `TSAnalyzerMode.InputOutput` and connect the analyzer's `Output` to a sink such as `MPEGTSSinkBlock`. The stream is forwarded unchanged. See [section 4](#4-analyze-while-recording-passthrough).

## See also

- [MPEG-TS Stream Analyzer Block](../../Special/TSAnalyzerBlock/) — the complete block reference.
- [MPEG-TS Analysis in C#: VisioForge vs ffprobe](../mpeg-ts-analysis-vs-ffprobe/) — positioning and feature comparison.

---END OF PAGE---


## Multi-Camera RTSP Grid in C# .NET for 4x4 NVR Walls
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/multi-camera-rtsp-grid/
**Description:** Build a 4×4 NVR-style RTSP camera wall in C# / .NET with VisioForge Media Blocks SDK. WPF and MAUI examples, synchronized start, low-latency tuning.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Android, iOS, WPF, MAUI, GStreamer, Streaming, Decoding, Mixing, IP Camera, RTSP, ONVIF, H.264, C#, NuGet
**API:** VideoView, RTSPPlayEngine, VideoRendererBlock, RTSPSourceSettings, IVideoView

# Multi-Camera RTSP Grid — 4×4 NVR Wall in C# / .NET

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Cross-platform support

The Media Blocks SDK runs on **Windows, macOS, Linux, Android, and iOS** via GStreamer — the WPF and MAUI examples below cover the full cross-platform story. See the [platform support matrix](../../../platform-matrix/) for codec and hardware-acceleration details, and the [Linux deployment guide](../../../deployment-x/Ubuntu/) for Ubuntu / NVIDIA Jetson / Raspberry Pi setup.

This guide shows how to build a 4×4 live preview grid (16 RTSP cameras at once) using the VisioForge Media Blocks SDK — the classic NVR / video wall / surveillance dashboard layout. You'll get a reusable `RTSPPlayEngine` helper class plus full XAML + code-behind examples for WPF and MAUI, including the synchronized-start pattern that keeps all 16 streams frame-aligned on screen.

## Architecture — One Pipeline per Camera

The Media Blocks SDK supports two ways to show multiple videos at once, and picking the right one matters:

- **One pipeline per camera, one `VideoRendererBlock` per cell** (this guide). Each camera gets its own `MediaBlocksPipeline` + `RTSPSourceBlock` + `VideoRendererBlock`, and each `VideoRendererBlock` draws into its own `VideoView` on the UI. This is what an NVR wall needs — 16 independent streams, each resizable, each restartable on its own.
- **One pipeline with `VideoMixerBlock`** compositing all sources into a single output frame. Useful when you want a single merged video (stream the whole wall out as one RTMP feed, record it as one MP4). Not what you want for an interactive preview grid — you lose independent control.

This guide uses the first pattern. The topology for 16 cameras:

```
┌───────────────────────┐     ┌──────────────────────┐
│  RTSPSourceBlock #0   │ ──► │ VideoRendererBlock #0 │ ──► videoView[0,0]
└───────────────────────┘     └──────────────────────┘

┌───────────────────────┐     ┌──────────────────────┐
│  RTSPSourceBlock #1   │ ──► │ VideoRendererBlock #1 │ ──► videoView[0,1]
└───────────────────────┘     └──────────────────────┘

                           ... ×16 independent pipelines ...
```

## Required NuGet Packages

**WPF (Windows x64)**:

- [VisioForge.DotNet.Core.UI.WPF](https://www.nuget.org/packages/VisioForge.DotNet.Core.UI.WPF/) — WPF `VideoView` control
- [VisioForge.CrossPlatform.Core.Windows.x64](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.Windows.x64/) — GStreamer runtime for Windows x64

**MAUI (Windows / Android / iOS / macCatalyst)**:

- [VisioForge.DotNet.Core.UI.MAUI](https://www.nuget.org/packages/VisioForge.DotNet.Core.UI.MAUI/) — MAUI `VideoView` control
- Per-platform: [VisioForge.CrossPlatform.Core.Windows.x64](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.Windows.x64/), [VisioForge.CrossPlatform.Core.Android](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.Android/), [VisioForge.CrossPlatform.Core.iOS](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.iOS/), [VisioForge.CrossPlatform.Core.macCatalyst](https://www.nuget.org/packages/VisioForge.CrossPlatform.Core.macCatalyst/)

## The Reusable `RTSPPlayEngine` Helper

Both the WPF and MAUI examples use the same wrapper class. It takes an already-configured `RTSPSourceSettings` plus an `IVideoView`, builds a single-pipeline playback graph, and exposes async lifecycle methods plus an `OnError` event.

```
using System;
using System.Threading.Tasks;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AudioRendering;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.Sources;

public class RTSPPlayEngine : IAsyncDisposable
{
    private MediaBlocksPipeline _pipeline;
    private VideoRendererBlock _videoRenderer;
    private AudioRendererBlock _audioRenderer;
    private RTSPSourceBlock _source;
    private bool _disposed;

    public event EventHandler<ErrorsEventArgs> OnError;

    public RTSPPlayEngine(RTSPSourceSettings rtspSettings, IVideoView videoView)
    {
        _pipeline = new MediaBlocksPipeline();
        _pipeline.OnError += (s, e) => OnError?.Invoke(this, e);

        _source = new RTSPSourceBlock(rtspSettings);
        _videoRenderer = new VideoRendererBlock(_pipeline, videoView) { IsSync = false };
        _pipeline.Connect(_source.VideoOutput, _videoRenderer.Input);

        if (rtspSettings.AudioEnabled)
        {
            _audioRenderer = new AudioRendererBlock() { IsSync = false };
            _pipeline.Connect(_source.AudioOutput, _audioRenderer.Input);
        }
    }

    // Start the pipeline in paused state (used for synchronized start)
    public Task<bool> PreloadAsync() => _pipeline.StartAsync(true);

    // Start playing immediately (non-synchronized use)
    public Task<bool> StartAsync() => _pipeline.StartAsync();

    // Resume a pipeline that was preloaded
    public Task ResumeAsync() => _pipeline.ResumeAsync();

    public Task<bool> StopAsync() => _pipeline.StopAsync(true);

    public bool IsPaused() => _pipeline.State == PlaybackState.Pause;
    public bool IsStarted() => _pipeline.State == PlaybackState.Play;

    public async ValueTask DisposeAsync()
    {
        if (_disposed) return;
        _disposed = true;

        if (_pipeline != null)
        {
            await _pipeline.DisposeAsync();
            _pipeline = null;
        }

        _videoRenderer?.Dispose();
        _audioRenderer?.Dispose();
        _source?.Dispose();
    }
}
```

The two key design points:

- **`IsSync = false`** on both renderers. For live surveillance you want drop-late-frame behaviour, not the default clock-based lipsync (which would stall the whole cell if a single packet is late).
- **`PreloadAsync` vs `StartAsync`**. `PreloadAsync` calls `pipeline.StartAsync(true)` which preloads the pipeline into Paused state. Combined with a later `ResumeAsync` this lets you fire up all 16 cameras, wait until each is sitting at its first frame, then kick them all to Play at once — no stagger on the wall.

## WPF Example — 4×4 Grid

### XAML

```
<Window x:Class="MultiCameraWall.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:wpf="clr-namespace:VisioForge.Core.UI.WPF;assembly=VisioForge.Core"
        Title="RTSP 4×4 Wall"
        Width="1600" Height="900"
        Loaded="Window_Loaded" Closing="Window_Closing">
    <DockPanel>
        <StackPanel DockPanel.Dock="Top" Orientation="Horizontal" Margin="10">
            <Button x:Name="btStart" Content="Start all" Width="80" Click="btStart_Click" />
            <Button x:Name="btStop"  Content="Stop all"  Width="80" Click="btStop_Click" Margin="10,0,0,0" />
        </StackPanel>

        <UniformGrid Rows="4" Columns="4">
            <wpf:VideoView x:Name="videoView00" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView01" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView02" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView03" Background="Black" Margin="1" />

            <wpf:VideoView x:Name="videoView10" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView11" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView12" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView13" Background="Black" Margin="1" />

            <wpf:VideoView x:Name="videoView20" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView21" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView22" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView23" Background="Black" Margin="1" />

            <wpf:VideoView x:Name="videoView30" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView31" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView32" Background="Black" Margin="1" />
            <wpf:VideoView x:Name="videoView33" Background="Black" Margin="1" />
        </UniformGrid>
    </DockPanel>
</Window>
```

`UniformGrid` is the cleanest WPF primitive for a regular grid — no row/column definitions, it spreads children into a 4×4 layout automatically.

### Code-behind

```
using System;
using System.Threading.Tasks;
using System.Windows;
using VisioForge.Core;
using VisioForge.Core.Types.X.Sources;

public partial class MainWindow : Window
{
    private const int GridSize = 4;
    private readonly RTSPPlayEngine[] _engines = new RTSPPlayEngine[GridSize * GridSize];
    private readonly IVideoView[] _views;

    // 16 RTSP URLs — replace with your own. ONVIF service URLs work too;
    // RTSPSourceSettings.CreateAsync will resolve them to RTSP internally.
    private static readonly string[] Urls =
    {
        "rtsp://192.168.1.101:554/stream1", "rtsp://192.168.1.102:554/stream1",
        "rtsp://192.168.1.103:554/stream1", "rtsp://192.168.1.104:554/stream1",
        "rtsp://192.168.1.105:554/stream1", "rtsp://192.168.1.106:554/stream1",
        "rtsp://192.168.1.107:554/stream1", "rtsp://192.168.1.108:554/stream1",
        "rtsp://192.168.1.109:554/stream1", "rtsp://192.168.1.110:554/stream1",
        "rtsp://192.168.1.111:554/stream1", "rtsp://192.168.1.112:554/stream1",
        "rtsp://192.168.1.113:554/stream1", "rtsp://192.168.1.114:554/stream1",
        "rtsp://192.168.1.115:554/stream1", "rtsp://192.168.1.116:554/stream1",
    };

    public MainWindow()
    {
        InitializeComponent();
        _views = new IVideoView[]
        {
            videoView00, videoView01, videoView02, videoView03,
            videoView10, videoView11, videoView12, videoView13,
            videoView20, videoView21, videoView22, videoView23,
            videoView30, videoView31, videoView32, videoView33,
        };
    }

    private async void Window_Loaded(object sender, RoutedEventArgs e)
    {
        await VisioForgeX.InitSDKAsync();
    }

    private async void btStart_Click(object sender, RoutedEventArgs e)
    {
        await DestroyAllAsync();

        // 1. Build sources and engines in parallel.
        var createTasks = new Task[GridSize * GridSize];
        for (int i = 0; i < _engines.Length; i++)
        {
            int idx = i;
            createTasks[i] = Task.Run(async () =>
            {
                var settings = await RTSPSourceSettings.CreateAsync(
                    new Uri(Urls[idx]), login: "admin", password: "admin123",
                    audioEnabled: false);

                settings.LowLatencyMode = true;          // minimise jitter buffer
                settings.UseGPUDecoder  = true;          // offload H.264 to GPU

                var engine = new RTSPPlayEngine(settings, _views[idx]);
                engine.OnError += (s, err) =>
                    Dispatcher.Invoke(() =>
                        System.Diagnostics.Debug.WriteLine($"cam[{idx}]: {err.Message}"));
                _engines[idx] = engine;
            });
        }
        await Task.WhenAll(createTasks);

        // 2. Preload every pipeline into the Paused state.
        await Task.WhenAll(Array.ConvertAll(_engines, en => en.PreloadAsync()));

        // 3. Wait until all pipelines report Paused.
        for (int tries = 0; tries < 100; tries++)   // 100 × 50 ms = 5 s max
        {
            bool allPaused = true;
            foreach (var en in _engines)
                if (!en.IsPaused()) { allPaused = false; break; }
            if (allPaused) break;
            await Task.Delay(50);
        }

        // 4. Resume all simultaneously — frame-aligned start across 16 cells.
        foreach (var en in _engines)
            await en.ResumeAsync().ConfigureAwait(false);
    }

    private async void btStop_Click(object sender, RoutedEventArgs e) => await DestroyAllAsync();

    private async Task DestroyAllAsync()
    {
        for (int i = 0; i < _engines.Length; i++)
        {
            if (_engines[i] != null)
            {
                await _engines[i].DisposeAsync();
                _engines[i] = null;
            }
        }
    }

    private async void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
    {
        await DestroyAllAsync();
        VisioForgeX.DestroySDK();
    }
}
```

## MAUI Example — 4×4 Grid

The MAUI version uses the same `RTSPPlayEngine` class unchanged — the only differences are the XAML namespace, the `videoView.GetVideoView()` bridge to get an `IVideoView` from a MAUI `VideoView`, and the `MauiProgram.cs` handler registration.

### MauiProgram.cs

```
using SkiaSharp.Views.Maui.Controls.Hosting;
using VisioForge.Core.UI.MAUI;

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .UseSkiaSharp()
            .ConfigureMauiHandlers(handlers => handlers.AddVisioForgeHandlers())
            .ConfigureFonts(fonts =>
            {
                fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            });

        return builder.Build();
    }
}
```

### MainPage.xaml

```
<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:vf="clr-namespace:VisioForge.Core.UI.MAUI;assembly=VisioForge.Core.UI.MAUI"
             x:Class="MultiCameraWall.MainPage">
    <Grid RowDefinitions="Auto,*">
        <HorizontalStackLayout Grid.Row="0" Padding="10" Spacing="10">
            <Button x:Name="btStart" Text="Start all" Clicked="OnStartClicked" />
            <Button x:Name="btStop"  Text="Stop all"  Clicked="OnStopClicked"  />
        </HorizontalStackLayout>

        <Grid Grid.Row="1"
              RowDefinitions="*,*,*,*"
              ColumnDefinitions="*,*,*,*"
              RowSpacing="1" ColumnSpacing="1" BackgroundColor="Black">

            <vf:VideoView x:Name="cam00" Grid.Row="0" Grid.Column="0" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam01" Grid.Row="0" Grid.Column="1" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam02" Grid.Row="0" Grid.Column="2" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam03" Grid.Row="0" Grid.Column="3" BackgroundColor="Black" />

            <vf:VideoView x:Name="cam10" Grid.Row="1" Grid.Column="0" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam11" Grid.Row="1" Grid.Column="1" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam12" Grid.Row="1" Grid.Column="2" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam13" Grid.Row="1" Grid.Column="3" BackgroundColor="Black" />

            <vf:VideoView x:Name="cam20" Grid.Row="2" Grid.Column="0" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam21" Grid.Row="2" Grid.Column="1" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam22" Grid.Row="2" Grid.Column="2" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam23" Grid.Row="2" Grid.Column="3" BackgroundColor="Black" />

            <vf:VideoView x:Name="cam30" Grid.Row="3" Grid.Column="0" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam31" Grid.Row="3" Grid.Column="1" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam32" Grid.Row="3" Grid.Column="2" BackgroundColor="Black" />
            <vf:VideoView x:Name="cam33" Grid.Row="3" Grid.Column="3" BackgroundColor="Black" />
        </Grid>
    </Grid>
</ContentPage>
```

### MainPage.xaml.cs

```
using VisioForge.Core;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.Sources;

public partial class MainPage : ContentPage
{
    private const int GridSize = 4;
    private readonly RTSPPlayEngine[] _engines = new RTSPPlayEngine[GridSize * GridSize];
    private IVideoView[] _views;

    private static readonly string[] Urls =
    {
        "rtsp://192.168.1.101:554/stream1", /* ...15 more... */
    };

    public MainPage()
    {
        InitializeComponent();
        _views = new IVideoView[]
        {
            cam00.GetVideoView(), cam01.GetVideoView(), cam02.GetVideoView(), cam03.GetVideoView(),
            cam10.GetVideoView(), cam11.GetVideoView(), cam12.GetVideoView(), cam13.GetVideoView(),
            cam20.GetVideoView(), cam21.GetVideoView(), cam22.GetVideoView(), cam23.GetVideoView(),
            cam30.GetVideoView(), cam31.GetVideoView(), cam32.GetVideoView(), cam33.GetVideoView(),
        };

        VisioForgeX.InitSDK();
    }

    private async void OnStartClicked(object sender, EventArgs e)
    {
        await DestroyAllAsync();

        var createTasks = new Task[GridSize * GridSize];
        for (int i = 0; i < _engines.Length; i++)
        {
            int idx = i;
            createTasks[i] = Task.Run(async () =>
            {
                var settings = await RTSPSourceSettings.CreateAsync(
                    new Uri(Urls[idx]), "admin", "admin123", audioEnabled: false);

                settings.LowLatencyMode = true;
                settings.UseGPUDecoder  = true;

                _engines[idx] = new RTSPPlayEngine(settings, _views[idx]);
            });
        }
        await Task.WhenAll(createTasks);

        await Task.WhenAll(Array.ConvertAll(_engines, en => en.PreloadAsync()));

        for (int tries = 0; tries < 100; tries++)
        {
            bool allPaused = true;
            foreach (var en in _engines)
                if (!en.IsPaused()) { allPaused = false; break; }
            if (allPaused) break;
            await Task.Delay(50);
        }

        foreach (var en in _engines)
            await en.ResumeAsync().ConfigureAwait(false);
    }

    private async void OnStopClicked(object sender, EventArgs e) => await DestroyAllAsync();

    private async Task DestroyAllAsync()
    {
        for (int i = 0; i < _engines.Length; i++)
        {
            if (_engines[i] != null)
            {
                await _engines[i].DisposeAsync();
                _engines[i] = null;
            }
        }
    }
}
```

### Android manifest

Add to `Platforms/Android/AndroidManifest.xml`:

```
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
```

### iOS / MacCatalyst

Add to the `.csproj` so the GStreamer dependencies load correctly under the Mono interpreter:

```
<PropertyGroup Condition="$(TargetFramework.Contains('-ios')) Or $(TargetFramework.Contains('-maccatalyst'))">
    <UseInterpreter>true</UseInterpreter>
</PropertyGroup>
```

## Synchronized Start — Why Preload + Resume

If you simply call `StartAsync()` on 16 pipelines in a loop, each one will begin playing the instant its first keyframe arrives — and that's a different wall-clock time per camera, depending on RTSP handshake latency and keyframe cadence. The eye catches the stagger immediately on a wall view.

The Preload + Resume pattern fixes this:

1. `PreloadAsync()` on every pipeline → every pipeline enters **Paused** at the first frame.
2. Poll until `IsPaused()` is true on all 16.
3. `ResumeAsync()` on every pipeline in quick succession → all cells unfreeze within the same frame.

You don't need this pattern if the cameras are showing unrelated scenes (16 different rooms). Use it when the visual continuity between cells matters (same room from multiple angles, time-synced replay, etc).

To skip sync: replace the preload/resume block with a single loop that calls `await engine.StartAsync()` on each engine, serially or via `Task.WhenAll`.

## Performance Tuning

For a responsive 16-camera wall, tune each `RTSPSourceSettings`:

- **`LowLatencyMode = true`** — sets `buffer-mode=None` + `drop-on-latency=false` internally. Cuts jitter buffer from 500 ms to 150 ms.
- **`UseGPUDecoder = true`** — hardware H.264 / H.265 decode. Without it a 16-stream 1080p wall will saturate CPU on most laptops.
- **`AudioEnabled = false`** — on all 16. No one wants 16 overlapping audio streams.
- **`VideoRendererBlock.IsSync = false`** — drop-late-frames. The wrapper above already sets this.
- **Resolution**: ask each camera for its **sub-stream** (typically 720p or 480p) via ONVIF profile, not the main 4K feed. 16 × 4K is a bandwidth problem before it's a rendering problem.

On a mid-range desktop (8-core CPU + integrated GPU), a 4×4 720p H.264 wall sits at roughly 15–25% CPU and ≤200 MB RAM with these settings.

## Error Handling

The `RTSPPlayEngine` forwards pipeline errors through its `OnError` event. In a wall view the right response is **log and keep the other 15 running** — never tear down the whole grid on a single camera fault.

```
engine.OnError += (s, err) =>
{
    // Per-camera log. Marshal to UI thread if you update UI here.
    Dispatcher.Invoke(() => LogLine($"cam[{idx}] error: {err.Message}"));
};
```

For a production NVR you'd add: timestamps, severity filtering, and a "camera disconnected" overlay on the affected `VideoView` (see next section).

## Reconnection — Fallback Switch

When an RTSP stream fails, the pipeline can automatically switch to a static image, text card, or fallback media file instead of freezing on the last good frame — the cell keeps showing *something* (like a "camera offline" slate) until the camera recovers.

In the Media Blocks SDK the fallback is wired at the pipeline level with `FallbackSwitchSourceBlock`, which wraps the source: build it from your `RTSPSourceSettings` plus a `FallbackSwitchSettings`, then connect its separate `VideoOutput` / `AudioOutput` pads exactly as you would the source block's. In the `RTSPPlayEngine` helper above it **replaces** the bare `RTSPSourceBlock` — do not wire both.

```
var fallbackSwitch = new FallbackSwitchSourceBlock(
    rtspSettings,
    new FallbackSwitchSettings
    {
        Enabled = true,
        Fallback = new StaticTextFallbackSettings { Text = "CAMERA OFFLINE" },
    });

_pipeline.Connect(fallbackSwitch.VideoOutput, _videoRenderer.Input);
if (rtspSettings.AudioEnabled)
{
    _pipeline.Connect(fallbackSwitch.AudioOutput, _audioRenderer.Input);
}
```

Setting `rtspSettings.FallbackSwitch` alone is **not enough** in a Media Blocks pipeline — a bare `RTSPSourceBlock` does not apply it and logs a warning at build time; the declarative property is applied by `VideoCaptureCoreX`. For the full `FallbackSwitch` API (text / image / alternate-media types, tunable timeouts, `ManualUnblock`) see the dedicated [RTSP reconnection and fallback switch guide](../../../general/network-sources/reconnection-and-fallback/).

## Related Documentation

- [RTSP camera source configuration](../../../videocapture/video-sources/ip-cameras/rtsp/) — `RTSPSourceSettings` reference, UDP/TCP transport, buffer tuning
- [ONVIF IP camera integration](../../../videocapture/video-sources/ip-cameras/onvif/) — WS-Discovery and profile selection to find the sub-stream URLs for your wall
- [Single-camera RTSP player](../rtsp-player-csharp/) — the single-stream version of this guide
- [Save original RTSP stream](../rtsp-save-original-stream/) — record any / all of the 16 feeds to disk without re-encoding
- [RTSP protocol deep-dive](../../../general/network-streaming/rtsp/) — how RTSP works under the hood
- [RTSP server output block](../../RTSPServer/) — serve your own composite wall as a single RTSP output

## GitHub Sample Projects

- [RTSP MultiViewSync Demo (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/RTSP%20MultiViewSync%20Demo) — 3-camera sync demo this guide is based on
- [RTSP MultiView Demo (WinForms)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WinForms/CSharp/RTSP%20MultiView%20Demo) — 3×3 WinForms equivalent (no sync)

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page for more Media Blocks SDK code samples. Need the RTSP URL for your camera? Browse our [IP camera brands directory](../../../camera-brands/) covering 60+ manufacturers.

---END OF PAGE---


## ONVIF IP Camera Capture to MP4 with Video Effects in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/onvif-capture-with-postprocessing/
**Description:** Capture ONVIF IP camera video and apply resize, brightness, and filter effects before saving to MP4 using VisioForge Media Blocks SDK for .NET.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, GStreamer, Recording, Encoding, IP Camera, RTSP, ONVIF, MP4, H.264, AAC, C#
**API:** MediaBlocksPipeline, RTSPSourceBlock, RTSPSourceSettings, H264EncoderBlock, AACEncoderBlock, MP4SinkBlock

# Capture MP4 from ONVIF Camera with Postprocessing

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Cross-platform support

The Media Blocks SDK runs on **Windows, macOS, Linux, Android, and iOS** via GStreamer. See the [platform support matrix](../../../platform-matrix/) for codec and hardware-acceleration details, and the [Linux deployment guide](../../../deployment-x/Ubuntu/) for Ubuntu / NVIDIA Jetson / Raspberry Pi setup.

Info

For complete working examples, see: - [RTSP Preview Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/RTSP%20Preview%20Demo) — Shows ONVIF camera preview with postprocessing - [IP Capture Demo (Video Capture SDK)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WPF/CSharp/IP%20Capture) — Alternative using Video Capture SDK

For comprehensive ONVIF documentation, see the [ONVIF IP Camera Integration Guide](../../../videocapture/video-sources/ip-cameras/onvif/). !!!

## Table of Contents

- [Capture MP4 from ONVIF Camera with Postprocessing](#capture-mp4-from-onvif-camera-with-postprocessing)
- [Table of Contents](#table-of-contents)
- [Overview](#overview)
- [When to Use Postprocessing](#when-to-use-postprocessing)
- [Prerequisites](#prerequisites)
- [Basic Setup: ONVIF Discovery and Connection](#basic-setup-onvif-discovery-and-connection)
- [Example 1: Resize Video](#example-1-resize-video)
- [Example 2: Apply Video Effects](#example-2-apply-video-effects)
- [Example 3: Real-Time Face Blur](#example-3-real-time-face-blur)
- [Example 4: Watermark and Logo Overlay](#example-4-watermark-and-logo-overlay)
- [Performance Considerations](#performance-considerations)
- [Best Practices](#best-practices)
- [Troubleshooting](#troubleshooting)

## Overview

This guide demonstrates how to capture video from ONVIF IP cameras while applying various postprocessing effects before encoding to MP4. Unlike pass-through recording which preserves the original stream, postprocessing requires decoding the video, applying transformations, and re-encoding.

This approach is useful when you need to: - Resize or crop video - Apply brightness, contrast, or color corrections - Add watermarks or logos - Blur faces for privacy - Apply artistic effects or filters - Combine multiple processing steps

## When to Use Postprocessing

**Use postprocessing when:** - You need to resize video (e.g., from 4K to 1080p) - You want to apply video effects (brightness, contrast, etc.) - You need to add overlays or watermarks - Privacy requirements mandate face blurring - You're combining multiple camera feeds - You need to apply AI/CV algorithms

**Use pass-through (no postprocessing) when:** - You want to preserve original video quality - You need to minimize CPU usage - Storage space is not a concern - Recording duration is long (hours/days)

For pass-through recording, see [Save RTSP Stream without Re-encoding](../rtsp-save-original-stream/).

## Prerequisites

1. **VisioForge Media Blocks SDK .NET** installed
2. **ONVIF Camera** accessible on your network
3. **Valid camera credentials** (username and password)
4. **Basic understanding of**:
5. C# async/await
6. ONVIF protocol basics
7. Video encoding parameters

## Basic Setup: ONVIF Discovery and Connection

First, discover and connect to your ONVIF camera:

```
using VisioForge.Core.ONVIFDiscovery;
using VisioForge.Core.ONVIFX;

// Discover ONVIF cameras
var discovery = new Discovery();
var cts = new CancellationTokenSource();
string cameraUrl = null;

await discovery.Discover(5, (device) =>
{
    if (device.XAdresses?.Any() == true)
    {
        cameraUrl = device.XAdresses.FirstOrDefault();
        Console.WriteLine($"Found camera: {cameraUrl}");
    }
}, cts.Token);

if (string.IsNullOrEmpty(cameraUrl))
{
    Console.WriteLine("No ONVIF cameras found");
    return;
}

// Connect to camera
var onvifClient = new ONVIFClientX();
bool connected = await onvifClient.ConnectAsync(cameraUrl, "admin", "password");

if (!connected)
{
    Console.WriteLine("Failed to connect to camera");
    return;
}

// Get RTSP stream URL
var profiles = await onvifClient.GetProfilesAsync();
var streamUri = await onvifClient.GetStreamUriAsync(profiles[0]);
string rtspUrl = streamUri.Uri;

Console.WriteLine($"RTSP URL: {rtspUrl}");
```

## Example 1: Resize Video

Resize video from ONVIF camera before saving to MP4. The Media Blocks API takes settings objects, not fluent properties — `RTSPSourceBlock` is constructed from an `RTSPSourceSettings`, the encoder from its settings object, the MP4 sink hands out input pads via `CreateNewInput(...)`, and links are declared on the pipeline.

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoProcessing;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.MediaBlocks.AudioEncoders;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types;

// Create pipeline
var pipeline = new MediaBlocksPipeline();

// RTSP source from ONVIF camera. Credentials and latency live on the settings
// object; use the async factory so the settings discover codec info up front.
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri(rtspUrl), "admin", "password", audioEnabled: true);
var rtspSource = new RTSPSourceBlock(rtspSettings);

// Video resize block — downscale to 1280x720. The (width, height) ctor is a
// shortcut for `new VideoResizeBlock(new ResizeVideoEffect(w, h))`.
var videoResize = new VideoResizeBlock(1280, 720);

// H.264 encoder. Pick a concrete settings class — Bitrate is in Kbit/s (2000 = 2 Mbps).
// OpenH264EncoderSettings works on every platform; swap to NVENC / QSV / AMF / MFH264 for GPU acceleration.
var h264Settings = new OpenH264EncoderSettings { Bitrate = 2000 };
var h264Encoder = new H264EncoderBlock(h264Settings);

// AAC audio encoder (Bitrate is in Kbit/s — 128 = 128 kbps).
var aacEncoder = new AACEncoderBlock(new VOAACEncoderSettings { Bitrate = 128 });

// MP4 sink — file-path ctor is the shortest path to a valid MP4 writer.
var mp4Sink = new MP4SinkBlock("output_resized.mp4");

// Add every block to the pipeline before wiring links
pipeline.AddBlock(rtspSource);
pipeline.AddBlock(videoResize);
pipeline.AddBlock(h264Encoder);
pipeline.AddBlock(aacEncoder);
pipeline.AddBlock(mp4Sink);

// Wire the video path (RTSP video → resize → H.264 → MP4 sink video pad)
pipeline.Connect(rtspSource.VideoOutput, videoResize.Input);
pipeline.Connect(videoResize.Output, h264Encoder.Input);
pipeline.Connect(h264Encoder.Output, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Video));

// Wire the audio path (RTSP audio → AAC → MP4 sink audio pad)
pipeline.Connect(rtspSource.AudioOutput, aacEncoder.Input);
pipeline.Connect(aacEncoder.Output, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Audio));

// Start recording
await pipeline.StartAsync();

Console.WriteLine("Recording with resize... Press Enter to stop.");
Console.ReadLine();

// Stop and cleanup
await pipeline.StopAsync();
await pipeline.DisposeAsync();

Console.WriteLine("Recording complete: output_resized.mp4");
```

## Example 2: Apply Video Effects

Apply brightness, contrast, hue, and saturation adjustments. Video-processing blocks take a settings object in the ctor; the settings carry the knobs.

```
using VisioForge.Core.MediaBlocks.VideoProcessing;
using VisioForge.Core.Types.X.VideoEffects;

// Create pipeline
var pipeline = new MediaBlocksPipeline();

// RTSP source
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri(rtspUrl), "admin", "password", audioEnabled: true);
var rtspSource = new RTSPSourceBlock(rtspSettings);

// Video-balance block — knobs live on the settings object.
// Brightness: -1.0..1.0 (0.2 = slightly brighter)
// Contrast:    0.0..2.0 (1.15 = +15% contrast)
// Saturation:  0.0..2.0 (1.3  = +30% saturation)
// Hue:        -1.0..1.0 (0.0  = no shift)
var balanceSettings = new VideoBalanceVideoEffect
{
    Brightness = 0.2,
    Contrast   = 1.15,
    Saturation = 1.3,
    Hue        = 0.0,
};
var videoBalance = new VideoBalanceBlock(balanceSettings);

// Color-effects block takes a preset directly in the ctor
var colorEffects = new ColorEffectsBlock(ColorEffectsPreset.Sepia);

// H.264 encoder (3 Mbps)
var h264Settings = new OpenH264EncoderSettings { Bitrate = 3000 };
var h264Encoder = new H264EncoderBlock(h264Settings);

// AAC audio
var aacEncoder = new AACEncoderBlock(new VOAACEncoderSettings { Bitrate = 128 });

// MP4 output
var mp4Sink = new MP4SinkBlock("output_enhanced.mp4");

// Add everything to the pipeline, then wire
pipeline.AddBlock(rtspSource);
pipeline.AddBlock(videoBalance);
pipeline.AddBlock(colorEffects);
pipeline.AddBlock(h264Encoder);
pipeline.AddBlock(aacEncoder);
pipeline.AddBlock(mp4Sink);

// Video chain: RTSP → balance → color-effects → H.264 → MP4
pipeline.Connect(rtspSource.VideoOutput, videoBalance.Input);
pipeline.Connect(videoBalance.Output, colorEffects.Input);
pipeline.Connect(colorEffects.Output, h264Encoder.Input);
pipeline.Connect(h264Encoder.Output, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Video));

// Audio chain
pipeline.Connect(rtspSource.AudioOutput, aacEncoder.Input);
pipeline.Connect(aacEncoder.Output, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Audio));

// Start
await pipeline.StartAsync();

Console.WriteLine("Recording with enhancements...");
await Task.Delay(TimeSpan.FromMinutes(5)); // Record for 5 minutes

await pipeline.StopAsync();
await pipeline.DisposeAsync();
```

## Example 3: Real-Time Face Blur

Apply face detection and blurring for privacy protection:

```
using VisioForge.Core.MediaBlocks.OpenCV;
using VisioForge.Core.Types.X.OpenCV;

// Create pipeline
var pipeline = new MediaBlocksPipeline();

// RTSP source
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri(rtspUrl), "admin", "password", audioEnabled: true);
var rtspSource = new RTSPSourceBlock(rtspSettings);

// CVFaceBlurBlock — automatic face detection and blurring via OpenCV
var faceBlurSettings = new CVFaceBlurSettings
{
    ScaleFactor      = 1.25,
    MinNeighbors     = 3,
    MinSize          = new Size(30, 30),
    MainCascadeFile  = "haarcascade_frontalface_default.xml",
};
var faceBlur = new CVFaceBlurBlock(faceBlurSettings);

// H.264 encoder
var h264Settings = new OpenH264EncoderSettings { Bitrate = 3000 };
var h264Encoder = new H264EncoderBlock(h264Settings);

// AAC audio
var aacEncoder = new AACEncoderBlock(new VOAACEncoderSettings { Bitrate = 128 });

// MP4 output
var mp4Sink = new MP4SinkBlock("output_face_blur.mp4");

// Add + wire
pipeline.AddBlock(rtspSource);
pipeline.AddBlock(faceBlur);
pipeline.AddBlock(h264Encoder);
pipeline.AddBlock(aacEncoder);
pipeline.AddBlock(mp4Sink);

pipeline.Connect(rtspSource.VideoOutput, faceBlur.Input);
pipeline.Connect(faceBlur.Output, h264Encoder.Input);
pipeline.Connect(h264Encoder.Output, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Video));

pipeline.Connect(rtspSource.AudioOutput, aacEncoder.Input);
pipeline.Connect(aacEncoder.Output, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Audio));

// Start
await pipeline.StartAsync();
```

## Example 4: Watermark and Logo Overlay

Add a watermark logo and a timestamp overlay. `ImageOverlayBlock` takes either a filename or an `ImageOverlaySettings`; position/opacity live on the settings. `TextOverlayBlock` always takes a `TextOverlaySettings`.

```
using VisioForge.Core.MediaBlocks.VideoProcessing;
using VisioForge.Core.Types.X.VideoEffects;
using SkiaSharp;

// Create pipeline
var pipeline = new MediaBlocksPipeline();

// RTSP source
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri(rtspUrl), "admin", "password", audioEnabled: true);
var rtspSource = new RTSPSourceBlock(rtspSettings);

// Logo / watermark: file-path ctor loads the image. Position knobs live on the
// settings object; transparency is Alpha (0..1, not Opacity).
var logoOverlay = new ImageOverlayBlock(new ImageOverlaySettings("watermark.png")
{
    X     = 10,   // 10 px from left
    Y     = 10,   // 10 px from top
    Alpha = 0.7,  // 0..1
});

// Static text overlay. TextOverlaySettings carries Text, position, Color (SKColor),
// and font knobs — see the OverlayManagerText reference for every option.
var textOverlay = new TextOverlayBlock(new TextOverlaySettings("Camera 1")
{
    Color = SKColors.White,
});

// H.264 encoder
var h264Settings = new OpenH264EncoderSettings { Bitrate = 3000 };
var h264Encoder = new H264EncoderBlock(h264Settings);

// AAC audio
var aacEncoder = new AACEncoderBlock(new VOAACEncoderSettings { Bitrate = 128 });

// MP4 output
var mp4Sink = new MP4SinkBlock("output_watermarked.mp4");

// Add + wire
pipeline.AddBlock(rtspSource);
pipeline.AddBlock(logoOverlay);
pipeline.AddBlock(textOverlay);
pipeline.AddBlock(h264Encoder);
pipeline.AddBlock(aacEncoder);
pipeline.AddBlock(mp4Sink);

// Video chain: RTSP → logo → text → H.264 → MP4
pipeline.Connect(rtspSource.VideoOutput, logoOverlay.Input);
pipeline.Connect(logoOverlay.Output, textOverlay.Input);
pipeline.Connect(textOverlay.Output, h264Encoder.Input);
pipeline.Connect(h264Encoder.Output, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Video));

// Audio chain
pipeline.Connect(rtspSource.AudioOutput, aacEncoder.Input);
pipeline.Connect(aacEncoder.Output, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Audio));

// Start
await pipeline.StartAsync();
```

## Performance Considerations

1. **CPU Usage**: Video processing is CPU-intensive. Each effect adds overhead:
2. Simple resize: ~10-20% CPU per stream
3. Color correction: ~5-15% CPU
4. Face detection: ~30-50% CPU (depends on resolution)
5. Multiple effects: Additive CPU usage
6. **GPU Acceleration**: Use hardware-accelerated encoders when available. `H264EncoderBlock.GetDefaultSettings()` already prefers NVENC / QSV / AMF when the platform supports it, but you can force a specific backend:

```
// NVIDIA NVENC H.264 encoder (Bitrate in Kbit/s — 4000 = 4 Mbps)
var nvencSettings = new NVENCH264EncoderSettings { Bitrate = 4000 };
var h264Encoder   = new H264EncoderBlock(nvencSettings);
```

1. **Error handling**: Subscribe to `OnError` to learn about pipeline failures:

```
pipeline.OnError += (sender, e) =>
{
    Console.WriteLine($"Pipeline error: {e.Message}");
};
```

1. **Encoding Settings Balance**:
2. **Quality**: Higher bitrate, slower preset = better quality, more CPU
3. **Performance**: Lower bitrate, faster preset = lower quality, less CPU
4. **File Size**: Bitrate directly affects file size

## Best Practices

1. **Test Performance First**:
2. Start with simple pipeline
3. Add effects one at a time
4. Monitor CPU/memory usage
5. Adjust settings based on hardware
6. **Choose Appropriate Bitrates** (all values in Kbit/s):
7. 720p: 1000-2000
8. 1080p: 2000-4000
9. 4K: 8000-15000
10. **Dispose Resources**:

```
try
{
    await pipeline.StartAsync();
    // ... recording ...
}
finally
{
    await pipeline.StopAsync();
    await pipeline.DisposeAsync();
    onvifClient?.Dispose();
}
```

1. **Observe pipeline lifecycle events**:

```
pipeline.OnStart  += (s, e) => Console.WriteLine("Pipeline started");
pipeline.OnStop   += (s, e) => Console.WriteLine("Pipeline stopped");
pipeline.OnPause  += (s, e) => Console.WriteLine("Pipeline paused");
pipeline.OnResume += (s, e) => Console.WriteLine("Pipeline resumed");
```

## Troubleshooting

**High CPU Usage:** - Reduce video resolution - Lower encoder preset (faster encoding) - Remove unnecessary effects - Use GPU acceleration if available

**Dropped Frames:** - Check if CPU is bottlenecked - Reduce frame rate - Lower bitrate - Simplify processing pipeline

**Poor Video Quality:** - Increase bitrate - Use slower encoder preset - Check source video quality - Verify network bandwidth for RTSP

**Memory Leaks:** - Ensure proper disposal of blocks - Check for circular references - Monitor long-running recordings

**Effects Not Applied:** - Verify block connections via `pipeline.Connect(outPad, inPad)` - Check effect parameters are valid - Ensure every block is registered via `pipeline.AddBlock(...)` before `StartAsync` - Review pipeline order (effects chain)

---

For simpler recording without postprocessing, see [Save RTSP Stream without Re-encoding](../rtsp-save-original-stream/). Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page for complete working examples.

---END OF PAGE---


## Save and Restore a Media Blocks Pipeline as JSON in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/pipeline-json-save-restore/
**Description:** Serialize a Media Blocks pipeline to JSON, validate it, materialize it back into a live pipeline, and capture a running one. C# examples with diagnostics.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, GStreamer, JSON, Serialization, C#
**API:** MediaBlocksPipeline, MediaBlocksPipelineDocument, MediaBlocksPipelineJsonSerializer, MediaBlocksPipelineValidator, MediaBlocksPipelineMaterializer, MediaBlocksPipelineSnapshot, MediaBlockCatalog

# Save and Restore a Media Blocks Pipeline as JSON in C

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Table of Contents

- [Overview](#overview)
- [The document model](#the-document-model)
- [Building a pipeline from JSON](#building-a-pipeline-from-json)
- [Validating before you build](#validating-before-you-build)
- [Capturing a live pipeline](#capturing-a-live-pipeline)
- [Relative asset paths](#relative-asset-paths)
- [Diagnostics](#diagnostics)
- [Discovering block types](#discovering-block-types)
- [Demos](#demos)

## Overview

A Media Blocks pipeline is normally built in code: you construct blocks, connect their pads, and start the pipeline. The persistence layer lets you do the same thing with a **document** — an ordinary JSON file that names the blocks, their settings and their connections. That document can be written by your application, edited by hand, shipped as a preset, or produced by a visual editor.

Three types do the work, and each has a single responsibility:

| Type | What it does |
| --- | --- |
| `MediaBlocksPipelineJsonSerializer` | JSON text ⇄ `MediaBlocksPipelineDocument` |
| `MediaBlocksPipelineValidator` | checks a document *before* anything is built |
| `MediaBlocksPipelineMaterializer` | document → live `MediaBlocksPipeline` |

The reverse direction — live pipeline → document — is `MediaBlocksPipelineSnapshot`, reached through `MediaBlocksPipeline.ToDocument()`.

```
flowchart LR
    JSON[JSON file] -->|Load| Document[MediaBlocksPipelineDocument]
    Document -->|Validate| Diagnostics[Diagnostics]
    Document -->|Materialize| Pipeline[MediaBlocksPipeline]
    Pipeline -->|ToDocument| Document
    Document -->|Serialize| JSON
```

## The document model

`MediaBlocksPipelineDocument` is a plain DTO tree:

- `SchemaVersion` — the document format version. Older versions are migrated on load.
- `Pipeline` — `Id`, `Name` and optional pipeline-level settings.
- `Blocks` — a `MediaBlockDocument` each: `Id` (a `Guid`), `Type` (the `MediaBlockType` value), `TypeName`, `Name`, and a `Settings` payload.
- `Connections` — a `MediaBlockConnectionDocument` each, with a `From` and a `To` `MediaBlockPadReference`.

A pad reference is a block id plus a **pad id**, and the pad id follows one convention:

| Pad id | Meaning |
| --- | --- |
| `input` / `output` | the block's main pad |
| `input:N` / `output:N` | element *N* of the block's `Inputs` / `Outputs` list |

The indexed form is the one to prefer when you generate documents: it addresses any block, while the unindexed form needs a main pad that not every block has. For a muxing sink such as `MP4SinkBlock`, `input:0` and `input:1` are the video and audio streams.

A minimal document:

```
{
  "schemaVersion": 1,
  "pipeline": { "id": "6f0d1b6e-1f7a-4f1e-9a1a-0a0f3d5f7a11", "name": "Player" },
  "blocks": [
    {
      "id": "10000000-0000-4000-8000-000000000001",
      "type": 3,
      "typeName": "UniversalSource",
      "name": "Media File",
      "settings": { "uri": "clips/sample.mp4", "renderVideo": true, "renderAudio": true }
    },
    {
      "id": "10000000-0000-4000-8000-000000000002",
      "type": 21,
      "typeName": "VideoRenderer",
      "name": "Preview"
    }
  ],
  "connections": [
    {
      "from": { "blockId": "10000000-0000-4000-8000-000000000001", "padId": "output:0" },
      "to":   { "blockId": "10000000-0000-4000-8000-000000000002", "padId": "input" }
    }
  ]
}
```

## Building a pipeline from JSON

The shortest path replaces an existing pipeline's contents:

```
var pipeline = new MediaBlocksPipeline();

var result = await pipeline.LoadJsonAsync(
    File.ReadAllText("player.json"),
    resolver: null,
    baseDirectory: Path.GetDirectoryName(Path.GetFullPath("player.json")));

if (!result.Success)
{
    foreach (var diagnostic in result.Diagnostics)
    {
        Console.WriteLine(diagnostic);
    }

    return;
}

await pipeline.StartAsync();
```

`LoadJsonAsync` requires the pipeline to be stopped, and it never leaves a half-built graph behind: if materialization fails partway, the pipeline is cleared.

To build a pipeline without owning one first, use the materializer directly. It returns the pipeline *and* the mapping from document ids to live blocks, which is what you need to reach a block afterwards:

```
var loaded = MediaBlocksPipelineJsonSerializer.Load(json);
var result = MediaBlocksPipelineMaterializer.Materialize(loaded.Document, resolver: null, baseDirectory: folder);

if (result.Success)
{
    var overlay = (TextOverlayBlock)result.Blocks[captionId];
    overlay.Settings.Text = "Live";
}
```

### Network sources are probed when the pipeline starts

A document carries a source's endpoint, never its media information: restoring one contacts nothing. Two sources need that information before they can be built — `RTSPRAWSourceBlock` picks its depayloader and parser from the stream layout, and the desktop `NDISourceBlock` creates its converters from the stream counts — so `StartAsync` probes them for you, once, before the graph is built. The camera or sender has to be reachable at that moment; if it is not, `StartAsync` returns `false` and logs which source could not be read.

The synchronous `Start` has nowhere to await a probe and does not do this, and neither do the `VideoCaptureCoreX` and `MediaPlayerCoreX` engines, which build their graph through it. Restore a document whose pipeline you intend to start that way by replacing those settings with ones built through `RTSPRAWSourceSettings.CreateAsync` / `NDISourceSettings.CreateAsync` after materialization.

### Audio devices are matched back to this machine

A document stores what identifies an audio device — its name, the API it belongs to, the endpoint path where the platform publishes one, and, on macOS, the stable CoreAudio `unique-id` — and never the enumerator's live handle, which means nothing outside the process that made it. Materialization matches that identity against the devices this machine has now and hands the block a live device again. That is also why a restored pipeline opens the right endpoint: the numeric CoreAudio id and the WASAPI device path are reassigned between runs, and the match re-reads the current ones.

If the device is gone, the pipeline still builds — on another device of the same API, reported as an `MBS063` warning naming both. If the machine has no device of that API at all, the block keeps the document's identity and materialization reports `MBS064`; the block will not open anything.

Matching enumerates devices, which on a cold process starts a GStreamer device monitor and can take seconds, so call `Materialize` off the UI thread — or enumerate once beforehand. Inputs and outputs are cached separately: `AudioSourcesAsync` warms capture devices, `AudioOutputsAsync` warms renderers, and on Apple platforms the asynchronous capture call is also the one that asks for microphone permission. The synchronous match inside `Materialize` does neither.

## Validating before you build

`Validate` answers the same questions materialization would, without constructing anything — so a UI can show a document's problems while the user edits it:

```
var diagnostics = MediaBlocksPipelineValidator.Validate(
    document,
    resolver: null,
    baseDirectory: folder);

var errors = diagnostics.Where(d => d.Severity == MediaBlocksDiagnosticSeverity.Error).ToList();
```

It checks the document's structure, that every block type is known to this build, that each block has a construction path, that pad references parse and point at pads the block actually has, that no feedback cycle exists, and — when you pass a `baseDirectory` — that the files a source reads are present.

Pass `baseDirectory: null` to skip the file-system checks entirely; that is the default, and it keeps the behaviour of a document you validate before its assets are in place.

## Capturing a live pipeline

`ToDocument()` walks the live graph and produces a document. It is safe while the pipeline is running — the block list is taken under the pipeline's own lock and nothing is changed — which makes it the save-during-Run path:

```
var snapshot = pipeline.ToDocument();

if (!snapshot.Complete)
{
    foreach (var diagnostic in snapshot.Diagnostics)
    {
        Console.WriteLine(diagnostic);
    }
}

await MediaBlocksPipelineJsonSerializer.SaveFileAsync(snapshot.Document, "captured.json");
```

`ToJson()` and `SaveJsonAsync(path)` are the one-line forms; they send the diagnostics to the SDK log instead of returning them.

The graph is captured exactly; the settings are not always

A block's identity, type and connections can be read from any block, so the **shape** of a pipeline always round-trips. Its **configuration** can only be read from blocks that expose their settings — 153 of this SDK's 404 block types do. For the rest there is nothing to read, and rather than write a document that looks complete and rebuilds the block on its defaults, the snapshot reports an `MBS060` diagnostic and leaves that block's `settings` empty.

Check `MediaBlocksPipelineSnapshotResult.Complete` before treating a snapshot as a faithful copy. A pipeline that was itself built from a document round-trips fully, because materialization stamps the document's block ids onto the blocks it creates.

## Relative asset paths

Settings that name a file may be relative to the document. Pass the document's folder as `baseDirectory`, and both validation and materialization resolve them against it:

```
var folder = Path.GetDirectoryName(Path.GetFullPath(documentPath));
var result = MediaBlocksPipelineMaterializer.Materialize(document, resolver: null, baseDirectory: folder);
```

The rewriting covers `Uri`-typed settings and string settings named `*Path`, `*File`, `Filename` or `*Location`. Values that name an endpoint rather than a file are left alone — anything with a scheme (`rtsp://`, `srt://:8888/`), an IPv4 literal, or a first segment that reads as a host name (`cam.local/stream.m3u8`). A folder whose name reads like a host is ambiguous, and the validator says so with an `MBS057` warning; prefix such a value with `./` to force the folder reading.

## Diagnostics

Every entry point returns `MediaBlocksDiagnostic` values rather than throwing, so a host can show the whole list at once. Each carries a `Severity`, a `Code`, a `Message` and the `BlockId` it belongs to.

| Code | Meaning |
| --- | --- |
| `MBS031` | unknown block type — this build's catalog has no such block |
| `MBS032` | the block has no construction path |
| `MBS040` | the block could not be constructed |
| `MBS048` / `MBS054` | a pad reference could not be resolved, or a pad is used twice |
| `MBS049` | the settings have no default constructor and the document carries no usable payload |
| `MBS050` | the settings payload could not be deserialized |
| `MBS055` | a file a source reads is not there |
| `MBS056` | a `resources` entry could not be applied |
| `MBS057` | a value that reads as a network endpoint was left as written |
| `MBS060` | a block did not expose its settings to a snapshot |
| `MBS061` | a block could not be named in a snapshot |
| `MBS062` | a connection could not be expressed in a snapshot |
| `MBS063` | the audio device a block names is gone, and another device of the same API is used instead |
| `MBS064` | the audio device a block names could not be attached at all — nothing of that API is present, or the lookup failed |

## Discovering block types

`MediaBlockCatalog` is the index the persistence layer builds on, and it is useful on its own: it lists every block this build carries, with its settings type, its editable properties and an availability probe.

```
foreach (var descriptor in MediaBlockCatalog.All)
{
    Console.WriteLine($"{descriptor.TypeName} - {descriptor.DisplayName} ({descriptor.Category})");
}

var mp4 = MediaBlockCatalog.Get(MediaBlockType.MP4Sink);
Console.WriteLine(mp4.IsSink);                 // true - it ends a branch
Console.WriteLine(mp4.AcceptsDynamicInputs);   // true - one input pad per stream
```

## Demos

A runnable console sample - build a pipeline in code, save it as JSON, rebuild it from that JSON and compare the two - ships with the SDK samples under **[Media Blocks SDK / Console](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/Console)**.

---END OF PAGE---


## Pre-Event Buffering and Recording for IP Cameras in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/pre-event-recording/
**Description:** Implement pre-event buffering for IP cameras in C# .NET. Capture RTSP and webcam footage with motion-triggered recording using VisioForge Media Blocks SDK.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Streaming, Recording, Encoding, Webcam, IP Camera, RTSP, MP4, MKV, TS, H.264, AAC, C#, NuGet
**API:** PreEventRecordingBlock, TeeBlock, SystemVideoSourceBlock, VideoRendererBlock, H264EncoderBlock

# How to Implement Pre-Event Recording for IP Cameras in C

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Table of Contents

- [Overview](#overview)
- [Core Features](#core-features)
- [How It Works](#how-it-works)
- [Prerequisites](#prerequisites)
- [Code Sample: WPF Application with Camera and Motion Detection](#code-sample-wpf-application-with-camera-and-motion-detection)
- [Explanation of the Code](#explanation-of-the-code)
- [Configuration Options](#configuration-options)
- [Key Considerations](#key-considerations)
- [Best Practices](#best-practices)

## Overview

Pre-event recording (also known as circular buffer recording or retrospective recording) is a key surveillance feature that continuously buffers the last N seconds of encoded video and audio in memory. When an event triggers — such as motion detection, an alarm signal, or an API call — the buffered pre-event footage is written to a file along with post-event recording. This creates complete event clips that include footage from before the trigger, so you never miss critical moments.

This guide demonstrates how to record IP camera streams and webcam video with pre-event buffering using the VisioForge Media Blocks SDK for .NET. It covers RTSP camera capture, motion detection triggered recording, and saving event clips to MP4 or MPEG-TS files.

## Core Features

- **Continuous buffering**: Encoded frames are stored in a managed circular buffer with configurable duration
- **Keyframe-aware**: Recording always starts from the nearest video keyframe (I-frame) for proper playback
- **Event-triggered output**: Files are created only when events occur — no continuous disk writes
- **Automatic post-event recording**: Configurable post-event duration with auto-stop
- **Extend on re-trigger**: If triggered again during recording, the post-event timer resets without creating a new file
- **Multiple container formats**: MP4 (default), MPEG-TS (crash-safe), and MKV
- **Thread-safe**: All buffer and state operations are synchronized for multi-threaded access

## How It Works

The `PreEventRecordingBlock` sits at the end of an encoding pipeline and operates in two modes:

**Buffering mode** (normal operation):

1. Encoded video and audio frames flow into the block from upstream encoders
2. Frames are stored in a time-limited circular buffer (ring buffer) in memory
3. When the buffer exceeds the configured `PreEventDuration`, the oldest frames are evicted
4. No disk I/O occurs during buffering

**Recording mode** (after trigger):

1. `TriggerRecording("event_001.mp4")` is called
2. The block finds the earliest video keyframe in the buffer
3. A dynamic output pipeline is created: AppSrc → Muxer → FileSink
4. All buffered frames from the keyframe onward are flushed to the file
5. Live frames continue flowing to the file in real-time
6. After the `PostEventDuration` timer expires, recording stops automatically
7. The output pipeline is torn down and the block returns to buffering mode

```
graph TD;
    A[IP Camera RTSP Source] --> B[Video Encoder H.264];
    A --> C[Audio Encoder AAC];
    B --> D[PreEventRecordingBlock];
    C --> D;
    D --> E{Trigger?};
    E -- No --> F[Ring Buffer in Memory];
    F --> E;
    E -- Yes --> G[Flush Buffer + Record to File];
    G --> H[Post-Event Timer];
    H --> F;
```

## Prerequisites

You'll need the VisioForge Media Blocks SDK. Add it to your .NET project via NuGet:

```
<PackageReference Include="VisioForge.DotNet.MediaBlocks" Version="2025.5.2" />
```

Depending on your target platform, add the corresponding native runtime package. For Windows x64:

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64.UPX" Version="2026.4.29" />
```

For detailed platform-specific dependencies, see the [Deployment Guide](../../../deployment-x/).

## Code Sample: WPF Application with Camera and Motion Detection

The following C# code is based on the [Pre-Event Recording WPF demo](https://github.com/visioforge/.Net-SDK-s-samples). It demonstrates a complete pipeline with a camera source, motion detection for automatic triggering, video preview, and pre-event recording to MP4 files.

Info

For a complete working project with XAML and all dependencies, see the [Pre-Event Recording Media Blocks Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/PreEventRecording%20Demo).

```
using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Windows;

using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AudioEncoders;
using VisioForge.Core.MediaBlocks.AudioRendering;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.MediaBlocks.VideoProcessing;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.PreEventRecording;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.VideoEffects;

public partial class MainWindow : Window, IDisposable
{
    // Pipeline blocks
    private MediaBlocksPipeline _pipeline;
    private MediaBlock _videoSource;
    private MediaBlock _audioSource;
    private TeeBlock _videoTee;
    private TeeBlock _audioTee;
    private VideoRendererBlock _videoRenderer;
    private AudioRendererBlock _audioRenderer;
    private H264EncoderBlock _h264Encoder;
    private AACEncoderBlock _aacEncoder;
    private PreEventRecordingBlock _preEventBlock;
    private MotionDetectionBlock _motionDetector;
    private MotionDetectionBlockSettings _motionSettings;

    private string _outputFolder;
    private System.Timers.Timer _statusTimer;

    private async void BtStart_Click(object sender, RoutedEventArgs e)
    {
        // Ensure output folder exists
        _outputFolder = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.MyVideos),
            "PreEventRecording");
        Directory.CreateDirectory(_outputFolder);

        bool audioEnabled = true;

        // Create pipeline
        _pipeline = new MediaBlocksPipeline();
        _pipeline.OnError += (s, args) => Log($"[Error] {args.Message}");

        // Video source (camera device)
        var device = (await DeviceEnumerator.Shared.VideoSourcesAsync()).FirstOrDefault();
        var videoSourceSettings = new VideoCaptureDeviceSourceSettings(device);
        _videoSource = new SystemVideoSourceBlock(videoSourceSettings);

        // Motion detection (frame differencing, no OpenCV required)
        _motionSettings = new MotionDetectionBlockSettings
        {
            MotionThreshold = 5,
            CompareGreyscale = true,
            GridWidth = 8,
            GridHeight = 8
        };
        _motionDetector = new MotionDetectionBlock(_motionSettings);
        _motionDetector.OnMotionDetected += OnMotionDetected;

        // Video tee: preview + encoder
        _videoTee = new TeeBlock(2, MediaBlockPadMediaType.Video);

        // Video renderer (preview)
        _videoRenderer = new VideoRendererBlock(_pipeline, VideoView1);

        // H264 encoder for the recording branch
        _h264Encoder = new H264EncoderBlock();

        // Pre-event recording block
        var preEventSettings = new PreEventRecordingSettings
        {
            PreEventDuration = TimeSpan.FromSeconds(10),
            PostEventDuration = TimeSpan.FromSeconds(5)
        };
        _preEventBlock = new PreEventRecordingBlock(preEventSettings, "mp4mux");
        _preEventBlock.AudioEnabled = audioEnabled;

        // Subscribe to recording events
        _preEventBlock.OnRecordingStarted += (s, args) =>
            Log($"Recording started: {args.Filename}");
        _preEventBlock.OnRecordingStopped += (s, args) =>
            Log($"Recording stopped: {args.Filename}");
        _preEventBlock.OnStateChanged += (s, args) =>
            Log($"State changed: {args.State}");

        // Connect video: source -> motion detector -> tee -> [renderer, encoder -> preEvent]
        _pipeline.Connect(_videoSource, _motionDetector);
        _pipeline.Connect(_motionDetector, _videoTee);
        _pipeline.Connect(_videoTee, _videoRenderer);
        _pipeline.Connect(_videoTee, _h264Encoder);
        _pipeline.Connect(_h264Encoder.Output, _preEventBlock.VideoInput);

        // Connect audio: source -> tee -> [renderer, encoder -> preEvent]
        if (audioEnabled)
        {
            var audioDevice = (await DeviceEnumerator.Shared.AudioSourcesAsync()).FirstOrDefault();
            if (audioDevice != null)
            {
                _audioSource = new SystemAudioSourceBlock(audioDevice.CreateSourceSettings(null));
                _audioTee = new TeeBlock(2, MediaBlockPadMediaType.Audio);
                _audioRenderer = new AudioRendererBlock();
                _aacEncoder = new AACEncoderBlock();

                _pipeline.Connect(_audioSource, _audioTee);
                _pipeline.Connect(_audioTee, _audioRenderer);
                _pipeline.Connect(_audioTee, _aacEncoder);
                _pipeline.Connect(_aacEncoder.Output, _preEventBlock.AudioInput);
            }
        }

        // Start pipeline — buffering begins immediately
        await _pipeline.StartAsync();

        // Start status timer to display buffer stats
        _statusTimer = new System.Timers.Timer(500);
        _statusTimer.Elapsed += (s, args) => UpdateStatus();
        _statusTimer.Start();

        Log("Pipeline started. Buffering...");
    }

    // Motion detection handler: auto-trigger recording on motion
    private void OnMotionDetected(object sender, MotionDetectionEventArgs e)
    {
        if (_preEventBlock == null) return;

        bool isMotion = e.Level >= _motionSettings.MotionThreshold;
        if (!isMotion) return;

        var state = _preEventBlock.State;
        if (state == PreEventRecordingState.Buffering)
        {
            var filename = Path.Combine(_outputFolder,
                $"motion_{DateTime.Now:yyyyMMdd_HHmmss}.mp4");
            _preEventBlock.TriggerRecording(filename);
            Log($"Motion triggered recording: {filename}");
        }
        else if (state == PreEventRecordingState.Recording ||
                 state == PreEventRecordingState.PostEventRecording)
        {
            // Motion still active — extend the recording
            _preEventBlock.ExtendRecording();
        }
    }

    // Manual trigger button
    private void BtTrigger_Click(object sender, RoutedEventArgs e)
    {
        if (_preEventBlock == null) return;

        var filename = Path.Combine(_outputFolder,
            $"event_{DateTime.Now:yyyyMMdd_HHmmss}.mp4");
        _preEventBlock.TriggerRecording(filename);
        Log($"Trigger recording: {filename}");
    }

    // Manual stop recording button
    private void BtStopRec_Click(object sender, RoutedEventArgs e)
    {
        _preEventBlock?.StopRecording();
        Log("Recording stopped manually.");
    }

    // Extend recording button
    private void BtExtend_Click(object sender, RoutedEventArgs e)
    {
        _preEventBlock?.ExtendRecording();
        Log("Post-event timer extended.");
    }

    // Monitor buffer status periodically
    private void UpdateStatus()
    {
        if (_preEventBlock == null) return;

        var state = _preEventBlock.State;
        var totalBytes = _preEventBlock.BufferTotalBytes;
        var duration = _preEventBlock.BufferedDuration;

        Dispatcher.Invoke(() =>
        {
            lbState.Text = $"State: {state}";
            lbBufferStats.Text = $"Buffer: {totalBytes / 1024.0:F1} KB, {duration.TotalSeconds:F1}s";
        });
    }

    // Stop pipeline and clean up
    private async void BtStop_Click(object sender, RoutedEventArgs e)
    {
        _statusTimer?.Stop();
        _statusTimer?.Dispose();

        if (_pipeline != null)
        {
            await _pipeline.StopAsync();
            _pipeline.Dispose();
            _pipeline = null;
        }

        if (_motionDetector != null)
        {
            _motionDetector.OnMotionDetected -= OnMotionDetected;
            _motionDetector = null;
        }

        _preEventBlock = null;
        _videoSource = null;
        _audioSource = null;

        Log("Pipeline stopped.");
    }
}
```

## Explanation of the Code

1. **Video Source**: The `SystemVideoSourceBlock` captures video from a local camera device. For RTSP IP cameras, use `RTSPSourceBlock` with `RTSPSourceSettings.CreateAsync()` instead.
2. **Motion Detection**: The `MotionDetectionBlock` performs frame-differencing-based motion detection without requiring OpenCV. It fires `OnMotionDetected` events that the application uses to automatically trigger recordings.
3. **Video Tee**: The `TeeBlock` splits the video stream into two branches — one for live preview via `VideoRendererBlock`, and one for H.264 encoding and pre-event buffering.
4. **H264 Encoder**: The `H264EncoderBlock` encodes raw video frames for the pre-event block. The block automatically selects the best available encoder (hardware-accelerated if available).
5. **PreEventRecordingBlock**: The core component. It receives encoded video and audio, stores them in a ring buffer, and creates dynamic output files on trigger. The `"mp4mux"` parameter sets MP4 as the output format.
6. **Audio Path**: Audio follows a similar pattern — tee splits to renderer (playback) and AAC encoder, which feeds into the pre-event block.
7. **Event Handling**: Three events notify your application:

   - `OnRecordingStarted` — fired when buffer flush begins
   - `OnRecordingStopped` — fired when recording finishes
   - `OnStateChanged` — fired on every state transition
8. **Status Monitoring**: A timer periodically reads `BufferTotalBytes` and `BufferedDuration` to display buffer health in the UI.

### Using an RTSP source

When using an RTSP IP camera instead of a local camera, replace the source setup:

```
// Replace SystemVideoSourceBlock with RTSPSourceBlock
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.21:554/Streaming/Channels/101"),
    login: "admin",
    password: "password",
    audioEnabled: true);

var rtspSource = new RTSPSourceBlock(rtspSettings);
_videoSource = rtspSource;

// Video path is the same: rtspSource -> motionDetector -> tee -> ...

// Audio comes from the RTSP source instead of a system audio device:
_pipeline.Connect(rtspSource.AudioOutput, _audioTee.Input);
```

## Configuration Options

### Buffer duration

```
var settings = new PreEventRecordingSettings
{
    PreEventDuration = TimeSpan.FromSeconds(60),  // Buffer last 60 seconds
    PostEventDuration = TimeSpan.FromSeconds(30)   // Record 30s after trigger
};
```

### Memory limit

```
var settings = new PreEventRecordingSettings
{
    PreEventDuration = TimeSpan.FromSeconds(30),
    PostEventDuration = TimeSpan.FromSeconds(10),
    MaxBufferBytes = 50 * 1024 * 1024  // Hard limit: 50 MB per camera
};
```

### MPEG-TS for crash safety

```
// MPEG-TS files are always playable even if the process crashes during recording
var preEventBlock = new PreEventRecordingBlock(settings, "mpegtsmux");
preEventBlock.TriggerRecording("/recordings/event_001.ts");
```

### MKV output

```
var preEventBlock = new PreEventRecordingBlock(settings, "matroskamux");
preEventBlock.TriggerRecording("/recordings/event_001.mkv");
```

### Disable audio

```
var preEventBlock = new PreEventRecordingBlock(settings, "mp4mux");
preEventBlock.AudioEnabled = false;

// Only connect video
pipeline.Connect(rtspSource.VideoOutput, preEventBlock.VideoInput);
```

## Key Considerations

- **Memory usage**: 30 seconds of buffered H.264 video at 4 Mbps plus AAC audio at 128 kbps uses approximately 15.5 MB of managed memory per camera. Scale accordingly when monitoring multiple cameras.
- **Keyframe alignment**: The actual pre-event duration in the output file may be slightly less than configured, as the buffer drains from the nearest keyframe. With a typical 2-second GOP, the actual pre-event footage starts within 2 seconds of the configured duration.
- **Re-trigger behavior**: Calling `TriggerRecording()` while already recording extends the current recording rather than creating a new file. Call `StopRecording()` first if you need a new file.
- **Container format**: Use MP4 for maximum compatibility. Use MPEG-TS for crash safety in unattended/headless deployments where power loss or crashes may occur.
- **Encoded input required**: The `PreEventRecordingBlock` expects encoded frames. When using sources that output raw video (like `SystemVideoSourceBlock`), add encoder blocks (H264, HEVC) between the source and the pre-event block.

## Best Practices

- Set `PreEventDuration` based on your application requirements — longer buffers use more memory but capture more context
- Use `MaxBufferBytes` as a safety net in multi-camera systems to prevent unbounded memory growth
- Subscribe to `OnRecordingStopped` to confirm recordings were finalized successfully
- Use MPEG-TS for surveillance applications running unattended
- Implement a file naming strategy that includes timestamps (e.g., `event_2024-01-15_14-30-00.mp4`) for easy organization
- Monitor `BufferTotalBytes` periodically to verify the buffer is being populated and evicted correctly

---END OF PAGE---


## RTSP Stream Viewer and IP Camera Player in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/rtsp-player-csharp/
**Description:** Build an RTSP stream viewer and IP camera player in C# with VisioForge Media Blocks SDK — live preview, ONVIF discovery, and passthrough recording.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Streaming, Recording, Encoding, Decoding, IP Camera, RTSP, ONVIF, UDP, MP4, TS, AAC, C#, NuGet
**API:** RTSPSourceSettings, RTSPSourceBlock, MediaBlocksPipeline, VideoRendererBlock, RTSPRAWSourceBlock

# RTSP Stream Viewer and IP Camera Player in C

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Introduction

This guide walks you through building an RTSP stream viewer and IP camera player application in C# using the VisioForge Media Blocks SDK. You will learn how to connect to IP cameras via RTSP, display live video with audio, discover cameras using ONVIF, and record streams to file — with or without re-encoding. The Media Blocks SDK runs on Windows, macOS, and Linux, so the same code works across platforms.

Common use cases include surveillance dashboards, NVR (network video recorder) applications, camera management tools, and any project that needs to display or record IP camera feeds programmatically.

Info

For complete working examples, see the [RTSP demos on GitHub](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK): RTSP Preview Demo, RTSP RAW Capture Demo, and RTSP MultiView Demo.

!!!

## Prerequisites

Add the Media Blocks SDK NuGet package to your project:

```
<PackageReference Include="VisioForge.DotNet.MediaBlocks" Version="2025.5.2" />
```

You also need the platform-specific runtime packages. For Windows:

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64.UPX" Version="2026.4.29" />
```

For other platforms (macOS, Linux, Android, iOS), see the [Deployment Guide](../../../deployment-x/).

## Live RTSP Preview

The core pattern connects an RTSP source to video and audio renderers through a `MediaBlocksPipeline`. Initialize the SDK once at application startup, then create pipelines as needed.

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.MediaBlocks.AudioRendering;
using VisioForge.Core.Types.X.Sources;

// Initialize SDK once at startup
await VisioForgeX.InitSDKAsync();

// Create the pipeline
var pipeline = new MediaBlocksPipeline();

// Connect to the RTSP camera
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.21:554/Streaming/Channels/101"),
    "admin",          // login
    "password",       // password
    true);            // audio enabled

var rtspSource = new RTSPSourceBlock(rtspSettings);

// Create video renderer (VideoView1 is an IVideoView control on your form)
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(rtspSource.VideoOutput, videoRenderer.Input);

// Create audio renderer (optional)
var audioRenderer = new AudioRendererBlock();
pipeline.Connect(rtspSource.AudioOutput, audioRenderer.Input);

// Start playback
await pipeline.StartAsync();
```

To stop playback and release resources:

```
await pipeline.StopAsync();
await pipeline.DisposeAsync();
```

## RTSP Authentication

Most IP cameras require credentials to access the video stream. You can provide authentication in two ways.

**Credentials as parameters** — pass username and password to `RTSPSourceSettings.CreateAsync()`:

```
var settings = await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.21:554/stream"),
    "admin",      // username
    "mypassword", // password
    true);        // audio enabled
```

**Credentials in the URL** — embed them directly in the RTSP URI:

```
var settings = await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://admin:mypassword@192.168.1.21:554/stream"),
    null, null, true);
```

For ONVIF cameras, authenticate through `ONVIFClientX` to retrieve the stream URI automatically — see the [ONVIF Camera Discovery](#onvif-camera-discovery) section below. Most cameras use digest authentication by default. If you encounter connection failures, verify that your camera's authentication mode matches (digest vs basic) and that the RTSP port (typically 554) is accessible.

## Low-Latency Mode

For real-time monitoring or PTZ control, enable low-latency mode to cut the jitter buffer from the default 500ms to 150ms. Set `Latency` to 150ms or less to go lower:

```
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.21:554/stream"),
    "admin", "password", true);

rtspSettings.LowLatencyMode = true;

var rtspSource = new RTSPSourceBlock(rtspSettings);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
videoRenderer.IsSync = false; // Disable A/V sync for lowest latency

pipeline.Connect(rtspSource.VideoOutput, videoRenderer.Input);
```

For detailed buffer tuning and UDP vs TCP transport configuration, see the [RTSP Protocol Configuration](../../../videocapture/video-sources/ip-cameras/rtsp/) reference.

## ONVIF Camera Discovery

Automatically discover IP cameras on the local network using the ONVIF discovery protocol, then retrieve stream URIs and camera information.

```
using VisioForge.Core.ONVIFDiscovery;
using VisioForge.Core.ONVIFX;

// Discover cameras on the network (5-second timeout)
var discovery = new Discovery();
var cameras = await discovery.Discover(5);

foreach (var camera in cameras)
{
    Console.WriteLine($"Found camera: {camera.XAdresses?.FirstOrDefault()}");
}

// Connect to a specific camera via ONVIF
var onvifClient = new ONVIFClientX();
bool connected = await onvifClient.ConnectAsync(
    "http://192.168.1.21/onvif/device_service",
    "admin",
    "password");

if (connected)
{
    // Get camera info
    var info = onvifClient.DeviceInformation;
    Console.WriteLine($"Camera: {info?.Model}, Serial: {info?.SerialNumber}");

    // Get available profiles and stream URI
    var profiles = await onvifClient.GetProfilesAsync();
    if (profiles?.Length > 0)
    {
        var mediaUri = await onvifClient.GetStreamUriAsync(profiles[0]);
        Console.WriteLine($"Stream URI: {mediaUri.Uri}");
    }
}
```

For PTZ control, multiple profiles, and advanced ONVIF features, see the [ONVIF IP Camera Integration](../../../videocapture/video-sources/ip-cameras/onvif/) guide.

## Recording Options

There are two approaches to recording RTSP streams, each suited for different use cases:

|  | Passthrough (No Re-encoding) | Re-encoding |
| --- | --- | --- |
| CPU usage | Minimal | High |
| Video quality | Original (lossless) | Re-compressed |
| File size | Same as source | Configurable bitrate |
| Video processing | No overlays, resize, or effects | Full editing capability |
| Best for | Surveillance archival, NVR | Streaming, post-processing |

### Recording with Passthrough (No Re-encoding)

Passthrough recording saves the original compressed stream directly to a file without decoding or re-encoding the video. This approach uses `RTSPRAWSourceBlock` instead of `RTSPSourceBlock` — the video data passes straight from the camera to the file sink with zero CPU overhead for video processing.

```
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.MediaBlocks.AudioEncoders;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Sources;

// Create a separate pipeline for recording
var recordPipeline = new MediaBlocksPipeline();

// Create RAW RTSP source (receives compressed stream directly)
var rawSettings = await RTSPRAWSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.21:554/stream"),
    "admin", "password", true);

var rawSource = new RTSPRAWSourceBlock(rawSettings);

// Create MP4 file sink
var muxer = new MP4SinkBlock(new MP4SinkSettings("output.mp4"));

// Connect video — no decoding, no re-encoding
var videoPad = (muxer as IMediaBlockDynamicInputs)
    .CreateNewInput(MediaBlockPadMediaType.Video);
recordPipeline.Connect(rawSource.VideoOutput, videoPad);

// Connect audio — re-encode to AAC for MP4 compatibility
var audioPad = (muxer as IMediaBlockDynamicInputs)
    .CreateNewInput(MediaBlockPadMediaType.Audio);

var decodeBin = new DecodeBinBlock(false, true, false);
var aacEncoder = new AACEncoderBlock(new AVENCAACEncoderSettings());

recordPipeline.Connect(rawSource.AudioOutput, decodeBin.Input);
recordPipeline.Connect(decodeBin.AudioOutput, aacEncoder.Input);
recordPipeline.Connect(aacEncoder.Output, audioPad);

await recordPipeline.StartAsync();
```

**Container format choice:** Use MP4 for broad playback compatibility. Use MPEG-TS (`MPEGTSSinkBlock`) for crash-safe recording — if the process terminates unexpectedly, all data written up to that point is preserved. MPEG-TS is preferred for 24/7 surveillance recording.

For a complete implementation with error handling, state management, and resource cleanup, see the [Save RTSP Stream Without Re-encoding](../rtsp-save-original-stream/) guide.

### Recording with Re-encoding

When you need to resize the video, add overlays or watermarks, change the codec, or reduce the bitrate, use `RTSPSourceBlock` (which decodes the stream) followed by encoder blocks:

```
// RTSPSourceBlock decodes the stream, allowing processing
var rtspSource = new RTSPSourceBlock(rtspSettings);
var mp4Sink = new MP4SinkBlock("output.mp4");

// Video: decoded → (optional processing) → encode to H.264 → mux
// Audio: decoded → encode to AAC → mux

pipeline.Connect(rtspSource.VideoOutput, /* encoder/processing blocks */);
```

For detailed code examples of recording with video processing (resize, effects, face detection), see the [ONVIF Capture with Postprocessing](../onvif-capture-with-postprocessing/) guide. For a simpler re-encoding example, see the [IP Camera Capture to MP4](../../../videocapture/video-tutorials/ip-camera-capture-mp4/) tutorial.

## Multi-Camera View

To display multiple IP cameras simultaneously, create independent `MediaBlocksPipeline` instances — one per camera. Each pipeline runs in its own thread and can be started and stopped independently.

```
// Create separate pipelines for each camera
var pipeline1 = new MediaBlocksPipeline();
var pipeline2 = new MediaBlocksPipeline();

// Camera 1
var source1 = new RTSPSourceBlock(await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.21:554/stream"), "admin", "pass1", true));
var renderer1 = new VideoRendererBlock(pipeline1, VideoView1);
pipeline1.Connect(source1.VideoOutput, renderer1.Input);

// Camera 2
var source2 = new RTSPSourceBlock(await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.22:554/stream"), "admin", "pass2", true));
var renderer2 = new VideoRendererBlock(pipeline2, VideoView2);
pipeline2.Connect(source2.VideoOutput, renderer2.Input);

// Start both
await pipeline1.StartAsync();
await pipeline2.StartAsync();
```

The [RTSP MultiView Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WinForms/CSharp/RTSP%20MultiView%20Demo) on GitHub shows a grid layout with per-camera record controls and passthrough recording.

## Frequently Asked Questions

### How do I authenticate with an RTSP IP camera in C#?

Embed credentials directly in the RTSP URL (`rtsp://user:pass@ip:554/path`) or pass them as separate parameters to `RTSPSourceSettings.CreateAsync()`. For ONVIF cameras, connect via `ONVIFClientX` first with username and password, then retrieve the authenticated stream URI using `GetStreamUriAsync()`. Most cameras support digest authentication by default.

### Should I use passthrough or re-encoding when recording RTSP streams?

Use passthrough for surveillance archival and NVR applications — it requires zero CPU for video processing and preserves the original camera quality. Use re-encoding when you need to resize, add overlays, change codec or bitrate, or stream to a different format. Most professional recording applications use passthrough to minimize server load.

### How do I reduce RTSP stream latency below 100ms?

Enable `LowLatencyMode = true` on `RTSPSourceSettings` (150ms jitter buffer vs the default 500ms). For even lower delay, set `Latency` to 150ms or less and disable video renderer sync with `IsSync = false`. Use UDP transport when your network supports it. See the [RTSP protocol guide](../../../videocapture/video-sources/ip-cameras/rtsp/) for advanced buffer tuning options.

### Preview works in VLC but freezes or ends after about a minute?

The default protocol list tries UDP first. Force TCP, and if the camera still drops the session, enable `ForceCustomKeepAlive` so the source sends GET\_PARAMETER every 30 seconds:

```
rtspSettings.AllowedProtocols = RTSPSourceProtocol.TCP;
rtspSettings.ForceCustomKeepAlive = true;
```

### Can I view and record from multiple IP cameras simultaneously?

Yes. Create separate `MediaBlocksPipeline` instances for each camera — each pipeline runs independently with its own RTSP connection, decoder, and renderer. You can add per-camera recording by creating additional recording pipelines using `RTSPRAWSourceBlock` for passthrough capture. The RTSP MultiView Demo on GitHub shows a complete implementation with grid layout and individual record controls.

### Which container format should I use for passthrough recording — MP4 or MPEG-TS?

Use MP4 for standard playback compatibility across devices and players. Use MPEG-TS for crash-safe recording — if the application or system crashes during recording, all data written up to the failure point is preserved. For 24/7 surveillance or mission-critical recording, MPEG-TS is the recommended choice.

## See Also

- [Save RTSP Stream Without Re-encoding](../rtsp-save-original-stream/) — detailed passthrough recording with full RTSPRecorder class implementation
- [ONVIF IP Camera Integration](../../../videocapture/video-sources/ip-cameras/onvif/) — ONVIF discovery, profiles, PTZ control
- [RTSP Protocol Configuration](../../../videocapture/video-sources/ip-cameras/rtsp/) — UDP vs TCP, buffer settings, low-latency tuning
- [IP Camera Capture to MP4](../../../videocapture/video-tutorials/ip-camera-capture-mp4/) — recording with re-encoding tutorial
- [ONVIF Capture with Postprocessing](../onvif-capture-with-postprocessing/) — resize, effects, face blur during recording
- [Multi-camera RTSP grid (NVR wall)](../multi-camera-rtsp-grid/) — scale from a single player to a 4×4 live preview wall on WPF or MAUI
- [RTSP reconnection and fallback switch](../../../general/network-sources/reconnection-and-fallback/) — handle camera drops with reconnect events and declarative `FallbackSwitch`
- [Code Samples on GitHub](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK) — RTSP preview, capture, and multi-view demos
- [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) — product page and downloads

---END OF PAGE---


## Save RTSP Stream to MP4 Without Re-encoding in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/rtsp-save-original-stream/
**Description:** Record IP camera RTSP streams directly to MP4 files without transcoding using VisioForge Media Blocks SDK. Passthrough capture with C# code examples.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Streaming, Recording, Encoding, Decoding, Conversion, IP Camera, RTSP, ONVIF, MP4, AAC, C#, NuGet
**API:** RTSPRecorder, MediaBlocksPipeline, RTSPRAWSourceBlock, RTSPRAWSourceSettings, AACEncoderBlock

# How to Save RTSP Stream to File: Record IP Camera Video without Re-encoding

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Info

For a complete working example of recording RTSP streams without re-encoding, see the [RTSP MultiView Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WinForms/CSharp/RTSP%20MultiView%20Demo).

For ONVIF camera-specific documentation, see the [ONVIF IP Camera Integration Guide](../../../videocapture/video-sources/ip-cameras/onvif/). !!!

## Table of Contents

- [How to Save RTSP Stream to File: Record IP Camera Video without Re-encoding](#how-to-save-rtsp-stream-to-file-record-ip-camera-video-without-re-encoding)
- [Table of Contents](#table-of-contents)
- [Overview](#overview)
- [Core Features](#core-features)
- [Core Concept](#core-concept)
- [Prerequisites](#prerequisites)
- [Code Sample: RTSPRecorder Class](#code-sample-rtsprecorder-class)
- [Explanation of the Code](#explanation-of-the-code)
- [How to Use the `RTSPRecorder`](#how-to-use-the-rtsprecorder)
- [Key Considerations](#key-considerations)
- [Full GitHub Sample](#full-github-sample)
- [Best Practices](#best-practices)
- [Troubleshooting](#troubleshooting)

## Overview

This guide demonstrates how to save an RTSP stream to an MP4 file by capturing the original video stream from an RTSP IP camera without re-encoding the video. This approach is highly beneficial for preserving the original video quality from cameras and minimizing CPU usage when you need to record footage. The audio stream can be passed through or, optionally, re-encoded for better compatibility, allowing you to save the complete streaming data. Tools like FFmpeg and VLC offer command-line or UI-based methods to record an RTSP stream; however, this guide focuses on a programmatic approach using the VisioForge Media Blocks SDK for .NET developers who need to create applications that connect to and record video from RTSP cameras.

## Core Features

- **Direct Stream Recording**: Save RTSP camera feeds without quality loss
- **CPU-Efficient Processing**: No video re-encoding required
- **Flexible Audio Handling**: Pass-through or re-encode audio as needed
- **Professional Integration**: Programmatic control for enterprise applications
- **High Performance**: Optimized for continuous recording

We will be using the VisioForge Media Blocks SDK, a powerful .NET library for building custom media processing applications, to effectively save RTSP to file.

## Core Concept

The main idea is to take the raw video stream from the RTSP source and directly send it to a file sink (e.g., MP4 muxer) without any decoding or encoding steps for the video. This is a common requirement for recording RTSP streams with maximum fidelity.

- **Video Stream**: Passed through directly from the RTSP source to the MP4 sink. This ensures the original video data is saved, crucial for applications that need to record high-quality footage from cameras.
- **Audio Stream**: Can either be passed through directly (if the original audio codec is compatible with the MP4 container) or re-encoded (e.g., to AAC) to ensure compatibility and potentially reduce file size when you save the RTSP stream.

## Prerequisites

You'll need the VisioForge Media Blocks SDK. You can add it to your .NET project via NuGet:

```
<PackageReference Include="VisioForge.DotNet.MediaBlocks" Version="2025.5.2" />
```

Depending on your target platform (Windows, macOS, Linux, including ARM-based systems like Jetson Nano for embedded camera applications), you will also need the corresponding native runtime packages. For example, on Windows to record video:

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64.UPX" Version="2026.4.29" />
```

For detailed information about deployment requirements, and platform-specific dependencies, please refer to our [Deployment Guide](../../../deployment-x/). It's important to check these details to ensure your video stream capture application works correctly.

Refer to the `RTSP Capture Original.csproj` file in the sample project for a complete list of dependencies for different platforms.

## Code Sample: RTSPRecorder Class

The following C# code defines an `RTSPRecorder` class that encapsulates the logic for capturing and saving the RTSP stream.

```
using System;
using System.Threading.Tasks;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AudioEncoders;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;

namespace RTSPCaptureOriginalStream
{
    /// <summary>
    /// RTSPRecorder class encapsulates the RTSP recording functionality to save RTSP stream to file.
    /// It uses the Media Blocks SDK to create a pipeline that connects an
    /// RTSP source (like an IP camera) to an MP4 sink (file).
    /// </summary>
    public class RTSPRecorder : IAsyncDisposable
    {
        /// <summary>
        /// The MediaBlocks pipeline that manages the flow of media data.
        /// </summary>
        public MediaBlocksPipeline Pipeline { get; private set; }

        // Private fields for the MediaBlock components
        private MediaBlock _muxer;               // MP4 container muxer (sink)
        private RTSPRAWSourceBlock _rtspRawSource; // RTSP stream source (provides raw streams)
        private DecodeBinBlock _decodeBin;       // Optional: Audio decoder (if re-encoding audio)
        private AACEncoderBlock _audioEncoder;   // Optional: AAC audio encoder (if re-encoding audio)
        private bool disposedValue;              // Flag to prevent multiple disposals

        /// <summary>
        /// Event fired when an error occurs in the pipeline.
        /// </summary>
        public event EventHandler<ErrorsEventArgs> OnError;

        /// <summary>
        /// Event fired when a status message is available.
        /// </summary>
        public event EventHandler<string> OnStatusMessage;

        /// <summary>
        /// Output filename for the MP4 recording.
        /// </summary>
        public string Filename { get; set; } = "output.mp4";

        /// <summary>
        /// Whether to re-encode audio to AAC format (recommended for compatibility).
        /// If false, audio is passed through.
        /// </summary>
        public bool ReencodeAudio { get; set; } = true;

        /// <summary>
        /// Starts the recording session by creating and configuring the MediaBlocks pipeline.
        /// </summary>
        /// <param name="rtspSettings">RTSP source configuration settings.</param>
        /// <returns>True if the pipeline started successfully, false otherwise.</returns>
        public async Task<bool> StartAsync(RTSPRAWSourceSettings rtspSettings)
        {
            // Create a new MediaBlocks pipeline
            Pipeline = new MediaBlocksPipeline();
            Pipeline.OnError += (sender, e) => OnError?.Invoke(this, e); // Bubble up errors

            OnStatusMessage?.Invoke(this, "Creating pipeline to record RTSP stream...");

            // 1. Create the RTSP source block.
            // RTSPRAWSourceBlock provides raw, un-decoded elementary streams (video and audio) from your IP camera or other RTSP cameras.
            _rtspRawSource = new RTSPRAWSourceBlock(rtspSettings);

            // 2. Create the MP4 sink (muxer) block.
            // This block will write the media streams into an MP4 file.
            _muxer = new MP4SinkBlock(new MP4SinkSettings(Filename));

            // 3. Connect Video Stream (Passthrough)
            // Create a dynamic input pad on the muxer for the video stream.
            // We connect the raw video output from the RTSP source directly to the MP4 sink.
            // This ensures the video is not re-encoded when you record the camera feed.
            var inputVideoPad = (_muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Video);
            Pipeline.Connect(_rtspRawSource.VideoOutput, inputVideoPad);
            OnStatusMessage?.Invoke(this, "Video stream connected (passthrough for original quality video).");

            // 4. Connect Audio Stream (Optional Re-encoding)
            // This section handles how the audio from the RTSP stream is processed and saved to the file.
            if (rtspSettings.AudioEnabled)
            {
                // Create a dynamic input pad on the muxer for the audio stream.
                var inputAudioPad = (_muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Audio);

                if (ReencodeAudio)
                {
                    // If audio re-encoding is enabled (e.g., to AAC for compatibility):
                    OnStatusMessage?.Invoke(this, "Setting up audio re-encoding to AAC for the recording...");

                    // Create a decoder block that only handles audio.
                    // We need to decode the original audio before re-encoding it to save the MP4 stream with compatible audio.
                    _decodeBin = new DecodeBinBlock(renderVideo: false, renderAudio: true, renderSubtitle: false)
                    {
                         // We can disable the internal audio converter if we're sure about the format
                         // or if the encoder handles conversion. For AAC, it's generally fine.
                         DisableAudioConverter = true
                    };

                    // Create an AAC encoder with default settings.
                    _audioEncoder = new AACEncoderBlock(new AVENCAACEncoderSettings());

                    // Connect the audio processing pipeline:
                    // RTSP audio output -> Decoder -> AAC Encoder -> MP4 Sink audio input
                    Pipeline.Connect(_rtspRawSource.AudioOutput, _decodeBin.Input);
                    Pipeline.Connect(_decodeBin.AudioOutput, _audioEncoder.Input);
                    Pipeline.Connect(_audioEncoder.Output, inputAudioPad);
                    OnStatusMessage?.Invoke(this, "Audio stream connected (re-encoding to AAC for MP4 file).");
                }
                else
                {
                    // If audio re-encoding is disabled, connect RTSP audio directly to the muxer.
                    // Note: This may cause issues if the original audio format is not
                    // compatible with the MP4 container (e.g., G.711 PCMU/PCMA) when trying to save the RTSP stream.
                    // Common compatible formats include AAC. Check your camera's audio format.
                    Pipeline.Connect(_rtspRawSource.AudioOutput, inputAudioPad);
                    OnStatusMessage?.Invoke(this, "Audio stream connected (passthrough). Warning: Compatibility depends on original camera audio format for the file.");
                }
            }

            // 5. Start the pipeline to record video
            OnStatusMessage?.Invoke(this, "Starting recording pipeline to save RTSP stream to file...");
            bool success = await Pipeline.StartAsync();
            if (success)
            {
                OnStatusMessage?.Invoke(this, "Recording pipeline started successfully.");
            }
            else
            {
                OnStatusMessage?.Invoke(this, "Failed to start recording pipeline.");
            }
            return success;
        }

        /// <summary>
        /// Stops the recording by stopping the MediaBlocks pipeline.
        /// </summary>
        /// <returns>True if the pipeline stopped successfully, false otherwise.</returns>
        public async Task<bool> StopAsync()
        {
            if (Pipeline == null)
                return false;

            OnStatusMessage?.Invoke(this, "Stopping recording pipeline...");
            bool success = await Pipeline.StopAsync();
            if (success)
            {
                OnStatusMessage?.Invoke(this, "Recording pipeline stopped successfully.");
            }
            else
            {
                OnStatusMessage?.Invoke(this, "Failed to stop recording pipeline.");
            }

            // Detach the error handler to prevent issues if StopAsync is called multiple times
            // or before DisposeAsync
            if (Pipeline != null)
            {
                 Pipeline.OnError -= OnError;
            }

            return success;
        }

        /// <summary>
        /// Asynchronously disposes of the RTSPRecorder and all its resources.
        /// Implements the IAsyncDisposable pattern for proper resource cleanup.
        /// </summary>
        public async ValueTask DisposeAsync()
        {
            if (!disposedValue)
            {
                if (Pipeline != null)
                {
                    Pipeline.OnError -= (sender, e) => OnError?.Invoke(this, e); // Ensure detachment
                    await Pipeline.DisposeAsync();
                    Pipeline = null;
                }

                // Dispose of all MediaBlock components
                // Using 'as IDisposable' for safe casting and disposal.
                (_muxer as IDisposable)?.Dispose();
                _muxer = null;

                _rtspRawSource?.Dispose();
                _rtspRawSource = null;

                _decodeBin?.Dispose();
                _decodeBin = null;

                _audioEncoder?.Dispose();
                _audioEncoder = null;

                disposedValue = true;
            }
        }
    }
}
```

## Explanation of the Code

1. **`RTSPRecorder` Class**: This class is central to helping a user save RTSP stream to file.

   - Implements `IAsyncDisposable` for proper resource management.
   - `Pipeline`: The `MediaBlocksPipeline` object that orchestrates the media flow.
   - `_rtspRawSource`: An `RTSPRAWSourceBlock` is used. The "RAW" is key here, as it provides the elementary streams (video and audio) from camera without attempting to decode them initially.
   - `_muxer`: An `MP4SinkBlock` is used to write the incoming video and audio streams into an MP4 file.
   - `_decodeBin` and `_audioEncoder`: These are optional blocks used only if `ReencodeAudio` is true. `_decodeBin` decodes the original audio from the IP camera, and `_audioEncoder` (e.g., `AACEncoderBlock`) re-encodes it to a more compatible format like AAC.
   - `Filename`: Specifies the output MP4 file path where the video will be saved.
   - `ReencodeAudio`: A boolean property to control audio processing. If `true`, audio is re-encoded to AAC. If `false`, audio is passed through directly. Check your camera audio format for compatibility if set to false.
2. **`StartAsync(RTSPRAWSourceSettings rtspSettings)` Method**: This method initiates the process to **record RTSP stream**.

   - Initializes `MediaBlocksPipeline`.
   - **RTSP Source**: Creates `_rtspRawSource` with `RTSPRAWSourceSettings`. These settings include the URL (the path to your camera's stream), credentials for user access, and audio capture settings.
   - **MP4 Sink**: Creates `_muxer` (MP4 sink) with the target filename.
   - **Video Path (Passthrough)**:
     - A new dynamic input pad for video is created on the `_muxer`.
     - `Pipeline.Connect(_rtspRawSource.VideoOutput, inputVideoPad);` This line directly connects the raw video output from the RTSP source to the MP4 muxer's\*video input. No re-encoding occurs for the video stream.
   - **Audio Path (Conditional)**: Determines how audio from the **camera** is handled when you **save to file**.
     - If `rtspSettings.AudioEnabled` is true:
       - A new dynamic input pad for audio is created on the `_muxer`.
       - If `ReencodeAudio` is `true` (recommended for wider file compatibility):
         - `_decodeBin` is created to decode the incoming audio from the camera. It's configured to only process audio (`audioDisabled: false`).
         - `_audioEncoder` (e.g., `AACEncoderBlock`) is created.
         - The pipeline is connected: `_rtspRawSource.AudioOutput` -> `_decodeBin.Input` -> `_decodeBin.AudioOutput` -> `_audioEncoder.Input` -> `_audioEncoder.Output` -> `inputAudioPad` (muxer's audio input).
       - If `ReencodeAudio` is `false`:
         - `Pipeline.Connect(_rtspRawSource.AudioOutput, inputAudioPad);` The raw audio output from the camera source is connected directly to the MP4 muxer. *Caution*: This relies on the original audio codec from the camera being compatible with the MP4 container (e.g., AAC). Formats like G.711 (PCMU/PCMA) are common in RTSP cameras but are not standard in MP4 and might lead to playback issues or require specialized players if you save this way. Check your camera's documentation.
   - Starts the pipeline using `Pipeline.StartAsync()` to begin the streaming video record process.
3. **`StopAsync()` Method**: Stops the `Pipeline`.
4. **`DisposeAsync()` Method**:

   - Cleans up all resources, including the pipeline and individual media blocks.

## How to Use the `RTSPRecorder`

Here's a basic example of how you might use the `RTSPRecorder` class:

```
using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using VisioForge.Core; // For VisioForgeX.DestroySDK()
using VisioForge.Core.Types.X.Sources; // For RTSPRAWSourceSettings
using RTSPCaptureOriginalStream; // Namespace of your RTSPRecorder class

class Demo
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("RTSP Camera to MP4 Capture (Original Video Stream)");
        Console.WriteLine("-------------------------------------------------");

        string rtspUrl = "rtsp://your_camera_ip:554/stream_path"; // Replace with your RTSP URL
        string username = "admin"; // Replace with your username, or empty if none
        string password = "password"; // Replace with your password, or empty if none
        string outputFilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyVideos), "rtsp_original_capture.mp4");

        Directory.CreateDirectory(Path.GetDirectoryName(outputFilePath));

        Console.WriteLine($"Capturing from: {rtspUrl}");
        Console.WriteLine($"Saving to: {outputFilePath}");
        Console.WriteLine("Press any key to stop recording...");

        var cts = new CancellationTokenSource();
        RTSPRecorder recorder = null;

        try
        {
            recorder = new RTSPRecorder
            {
                Filename = outputFilePath,
                ReencodeAudio = true // Set to false to pass through audio (check compatibility)
            };

            recorder.OnError += (s, e) => Console.WriteLine($"ERROR: {e.Message}");
            recorder.OnStatusMessage += (s, msg) => Console.WriteLine($"STATUS: {msg}");

            // Configure RTSP source settings. The ctor is private — use the async factory.
            var rtspSettings = await RTSPRAWSourceSettings.CreateAsync(
                new Uri(rtspUrl), username, password, audioEnabled: true);
            // Adjust other settings as needed, e.g., restrict transport to TCP only:
            // rtspSettings.AllowedProtocols = RTSPSourceProtocol.TCP;

            if (await recorder.StartAsync(rtspSettings))
            {
                Console.ReadKey(true); // Wait for a key press to stop
            }
            else
            {
                Console.WriteLine("Failed to start recording. Check status messages and RTSP URL/credentials.");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An unexpected error occurred: {ex.Message}");
        }
        finally
        {
            if (recorder != null)
            {
                Console.WriteLine("Stopping recording...");
                await recorder.StopAsync();
                await recorder.DisposeAsync();
                Console.WriteLine("Recording stopped and resources disposed.");
            }

            // Important: Clean up VisioForge SDK resources on application exit
            VisioForgeX.DestroySDK();
        }

        Console.WriteLine("Press any key to exit.");
        Console.ReadKey(true);
    }
}
```

## Key Considerations

- **Audio Compatibility (Passthrough)**: If you choose `ReencodeAudio = false`, ensure the camera's audio codec (e.g., AAC, MP3) is compatible with the MP4 container. Common RTSP audio codecs like G.711 (PCMU/PCMA) are generally not directly supported in MP4 files and will likely result in silent audio or playback errors. Re-encoding to AAC is generally safer for wider compatibility.
- **Network Conditions**: RTSP streaming is sensitive to network stability, so ensure a reliable network connection to the camera.
- **Error Handling**: Robust applications should implement thorough error handling by subscribing to the `OnError` event of the `RTSPRecorder` (or directly from the `MediaBlocksPipeline`).
- **Resource Management**: Always `DisposeAsync` the `RTSPRecorder` instance (and thus the `MediaBlocksPipeline`) when done to free up resources. `VisioForgeX.DestroySDK()` should be called once when your application exits.

## Full GitHub Sample

For a complete, runnable console application demonstrating these concepts, including user input for RTSP details and dynamic duration display, please refer to the official VisioForge samples repository:

- **[RTSP Capture Original Stream Sample on GitHub](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/Console/RTSP%20Capture%20Original)**

This sample provides a more comprehensive example and showcases additional features.

## Best Practices

- Always implement proper error handling
- Monitor network stability for reliable streaming
- Use appropriate audio encoding settings
- Manage system resources effectively
- Implement proper cleanup procedures

## Troubleshooting

Common issues and their solutions when saving RTSP streams:

- Network connectivity problems
- Audio codec compatibility
- Resource management
- Stream initialization errors
- Recording storage considerations

## See also

- [Pre-Event Recording with IP Camera](../pre-event-recording/) — buffer RTSP video and record on motion detection trigger
- [RTSP Video Streaming](../../../general/network-streaming/rtsp/) — RTSP streaming fundamentals and server setup
- [RTSP reconnection and fallback switch](../../../general/network-sources/reconnection-and-fallback/) — keep recordings running through camera drops with automatic `FallbackSwitch`

---

This guide provides a foundational understanding of how to save an RTSP stream's original video while flexibly handling the audio stream using the VisioForge Media Blocks SDK. By leveraging the `RTSPRAWSourceBlock` and direct pipeline connections, you can achieve efficient, high-quality recordings.

---END OF PAGE---


## Record a UDP MPEG-TS Stream Without Re-encoding in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Guides/udp-mpegts-record-without-reencoding/
**Description:** Remux a UDP MPEG-TS stream (H.264/HEVC + AAC) straight to MP4 or MPEG-TS files without transcoding using VisioForge Media Blocks SDK. C# passthrough capture.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, Streaming, Recording, Conversion, UDP, MPEG-TS, MP4, TS, H.264, H.265, AAC, C#, NuGet
**API:** UDPRemuxRecorder, MediaBlocksPipeline, UDPRAWSourceBlock, UDPRAWSourceSettings, MP4SinkBlock, MPEGTSSinkBlock

# How to Record a UDP MPEG-TS Stream to File Without Re-encoding

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Info

For a complete, runnable example see the [UDP RAW Capture Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/UDP%20RAW%20Capture%20Demo).

For UDP streaming fundamentals (sending side, container, multicast), see the [UDP Streaming guide](../../../general/network-streaming/udp/). !!!

## Table of Contents

- [Overview](#overview)
- [Core Features](#core-features)
- [Core Concept](#core-concept)
- [Prerequisites](#prerequisites)
- [Code Sample: UDPRemuxRecorder Class](#code-sample-udpremuxrecorder-class)
- [Explanation of the Code](#explanation-of-the-code)
- [How to Use the UDPRemuxRecorder](#how-to-use-the-udpremuxrecorder)
- [Recording to MPEG-TS Instead of MP4](#recording-to-mpeg-ts-instead-of-mp4)
- [Splitting the Recording into Files](#splitting-the-recording-into-files)
- [Adding a Live Preview](#adding-a-live-preview)
- [Key Considerations](#key-considerations)
- [Troubleshooting](#troubleshooting)
- [Frequently Asked Questions](#frequently-asked-questions)
- [See Also](#see-also)

## Overview

This guide shows how to receive a UDP MPEG-TS stream and write it to a file **without re-encoding** the video or audio. Many encoders, hardware appliances, and broadcast contribution feeds push H.264 or H.265 video together with AAC audio over UDP inside an MPEG transport stream. When you only need to record that feed, decoding and re-encoding it wastes CPU and degrades quality. **Remuxing** — also called stream copy or passthrough capture — moves the already-compressed packets straight into a new container, so the recording is bit-for-bit identical to what arrived on the wire.

The VisioForge Media Blocks SDK makes this a short pipeline: a `UDPRAWSourceBlock` listens on a UDP port, demultiplexes the transport stream, and exposes the encoded elementary streams on its output pads. You connect those pads directly to an MP4 or MPEG-TS sink, and the SDK muxes the data to disk. No decoder, no encoder, minimal CPU.

This is the UDP counterpart of the [Save RTSP Stream Without Re-encoding](../rtsp-save-original-stream/) guide; the recording concept is the same, only the network source differs.

## Core Features

- **Zero re-encoding**: video and audio are copied straight to the container, preserving the original quality.
- **Low CPU usage**: no decode/encode stages, suitable for embedded devices and many simultaneous recorders.
- **H.264 and H.265 video** plus **AAC audio** passthrough into MP4 or MPEG-TS.
- **Unicast and multicast** UDP input via a simple `udp://host:port` URI.
- **File splitting** for continuous, long-running capture with size-bounded segments.
- **Optional live preview** alongside the recording.

## Core Concept

A UDP MPEG-TS feed carries one or more elementary streams (encoded video, encoded audio) packetized into the transport stream. To record it without re-encoding, the pipeline only needs to:

1. Receive the UDP packets and parse the MPEG-TS container.
2. Pick out the encoded video and audio elementary streams.
3. Stamp each buffer with a valid presentation timestamp (PTS) — strict muxers such as `mp4mux` reject buffers without one.
4. Mux the encoded streams into the target container.

`UDPRAWSourceBlock` performs steps 1–3 for you. In `Auto`/`MPEGTS` mode it runs the transport stream through a parser chain (`h264parse`/`h265parse` for video, `aacparse` for audio) that infers and interpolates timestamps, so the buffers leaving the source are already mux-ready. You only wire the source to a sink:

```
graph LR;
    UDPRAWSourceBlock-- "encoded H.264/H.265" -->MP4SinkBlock;
    UDPRAWSourceBlock-- "encoded AAC" -->MP4SinkBlock;
```

## Prerequisites

Add the Media Blocks SDK to your project via NuGet:

```
<PackageReference Include="VisioForge.DotNet.MediaBlocks" Version="2026.5.30" />
```

On Windows you also need the native runtime packages. For recording (muxing) you need the core runtime; the Libav package supplies the muxers:

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64.UPX" Version="2026.4.29" />
```

For macOS, Linux, Android, and iOS runtime packages and platform-specific notes, see the [Deployment Guide](../../../deployment-x/).

## Code Sample: UDPRemuxRecorder Class

The `UDPRemuxRecorder` class below encapsulates the whole pipeline. It receives a UDP MPEG-TS stream and remuxes it to an MP4 file, with optional audio passthrough.

```
using System;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;

namespace UDPCaptureSample
{
    /// <summary>
    /// Records a UDP MPEG-TS stream (H.264/HEVC + AAC) to an MP4 file without re-encoding.
    /// The encoded elementary streams are remuxed straight into the container.
    /// </summary>
    public class UDPRemuxRecorder : IAsyncDisposable
    {
        private MediaBlocksPipeline _pipeline;
        private UDPRAWSourceBlock _source;
        private MP4SinkBlock _sink;

        /// <summary>
        /// Raised when the underlying pipeline reports an error.
        /// </summary>
        public event EventHandler<ErrorsEventArgs> OnError;

        /// <summary>
        /// Builds the recording pipeline.
        /// </summary>
        /// <param name="udpUrl">UDP source URL, e.g. "udp://0.0.0.0:1234" or "udp://239.1.1.1:1234".</param>
        /// <param name="outputFile">Destination MP4 file path.</param>
        /// <param name="recordAudio">Capture the AAC audio track in addition to video.</param>
        public async Task BuildAsync(string udpUrl, string outputFile, bool recordAudio = true)
        {
            // Initialize the SDK once. InitSDKAsync() is idempotent, so a second
            // recorder calling it again is a safe no-op. In a larger app you can
            // instead call it a single time at startup.
            await VisioForgeX.InitSDKAsync();

            _pipeline = new MediaBlocksPipeline();
            _pipeline.OnError += (sender, e) => OnError?.Invoke(this, e);

            // 1. UDP MPEG-TS source. Auto mode detects the container and exposes the
            //    encoded elementary streams (no decoding). AudioEnabled adds the AAC pad.
            var settings = new UDPRAWSourceSettings(new Uri(udpUrl))
            {
                Mode = UDPRAWSourceMode.Auto,
                AudioEnabled = recordAudio
            };

            _source = new UDPRAWSourceBlock(settings);

            // 2. MP4 sink. Each track gets its own dynamic input pad.
            _sink = new MP4SinkBlock(new MP4SinkSettings(outputFile));

            // 3. Connect the encoded video stream directly to the muxer (passthrough).
            var videoInput = (_sink as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Video);
            _pipeline.Connect(_source.VideoOutput, videoInput);

            // 4. Connect the encoded audio stream, if present. AudioOutput is non-null
            //    only when AudioEnabled is true and the stream actually carries audio.
            if (recordAudio && _source.AudioOutput != null)
            {
                var audioInput = (_sink as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Audio);
                _pipeline.Connect(_source.AudioOutput, audioInput);
            }
        }

        /// <summary>
        /// Starts recording. Returns false if the pipeline failed to start.
        /// </summary>
        public Task<bool> StartAsync() => _pipeline?.StartAsync() ?? Task.FromResult(false);

        /// <summary>
        /// Stops recording and finalizes the output file.
        /// </summary>
        public async Task StopAsync()
        {
            if (_pipeline != null)
            {
                await _pipeline.StopAsync();
            }
        }

        /// <inheritdoc/>
        public async ValueTask DisposeAsync()
        {
            if (_pipeline != null)
            {
                await _pipeline.DisposeAsync();
                _pipeline = null;
            }

            _sink = null;
            _source = null;
        }
    }
}
```

## Explanation of the Code

- **`VisioForgeX.InitSDKAsync()`** initializes the SDK once per process. Call `VisioForgeX.DestroySDK()` when your application exits.
- **`UDPRAWSourceSettings`** takes the listening URL. `Mode = UDPRAWSourceMode.Auto` lets the source detect the MPEG-TS container and expose the encoded streams; `UDPRAWSourceMode.MPEGTS` forces the same behavior explicitly. Setting `AudioEnabled = true` tells the source to expose the audio elementary stream on `AudioOutput`.
- **`_source.VideoOutput`** always carries the encoded video (H.264 or H.265) — no decoding happens. **`_source.AudioOutput`** is non-null only when `AudioEnabled` is `true` and the mode is `Auto`/`MPEGTS`; it carries the encoded AAC audio.
- **`MP4SinkBlock` implements `IMediaBlockDynamicInputs`**, so you call `CreateNewInput(MediaBlockPadMediaType.Video)` / `CreateNewInput(MediaBlockPadMediaType.Audio)` to add one input pad per track, then connect the matching source pad.
- **Timestamps**: in `Auto`/`MPEGTS` mode the source inserts `h264parse`/`h265parse`/`aacparse` with timestamp inference and interpolation, so every buffer reaching the MP4 muxer has a valid PTS. This is why the remuxed file has correct timing without any decode step.
- **`StartAsync()`** returns `Task<bool>` — check the result and tear down on `false`.

## How to Use the UDPRemuxRecorder

```
await using var recorder = new UDPRemuxRecorder();
recorder.OnError += (s, e) => Console.WriteLine($"Pipeline error: {e.Message}");

await recorder.BuildAsync("udp://0.0.0.0:1234", "output.mp4", recordAudio: true);

if (await recorder.StartAsync())
{
    Console.WriteLine("Recording... press any key to stop.");
    Console.ReadKey(true);
    await recorder.StopAsync();
    Console.WriteLine("Saved output.mp4");
}
else
{
    Console.WriteLine("Failed to start. Check the UDP URL and port.");
}

VisioForgeX.DestroySDK();
```

The URL is the **local listening endpoint**, not the sender's address:

- `udp://0.0.0.0:1234` — listen on all interfaces, port 1234 (unicast).
- `udp://239.1.1.1:1234` — join the multicast group `239.1.1.1` on port 1234 (the source joins the group automatically).
- `udp://192.168.1.10:1234` — bind to a specific local interface.

## Recording to MPEG-TS Instead of MP4

To keep the recording in an MPEG-TS container (`.ts`) — which tolerates a wider range of codecs and is robust to truncation — swap the sink for an `MPEGTSSinkBlock`. The source and connection logic are identical:

```
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.Types.X.Sinks;

var sink = new MPEGTSSinkBlock(new MPEGTSSinkSettings("output.ts"));

var videoInput = (sink as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Video);
pipeline.Connect(source.VideoOutput, videoInput);

if (source.AudioOutput != null)
{
    var audioInput = (sink as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Audio);
    pipeline.Connect(source.AudioOutput, audioInput);
}
```

## Splitting the Recording into Files

For continuous, long-running capture, split the output into segments with `MP4SplitSinkSettings`. The muxer starts a new file on a key frame after the configured duration, so each segment is independently playable:

```
var splitSettings = new MP4SplitSinkSettings("capture_%05d.mp4")
{
    SplitDuration = TimeSpan.FromMinutes(5),  // new file every 5 minutes
    SplitMaxFiles = 12                        // keep the latest 12 files (0 = unlimited)
};

var sink = new MP4SinkBlock(splitSettings);
```

The `%05d` placeholder in the location pattern is replaced with the zero-padded segment index.

## Adding a Live Preview

You can record and preview simultaneously by teeing the encoded video, sending one branch to the recorder and decoding the other for display. This mirrors the [UDP RAW Capture Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/UDP%20RAW%20Capture%20Demo):

```
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.MediaBlocks.VideoRendering;

var tee = new TeeBlock(2, MediaBlockPadMediaType.Video);

var recorder = new MP4SinkBlock(new MP4SinkSettings("output.mp4"));
var recVideoInput = (recorder as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Video);

// Preview branch: decode for display only.
var decoder = new DecodeBinBlock(renderVideo: true, renderAudio: false, renderSubtitle: false);
var renderer = new VideoRendererBlock(pipeline, VideoView1); // VideoView1 is your UI control

pipeline.Connect(source.VideoOutput, tee.Input);
pipeline.Connect(tee.Outputs[0], recVideoInput);             // recording branch (no decode)
pipeline.Connect(tee.Outputs[1], decoder.Input);             // preview branch
pipeline.Connect(decoder.VideoOutput, renderer.Input);
```

The recording branch stays a pure passthrough; only the preview branch decodes.

## Key Considerations

- **Container/codec compatibility**: MP4 stores H.264, H.265, and AAC well — exactly what a typical UDP MPEG-TS broadcast feed carries. MPEG-TS (`.ts`) is more permissive and more resilient to a recording that ends abruptly (power loss), because it has no trailing index to write.
- **Audio is opt-in**: if you leave `AudioEnabled = false`, `AudioOutput` stays `null` and the recording is video-only. Always guard `if (source.AudioOutput != null)` before connecting audio.
- **Multicast vs unicast**: a multicast group address in the URL (`224.0.0.0`–`239.255.255.255`) is joined automatically; a unicast bind (`0.0.0.0` or a specific local IP) just listens. Make sure your firewall allows inbound UDP on the chosen port.
- **Packet loss**: UDP does not retransmit. On a lossy network you may see brief artifacts in the recording; the muxer keeps running and the file stays valid.
- **Resource cleanup**: dispose the recorder (and therefore the pipeline) when done, and call `VisioForgeX.DestroySDK()` once on application exit.

## Troubleshooting

- **Empty or zero-duration file** — usually means no data arrived. Confirm the sender targets the same port, check the firewall, and verify the URL is the local listening endpoint (`0.0.0.0:port`), not the sender's address.
- **`Could not multiplex` / muxer errors** — indicates buffers without a PTS. Use `Mode = Auto` or `Mode = MPEGTS` so the source inserts the timestamp-inferring parsers; do not bypass them for a container feed.
- **Silent recording** — `AudioEnabled` was left `false`, or the stream carries no audio, so `AudioOutput` was `null` and no audio pad was connected.
- **Multicast stream not received** — the network may not route the group to your host. Confirm the multicast address and that the switch/router forwards it; test with a unicast bind first.
- **Wrong codec assumed in RTP/Raw mode** — `Auto`/`MPEGTS` modes detect the codec from the container. Only `RTP` and `Raw` modes require you to set `VideoCodec` explicitly.

## Frequently Asked Questions

### Can I record a UDP MPEG-TS stream without re-encoding in C#?

Yes. `UDPRAWSourceBlock` exposes the already-encoded H.264/H.265 video and AAC audio on its output pads. Connect them straight to an `MP4SinkBlock` or `MPEGTSSinkBlock` and the streams are remuxed to disk with no decode or encode step.

### What is the difference between remuxing and transcoding?

Remuxing (stream copy/passthrough) copies the compressed packets into a new container unchanged — fast, lossless, low CPU. Transcoding decodes the stream and re-encodes it, which lets you change codec, resolution, or bitrate but costs CPU and reduces quality. To simply save a UDP feed, remuxing is the right choice.

### How do I record a multicast UDP stream?

Use a multicast group address in the URL, e.g. `udp://239.1.1.1:1234`. The source joins the group automatically. Make sure your network forwards the multicast group to the recording host and the firewall allows inbound UDP on the port.

### Which container should I record to — MP4 or MPEG-TS?

Use MP4 when you want a single, widely-compatible file for H.264/H.265 + AAC. Use MPEG-TS (`.ts`) when you need maximum codec flexibility or resilience to an abrupt stop, since TS has no trailing index that must be finalized.

### Does remuxing to MP4 keep the original video quality?

Yes. The encoded video and audio packets are copied byte-for-byte into the MP4 container, so the recording is identical in quality to the incoming stream. Quality only changes if you choose to transcode instead.

## See Also

- [Save RTSP Stream Without Re-encoding](../rtsp-save-original-stream/) — the same passthrough recording concept for RTSP IP cameras
- [UDP Streaming with VisioForge SDKs](../../../general/network-streaming/udp/) — UDP protocol, MPEG-TS container, and the sending side
- [Capture Video to MPEG-TS](../../../general/guides/video-capture-to-mpegts/) — produce MPEG-TS output from a capture pipeline
- [Media Blocks Source Blocks](../../Sources/) — all available sources, including network and device inputs
- [Getting Started with Media Blocks](../../GettingStarted/) — pipeline fundamentals and the block model

---END OF PAGE---


## Modular Multimedia Processing Pipeline API for C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/
**Description:** Build custom multimedia pipelines in C# with VisioForge Media Blocks SDK. Connect source, processing, and output blocks for transcoding, capture, and streaming.
**Tags:** Media Blocks SDK, .NET, DirectShow, Windows, macOS, Linux, Android, iOS, Playback, Streaming

# Media Blocks SDK for C# .NET — Modular Multimedia Pipeline API

[Media Blocks SDK .NET](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction

Media Blocks SDK for .NET is a pipeline-based multimedia framework that lets you build custom video and audio processing workflows in C#. Instead of using a fixed API with predefined behavior, you create a pipeline by connecting typed blocks — sources, encoders, effects, renderers, and sinks — to construct exactly the processing chain your application needs.

The SDK runs on Windows, macOS, Linux, Android, and iOS. It powers use cases that the higher-level Video Capture SDK and Media Player SDK cannot cover: multi-source compositing, custom transcoding pipelines, simultaneous encoding to multiple formats, real-time video effects chains, and integration with hardware like Blackmagic Decklink or industrial cameras.

## When to Use Media Blocks

Media Blocks SDK is the right choice when you need full control over the multimedia pipeline. Use it instead of (or alongside) the other VisioForge SDKs when:

| Scenario | Recommended SDK |
| --- | --- |
| Simple webcam recording to MP4 | [Video Capture SDK](../videocapture/) |
| Play a video file with standard controls | [Media Player SDK](../mediaplayer/) |
| Custom pipeline: source → effects → encode → multiple outputs | **Media Blocks SDK** |
| Live video compositing from multiple sources | **Media Blocks SDK** |
| Transcoding / format conversion with custom processing | **Media Blocks SDK** |
| RTSP recording with post-processing (overlay, resize, re-encode) | **Media Blocks SDK** |
| Cross-platform Avalonia or MAUI media app | **Media Blocks SDK** |
| Integration with Decklink, GenICam, or NVIDIA hardware | **Media Blocks SDK** |

## Common Use Cases

### Video File Transcoding and Format Conversion

Convert video files between formats (e.g., AVI to MP4, MKV to WebM) with full control over codecs, resolution, bitrate, and processing. Chain resize, deinterlace, or color correction blocks between the source and encoder.

### Custom Camera Capture with Processing Pipeline

Build camera capture workflows that go beyond simple recording. Insert real-time effects, text overlays, or computer vision blocks between the camera source and the file sink. Output to multiple destinations simultaneously — preview window, file, and network stream.

See: [Camera Viewer Application Tutorial](GettingStarted/camera/)

### Live Video Compositing and Mixing

Combine multiple video sources into a single output with the [Live Video Compositor](LiveVideoCompositor/). Position, scale, and layer video feeds for multi-camera production, picture-in-picture, or surveillance grid layouts.

### RTSP Stream Recording with Post-Processing

Capture RTSP streams from IP cameras and apply processing before saving — resize to lower resolution, add timestamp overlays, re-encode with different quality settings, or split into segments.

See: [RTSP Stream Save Guide](Guides/rtsp-save-original-stream/) | [ONVIF Capture with Post-Processing](Guides/onvif-capture-with-postprocessing/)

### Text and Image Overlay / Watermarking

Add text, images, or SVG overlays to live video or recorded files using the [Overlay Manager Block](VideoProcessing/OverlayManagerBlock/). Useful for watermarking, timestamp insertion, branding, and on-screen display.

### Barcode and QR Code Reading from Video

Process live camera feeds or video files to detect and decode barcodes and QR codes in real-time.

See: [Barcode & QR Code Reader Guide](Guides/barcode-qr-reader-guide/)

### Pre-Event Recording

Implement circular buffer recording that captures video continuously and writes event clips (including footage from before the trigger) to disk.

See: [Pre-Event Recording Guide](Guides/pre-event-recording/)

## Platform Support

| Platform | UI Frameworks | Notes |
| --- | --- | --- |
| Windows x64 | WinForms, WPF, MAUI, Avalonia, Console | Full feature set including DirectShow bridges |
| macOS | MAUI, Avalonia, Console | AVFoundation camera access |
| Linux x64 | Avalonia, Console | V4L2 camera, GStreamer-based processing |
| Android | MAUI | Via MAUI integration |
| iOS | MAUI | Via MAUI integration |

## Core SDK Components

### Sources

[Source Blocks](Sources/) ingest media from cameras, files, network streams, virtual generators, and capture hardware.

### Video Processing

- [Video Encoders](VideoEncoders/) — H.264, H.265/HEVC, VP8, VP9, AV1 with GPU acceleration (NVENC, AMF, Quick Sync)
- [Video Decoders](VideoDecoders/) — Hardware and software decoding for all major codecs
- [Video Processing](VideoProcessing/) — Resize, crop, rotate, color correction, deinterlace, effects
- [Video Rendering](VideoRendering/) — Display video in WinForms, WPF, MAUI, and Avalonia controls
- [Live Video Compositor](LiveVideoCompositor/) — Multi-source mixing and compositing

### AI and Computer Vision

On-device AI blocks (ONNX / Whisper) that drop straight into a Media Blocks pipeline — no cloud, no per-call billing. See the [AI overview](../general/ai/) for the full list and integration paths.

- [Object Detection](../general/ai/object-detection/) — detect objects per frame with YOLOv8/YOLOX/RT-DETR
- [Object Analytics](../general/ai/object-analytics/) — tracking, tripwires, and polygon-zone counting
- [Open Vocabulary Detection](../general/ai/open-vocabulary-detection/) — detect objects by free-text prompt (OWLv2 / Grounding DINO)
- [VLM Captioning](../general/ai/vlm-captioning/) — caption, describe, ground, and OCR frames with Florence-2
- [Semantic Video Search](../general/ai/semantic-video-search/) — index frames as CLIP embeddings and search by text
- [OCR](../general/ai/ocr/) — recognize text regions with PaddleOCR models
- [Face Recognition](../general/ai/face-recognition/) — detect and identify faces against an enrolled gallery
- [License Plate Recognition](../general/ai/license-plate-recognition/) — detect and read license plates (ANPR)
- [PII Redaction](../general/ai/pii-redaction/) — blur or pixelate faces, license plates, and on-screen text
- [Background Removal](../general/ai/background-removal/) — replace, blur, or make the background transparent
- [Auto Reframe](../general/ai/auto-reframe/) — reframe landscape footage into subject-following vertical 9:16 video
- [Speech-to-Text](../general/ai/speech-to-text/) — transcribe audio and generate live subtitles with Whisper
- [Generic ONNX Inference](../general/ai/onnx-inference/) — run a custom ONNX model and receive raw tensors

### Audio Processing

- [Audio Encoders](AudioEncoders/) — AAC, MP3, Vorbis, Opus, FLAC encoding
- [Audio Processing](AudioProcessing/) — Filters, effects, sample rate conversion, channel mixing
- [Audio Rendering](AudioRendering/) — Playback to system audio devices
- [Audio Visualizers](AudioVisualizers/) — Waveform and spectrum visualization blocks

### Output and Connectivity

- [Sinks](Sinks/) — Write to MP4, WebM, AVI, MKV, TS files and network streams
- [Output Blocks](Outputs/) — High-level output configurations
- [Bridges](Bridge/) — Connect pipeline segments and synchronize blocks
- [Demuxers](Demuxers/) and [Parsers](Parsers/) — Stream demultiplexing and parsing

### Hardware and Platform-Specific

- [NVIDIA](Nvidia/) — NVENC/NVDEC hardware acceleration blocks
- [Blackmagic Decklink](Decklink/) — Professional capture and playback hardware
- [OpenCV](OpenCV/) — Computer vision integration
- [OpenGL](OpenGL/) — GPU-based video processing
- [AWS](AWS/) — Cloud integration blocks
- [RTSP Server](RTSPServer/) — Serve video as an RTSP stream
- [USB (UVC) cameras on Android](../general/guides/android-usb-camera/) — Capture from a webcam attached over OTG, which Camera2 cannot see

## Getting Started

Ready to build your first pipeline? The Developer Quick Start Guide covers installation, core concepts, pipeline architecture, and step-by-step code examples:

[Developer Quick Start Guide](GettingStarted/)

Additional getting started tutorials:

- [Complete Pipeline Implementation](GettingStarted/pipeline/)
- [Media Player Development](GettingStarted/player/)
- [Camera Viewer Application](GettingStarted/camera/)
- [Device Enumeration](GettingStarted/device-enum/)

## Guides

- [Save RTSP Stream to File](Guides/rtsp-save-original-stream/)
- [RTSP Stream Viewer and IP Camera Player](Guides/rtsp-player-csharp/)
- [ONVIF Capture with Post-Processing](Guides/onvif-capture-with-postprocessing/)
- [Barcode & QR Code Reader](Guides/barcode-qr-reader-guide/)
- [Pre-Event Recording](Guides/pre-event-recording/)
- [Audio Metadata Tags](Guides/audio-metadata-tags/)
- [Custom Video Effects and OpenGL Shaders](Guides/custom-video-effects-csharp/)

## Developer Resources

- [Code Samples on GitHub](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK)
- [Deployment Guide](../deployment-x/)
- [API Reference](https://api.visioforge.org/dotnet/api/index.html)
- [Changelog](../changelog/)
- [End User License Agreement](../../eula/)
- [Licensing Information](https://www.visioforge.com/licensing)

---END OF PAGE---


## Live Video Compositor for Real-Time Mixing in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/LiveVideoCompositor/
**Description:** Mix multiple live video and audio sources in real-time using VisioForge Media Blocks SDK. Dynamic source switching for streaming and recording in C#.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming
**API:** LiveVideoCompositor, LVCVideoInput, MediaBlock, LVCAudioInput, LVCAudioOutput

# Live Video Compositor

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Live Video Compositor is a part of the [VisioForge Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) that allows you to add and remove sources and outputs in real time to a pipeline.

This allows you to create applications that simultaneously handle multiple video and audio sources.

For example, the LVC allows you to start streaming to YouTube at just the right moment while simultaneously recording video to disk. Using the LVC, you can create an application similar to OBS Studio.

Each source and output has its unique identifier that can be used to add and remove sources and outputs in real time.

Each source and output has its own independent pipeline that can be started and stopped.

## Features

- Supports multiple video and audio sources
- Supports multiple video and audio outputs
- Setting the position and size of video sources
- Setting the transparency of video sources
- Setting the volume of audio sources

## LiveVideoCompositor class

The `LiveVideoCompositor` is the main class that allows the addition and removal of live sources and outputs to the pipeline. When creating it, it is necessary to specify the resolution and frame rate to use. All sources with a different frame rate will be automatically converted to the frame rate specified when creating the LVC.

`LiveVideoCompositorSettings` allows you to set the video and audio parameters. Key properties include:

- `MixerType`: Specifies the video mixer type (e.g., `LVCMixerType.OpenGL`, `LVCMixerType.D3D11` (Windows only), or `LVCMixerType.CPU`).
- `AudioEnabled`: A boolean indicating whether the audio stream is enabled.
- `VideoWidth`, `VideoHeight`, `VideoFrameRate`: Define the output video resolution and frame rate.
- `AudioFormat`, `AudioSampleRate`, `AudioChannels`: Define the output audio parameters.
- `VideoView`: An optional `IVideoView` for rendering video output directly.
- `AudioOutput`: An optional `AudioRendererBlock` for rendering audio output directly.

It is also necessary to set the maximum number of sources and outputs when designing your application, though this is not a direct parameter of `LiveVideoCompositorSettings`.

### Sample code

1. Create a new instance of the `LiveVideoCompositor` class.

```
var settings = new LiveVideoCompositorSettings(1920, 1080, VideoFrameRate.FPS_25);
// Optionally, configure other settings like MixerType, AudioEnabled, etc.
// settings.MixerType = LVCMixerType.OpenGL;
// settings.AudioEnabled = true;
var compositor = new LiveVideoCompositor(settings);
```

1. Add video and audio sources and outputs (see below)
2. Start the pipeline.

```
await compositor.StartAsync();
```

## LVC Video Input

The `LVCVideoInput` class is used to add video sources to the LVC pipeline. The class allows you to set the video parameters and the rectangle of the video source.

You can use any block that has a video output pad. For example, you can use `VirtualVideoSourceBlock` to create a virtual video source or `SystemVideoSourceBlock` to capture video from the webcam.

Key properties for `LVCVideoInput` include:

- `Rectangle`: Defines the position and size of the video source within the compositor's output.
- `ZOrder`: Determines the stacking order of overlapping video sources.
- `ResizePolicy`: Specifies how the video source should be resized if its aspect ratio differs from the target rectangle (`LVCResizePolicy.Stretch`, `LVCResizePolicy.Letterbox`, `LVCResizePolicy.LetterboxToFill`).
- `VideoView`: An optional `IVideoView` to preview this specific input source.

### Usage

When creating an `LVCVideoInput` object, you must specify the `MediaBlock` to be used as the video data source, along with `VideoFrameInfoX` describing the video, a `Rect` for its placement, and whether it should `autostart`.

### Sample code

#### Virtual video source

The sample code below shows how to create an `LVCVideoInput` object with a `VirtualVideoSourceBlock` as the video source.

```
var rect = new Rect(0, 0, 640, 480);

var name = "Video source [Virtual]";
var settings = new VirtualVideoSourceSettings();
var info = new VideoFrameInfoX(settings.Width, settings.Height, settings.FrameRate);
var src = new LVCVideoInput(name, _compositor, new VirtualVideoSourceBlock(settings), info, rect, true);
// Optionally, set ZOrder or ResizePolicy
// src.ZOrder = 1;
// src.ResizePolicy = LVCResizePolicy.Letterbox;
if (await _compositor.Input_AddAsync(src))
{
    // added successfully
}
else
{
    src.Dispose();
}
```

#### Screen source

For Desktop platforms, we can capture the screen. The sample code below shows how to create an `LVCVideoInput` object with a `ScreenSourceBlock` as the video source.

```
var settings = new ScreenCaptureDX9SourceSettings();
settings.CaptureCursor = true;
settings.Monitor = 0;
settings.FrameRate = new VideoFrameRate(30);
settings.Rectangle = new Rect(0, 0, 1920, 1080); // (left, top, right, bottom) — full 1920x1080

var rect = new Rect(0, 0, 640, 480);
var name = $"Screen source";
var info = new VideoFrameInfoX(settings.Rectangle.Width, settings.Rectangle.Height, settings.FrameRate);
var src = new LVCVideoInput(name, _compositor, new ScreenSourceBlock(settings), info, rect, true);
// Optionally, set ZOrder or ResizePolicy
// src.ZOrder = 0;
// src.ResizePolicy = LVCResizePolicy.Stretch;
if (await _compositor.Input_AddAsync(src))
{
    // added successfully
}
else
{
    src.Dispose();
}
```

#### System video source (webcam)

The sample code below shows how to create an `LVCVideoInput` object with a `SystemVideoSourceBlock` as the video source.

We use the `DeviceEnumerator` class to get the video source devices. The first video device will be used as the video source. The first video format of the device will be used as the video format.

```
VideoCaptureDeviceSourceSettings settings = null;

var device = (await DeviceEnumerator.Shared.VideoSourcesAsync())[0];
if (device != null)
{
    var formatItem = device.VideoFormats[0];
    if (formatItem != null)
    {
        settings = new VideoCaptureDeviceSourceSettings(device)
        {
            Format = formatItem.ToFormat()
        };

        settings.Format.FrameRate = dlg.FrameRate;
    }
}

if (settings == null)
{
    MessageBox.Show(this, "Unable to configure video capture device.");
    return;
}

var name = $"Camera source [{device.Name}]";
var rect = new Rect(0, 0, 1280, 720);
var videoInfo = new VideoFrameInfoX(settings.Format.Width, settings.Format.Height, settings.Format.FrameRate);
var src = new LVCVideoInput(name, _compositor, new SystemVideoSourceBlock(settings), videoInfo, rect, true);
// Optionally, set ZOrder or ResizePolicy
// src.ZOrder = 2;
// src.ResizePolicy = LVCResizePolicy.LetterboxToFill;

if (await _compositor.Input_AddAsync(src))
{
    // added successfully
}
else
{
    src.Dispose();
}
```

## LVC Audio Input

The `LVCAudioInput` class is used to add audio sources to the LVC pipeline. The class allows you to set the audio parameters and the volume of the audio source.

You can use any block that has an audio output pad. For example, you can use the `VirtualAudioSourceBlock` to create a virtual audio source or `SystemAudioSourceBlock` to capture audio from the microphone.

### Usage

When creating an `LVCAudioInput` object, you must specify the `MediaBlock` to be used as the audio data source, along with `AudioInfoX` (which requires format, channels, and sample rate) and whether it should `autostart`.

### Sample code

#### Virtual audio source

The sample code below shows how to create an `LVCAudioInput` object with a `VirtualAudioSourceBlock` as the audio source.

```
var name = "Audio source [Virtual]";
var settings = new VirtualAudioSourceSettings();
var info = new AudioInfoX(settings.Format, settings.SampleRate, settings.Channels);
var src = new LVCAudioInput(name, _compositor, new VirtualAudioSourceBlock(settings), info, true);
if (await _compositor.Input_AddAsync(src))
{
    // added successfully
}
else
{
    src.Dispose();
}
```

#### System audio source (DirectSound in Windows)

The sample code below shows how to create an `LVCAudioInput` object with a `SystemAudioSourceBlock` as the audio source.

We use the `DeviceEnumerator` class to get the audio devices. The first audio device is used as the audio source. The first audio format of the device is used as the audio format.

```
DSAudioCaptureDeviceSourceSettings settings = null;
AudioCaptureDeviceFormat deviceFormat = null;

var device = (await DeviceEnumerator.Shared.AudioSourcesAsync(AudioCaptureDeviceAPI.DirectSound))[0];
if (device != null)
{
    var formatItem = device.Formats[0];
    if (formatItem != null)
    {
        deviceFormat = formatItem.ToFormat();
        settings = new DSAudioCaptureDeviceSourceSettings(device, deviceFormat);
    }
}

if (settings == null)
{
    MessageBox.Show(this, "Unable to configure audio capture device.");
    return;
}

var name = $"Audio source [{device.Name}]";
var info = new AudioInfoX(deviceFormat.Format, deviceFormat.SampleRate, deviceFormat.Channels);
var src = new LVCAudioInput(name, _compositor, new SystemAudioSourceBlock(settings), info, true);
if (await _compositor.Input_AddAsync(src))
{
    // added successfully
}
else
{
    src.Dispose();
}
```

## LVC Video Output

The `LVCVideoOutput` class is used to add video outputs to the LVC pipeline. You can start and stop the output pipeline independently from the main pipeline.

### Usage

When creating an `LVCVideoOutput` object, you must specify the `MediaBlock` to be used as the video data output, its `name`, a reference to the `LiveVideoCompositor`, and whether it should `autostart` with the main pipeline. An optional processing `MediaBlock` can also be provided. Usually, this element is used to save the video as a file or stream it (without audio).

For video+audio outputs, use the `LVCVideoAudioOutput` class.

You can use the SuperMediaBlock to make a custom block pipeline for video output. For example, you can add a video encoder, a muxer, and a file writer to save the video to a file.

## LVC Audio Output

The `LVCAudioOutput` class is used to add audio outputs to the LVC pipeline. You can start and stop the output pipeline independently from the main pipeline.

### Usage

When creating an `LVCAudioOutput` object, you must specify the `MediaBlock` to be used as the audio data output, its `name`, a reference to the `LiveVideoCompositor`, and whether it should `autostart`.

### Sample code

#### Add an audio renderer

Add an audio renderer to the LVC pipeline. You need to create an `AudioRendererBlock` object and then create an `LVCAudioOutput` object. Finally, add the output to the compositor.

The first device is used as an audio output.

```
var audioRenderer = new AudioRendererBlock((await DeviceEnumerator.Shared.AudioOutputsAsync())[0]);
var audioRendererOutput = new LVCAudioOutput("Audio renderer", _compositor, audioRenderer, true);
await _compositor.Output_AddAsync(audioRendererOutput, true);
```

#### Add an MP3 output

Add an MP3 output to the LVC pipeline. You need to create an `MP3OutputBlock` object and then create an `LVCAudioOutput` object. Finally, add the output to the compositor.

```
var mp3Output = new MP3OutputBlock(outputFile, new MP3EncoderSettings());
var output = new LVCAudioOutput(outputFile, _compositor, mp3Output, false);

if (await _compositor.Output_AddAsync(output))
{
    // added successfully
}
else
{
    output.Dispose();
}
```

## LVC Video/Audio Output

The `LVCVideoAudioOutput` class is used to add video+audio outputs to the LVC pipeline. You can start and stop the output pipeline independently from the main pipeline.

### Usage

When creating an `LVCVideoAudioOutput` object, you must specify the `MediaBlock` to be used as the video+audio data output, its `name`, a reference to the `LiveVideoCompositor`, and whether it should `autostart`. Optional processing `MediaBlock`s for video and audio can also be provided.

### Sample code

#### Add an MP4 output

```
var mp4Output = new MP4OutputBlock(new MP4SinkSettings("output.mp4"), new OpenH264EncoderSettings(), new MFAACEncoderSettings());

var output = new LVCVideoAudioOutput(outputFile, _compositor, mp4Output, false);

if (await _compositor.Output_AddAsync(output))
{
    // added successfully
}
else
{
    output.Dispose();
}
```

#### Add a WebM output

```
var webmOutput = new WebMOutputBlock(new WebMSinkSettings("output.webm"), new VP8EncoderSettings(), new VorbisEncoderSettings());
var output = new LVCVideoAudioOutput(outputFile, _compositor, webmOutput, false);

if (await _compositor.Output_AddAsync(output))
{
   // added successfully
}
else
{
    output.Dispose();
}
```

## LVC Video View Output

The `LVCVideoViewOutput` class is used to add video view to the LVC pipeline. You can use it to display the video on the screen.

### Usage

When creating an `LVCVideoViewOutput` object, you must specify the `IVideoView` control to be used, its `name`, a reference to the `LiveVideoCompositor`, and whether it should `autostart`. An optional processing `MediaBlock` can also be provided.

### Sample code

```
var name = "[VideoView] Preview";
var videoRendererOutput = new LVCVideoViewOutput(name, _compositor, VideoView1, true);
await _compositor.Output_AddAsync(videoRendererOutput);
```

VideoView1 is a `VideoView` object that is used to display the video. Each platform / UI framework has its own `VideoView` implementation.

You can add several `LVCVideoViewOutput` objects to the LVC pipeline to display the video on different displays.

## Monitoring render frame rate

When composing many inputs at once, the compositor can fall behind the configured `VideoFrameRate` if the CPU or GPU runs out of headroom. Subscribe to `OnRenderStatistics` to read the actual output frame rate and detect drops early:

```
using System.Diagnostics;

compositor.OnRenderStatistics += (sender, e) =>
{
    // Fires roughly twice a second on a threadpool thread.
    Debug.WriteLine($"FPS: {e.ActualFps:F1} / configured {e.ConfiguredFps:F1}, total frames: {e.FramesDelivered}");
};
```

`RenderStatisticsEventArgs` exposes:

- `ActualFps` – measured output frame rate over the last sampling window.
- `ConfiguredFps` – the frame rate requested via `LiveVideoCompositorSettings.VideoFrameRate`.
- `FramesDelivered` – monotonic count of frames produced since the compositor started.
- `LastFrameTimestamp` – PTS of the most recent frame (`TimeSpan.Zero` if none yet).

If `ActualFps` sits noticeably below `ConfiguredFps` for several consecutive ticks, the pipeline is not keeping up — typical causes are too many inputs, oversized source resolutions, a software-only mixer on a heavily loaded CPU, or a slow downstream encoder. Switching `LVCMixerType` to `OpenGL` or `D3D11`, reducing inputs, or dropping source resolution usually restores the configured rate.

Marshal to the UI thread before updating controls, since the event fires on a threadpool thread.

## V1 vs V2

The SDK ships two implementations under different namespaces:

- `VisioForge.Core.LiveVideoCompositorV2` – current, recommended.
- `VisioForge.Core.LiveVideoCompositor` – original implementation, **deprecated** and scheduled for removal in a future release.

Both namespaces expose an identically named `LiveVideoCompositor` class plus the same `LVC*` helpers. Migrating a file is usually a single-line `using` swap:

```
// Before
using VisioForge.Core.LiveVideoCompositor;

// After
using VisioForge.Core.LiveVideoCompositorV2;
```

After switching the `using`, `new LiveVideoCompositor(...)` resolves to the V2 class and the obsolete warnings disappear. The `OnRenderStatistics` event is only available on V2.

### Video effects do not migrate one-to-one

Two differences survive the `using` swap, and both concern `Video_Effects_*`:

- **Scope.** V1 keeps one effects block per channel, sized by `LiveVideoCompositorSettings.VideoChannelCount`, and the `channel` argument selects among them. V2 has no `VideoChannelCount` and a single effects block on the composed output, after the mixer — so its `channel` argument never had anything to select. The overloads that take one are obsolete and forward to the channel-free methods: use `Video_Effects_AddOrUpdateAsync(effect)`, `Video_Effects_Get(name)`, `Video_Effects_RemoveAsync(...)` and `Video_Effects_Clear()`.
- **Effect type.** V1 takes `IBaseVideoEffect`, V2 takes `BaseVideoEffect`. This one is a compile error rather than a silent difference.

To process a single input instead of the whole composition — what V1's per-channel effects did — add a `VideoEffectsBlock` to that input's `ProcessingVideoBlocks`. Those blocks run between the source and the mixer:

```
var input = new LVCVideoInput("camera", compositor, sourceBlock, videoInfo, rect, autostart: true);

var effects = new VideoEffectsBlock();
await effects.AddOrUpdateAsync(new GrayscaleVideoEffect("gray"));
input.ProcessingVideoBlocks.Add(effects);

await compositor.Input_AddAsync(input);
```

---

[Sample application on GitHub](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Live%20Video%20Compositor%20Demo)

---END OF PAGE---


## NVIDIA CUDA GPU Video Processing Blocks in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Nvidia/
**Description:** Accelerate video conversion, resizing, and data transfer with Nvidia CUDA GPU blocks in VisioForge Media Blocks SDK pipelines for .NET.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS
**API:** NVDataUploadBlock, NVDataDownloadBlock, NVVideoResizeBlock, NVVideoConverterBlock, NVDSDewarpBlock

# Nvidia Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Nvidia blocks leverage Nvidia GPU capabilities for accelerated media processing tasks such as data transfer, video conversion, and resizing.

## NVDataDownloadBlock

Nvidia data download block. Downloads data from Nvidia GPU to system memory.

#### Block info

Name: NVDataDownloadBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Video (GPU memory) | 1 |
| Output video | Video (system memory) | 1 |

#### The sample pipeline

```
graph LR;
    NVCUDAConverterBlock-->NVDataDownloadBlock-->VideoRendererBlock;
```

#### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create a source that outputs to GPU memory (e.g., a decoder or another Nvidia block)
// For example, NVDataUploadBlock or an NV-accelerated decoder
var upstreamNvidiaBlock = new NVDataUploadBlock(); // Conceptual: assume this block is properly configured

// create Nvidia data download block
var nvDataDownload = new NVDataDownloadBlock();

// create video renderer block
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1 is your display control

// connect blocks
// pipeline.Connect(upstreamNvidiaBlock.Output, nvDataDownload.Input); // Connect GPU source to download block
// pipeline.Connect(nvDataDownload.Output, videoRenderer.Input); // Connect download block (system memory) to renderer

// start pipeline
// await pipeline.StartAsync();
```

#### Remarks

This block is used to transfer video data from the Nvidia GPU's memory to the main system memory. This is typically needed when a GPU-processed video stream needs to be accessed by a component that operates on system memory, like a CPU-based encoder or a standard video renderer. Ensure that the correct Nvidia drivers and CUDA toolkit are installed for this block to function. Use `NVDataDownloadBlock.IsAvailable()` to check if the block can be used.

#### Platforms

Windows, Linux (Requires Nvidia GPU and appropriate drivers/SDK).

## NVDataUploadBlock

Nvidia data upload block. Uploads data to Nvidia GPU from system memory.

#### Block info

Name: NVDataUploadBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Video (system memory) | 1 |
| Output video | Video (GPU memory) | 1 |

#### The sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->NVDataUploadBlock-->NVH264EncoderBlock;
```

#### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create a video source (e.g., SystemVideoSourceBlock or UniversalSourceBlock).
// UniversalSourceBlock requires UniversalSourceSettings via the async factory:
var sourceSettings = await UniversalSourceSettings.CreateAsync("input.mp4");
var videoSource = new UniversalSourceBlock(sourceSettings);

// create Nvidia data upload block
var nvDataUpload = new NVDataUploadBlock();

// create an Nvidia accelerated encoder (e.g., NVH264EncoderBlock)
// var nvEncoder = new NVH264EncoderBlock(new NVH264EncoderSettings()); // Conceptual

// connect blocks
// pipeline.Connect(videoSource.VideoOutput, nvDataUpload.Input); // Connect system memory source to upload block
// pipeline.Connect(nvDataUpload.Output, nvEncoder.Input); // Connect upload block (GPU memory) to NV encoder

// start pipeline
// await pipeline.StartAsync();
```

#### Remarks

This block is used to transfer video data from main system memory to the Nvidia GPU's memory. This is typically a prerequisite for using Nvidia-accelerated processing blocks like encoders, decoders, or filters that operate on GPU memory. Ensure that the correct Nvidia drivers and CUDA toolkit are installed for this block to function. Use `NVDataUploadBlock.IsAvailable()` to check if the block can be used.

#### Platforms

Windows, Linux (Requires Nvidia GPU and appropriate drivers/SDK).

## NVVideoConverterBlock

Nvidia video converter block. Performs color space conversions and other video format conversions using the Nvidia GPU.

#### Block info

Name: NVVideoConverterBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Video (GPU memory) | 1 |
| Output video | Video (GPU memory, possibly different format) | 1 |

#### The sample pipeline

```
graph LR;
    NVDataUploadBlock-->NVVideoConverterBlock-->NVDataDownloadBlock;
```

#### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// Assume video data is already in GPU memory via NVDataUploadBlock or an NV-decoder
// var nvUploadedSource = new NVDataUploadBlock(); // Conceptual
// pipeline.Connect(systemMemorySource.Output, nvUploadedSource.Input);

// create Nvidia video converter block
var nvVideoConverter = new NVVideoConverterBlock();
// Specific conversion settings might be applied here if the block has properties for them.

// Assume we want to download the converted video back to system memory
// var nvDataDownload = new NVDataDownloadBlock(); // Conceptual

// connect blocks
// pipeline.Connect(nvUploadedSource.Output, nvVideoConverter.Input);
// pipeline.Connect(nvVideoConverter.Output, nvDataDownload.Input);
// pipeline.Connect(nvDataDownload.Output, videoRenderer.Input); // Or to another system memory component

// start pipeline
// await pipeline.StartAsync();
```

#### Remarks

The `NVVideoConverterBlock` is used for efficient video format conversions (e.g., color space, pixel format) leveraging the Nvidia GPU. This is often faster than CPU-based conversions, especially for high-resolution video. It typically operates on video data already present in GPU memory. Ensure that the correct Nvidia drivers and CUDA toolkit are installed. Use `NVVideoConverterBlock.IsAvailable()` to check if the block can be used.

#### Platforms

Windows, Linux (Requires Nvidia GPU and appropriate drivers/SDK).

## NVVideoResizeBlock

Nvidia video resize block. Resizes video frames using the Nvidia GPU.

#### Block info

Name: NVVideoResizeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Video (GPU memory) | 1 |
| Output video | Video (GPU memory, resized) | 1 |

#### Settings

The `NVVideoResizeBlock` is configured using a `VisioForge.Core.Types.Size` object passed to its constructor.

- `Resolution` (`VisioForge.Core.Types.Size`): Specifies the target output resolution (Width, Height) for the video.

#### The sample pipeline

```
graph LR;
    NVDataUploadBlock-->NVVideoResizeBlock-->NVH264EncoderBlock;
```

#### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// Target resolution for resizing
var targetResolution = new VisioForge.Core.Types.Size(1280, 720);

// Assume video data is already in GPU memory via NVDataUploadBlock or an NV-decoder
// var nvUploadedSource = new NVDataUploadBlock(); // Conceptual
// pipeline.Connect(systemMemorySource.Output, nvUploadedSource.Input);

// create Nvidia video resize block
var nvVideoResize = new NVVideoResizeBlock(targetResolution);

// Assume the resized video will be encoded by an NV-encoder
// var nvEncoder = new NVH264EncoderBlock(new NVH264EncoderSettings()); // Conceptual

// connect blocks
// pipeline.Connect(nvUploadedSource.Output, nvVideoResize.Input);
// pipeline.Connect(nvVideoResize.Output, nvEncoder.Input);

// start pipeline
// await pipeline.StartAsync();
```

#### Remarks

The `NVVideoResizeBlock` performs video scaling operations efficiently using the Nvidia GPU. This is useful for adapting video streams to different display resolutions or encoding requirements. It typically operates on video data already present in GPU memory. Ensure that the correct Nvidia drivers and CUDA toolkit are installed. Use `NVVideoResizeBlock.IsAvailable()` to check if the block can be used.

#### Platforms

Windows, Linux (Requires Nvidia GPU and appropriate drivers/SDK).

## NVDSDewarpBlock

Nvidia DeepStream dewarp block. Performs dewarping transformations for fisheye and wide-angle camera distortion correction using GPU acceleration.

#### Block info

Name: NVDSDewarpBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Video (GPU memory) | 1 |
| Output video | Video (GPU memory) | 1 |

#### The sample pipeline

```
graph LR;
    NVDataUploadBlock-->NVDSDewarpBlock-->NVDataDownloadBlock;
```

#### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// Upload video to GPU memory
var nvUpload = new NVDataUploadBlock();

// Configure dewarp settings for fisheye correction. Camera calibration and projection
// parameters live in the DeepStream-format ConfigFile; the .NET settings object only
// holds the top-level knobs (GPU id, memory type, source id, config-file path).
var dewarpSettings = new NVDSDewarpSettings
{
    Enabled = true,
    NumSourcePlanes = 1,
    ConfigFile = "config_dewarper.txt",
    GpuId = 0,
    SourceId = 0
};

// Create dewarp block
var nvDewarp = new NVDSDewarpBlock(dewarpSettings);

// Download from GPU if needed
var nvDownload = new NVDataDownloadBlock();

// Connect blocks
pipeline.Connect(nvUpload.Output, nvDewarp.Input);
pipeline.Connect(nvDewarp.Output, nvDownload.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Remarks

The `NVDSDewarpBlock` is part of Nvidia's DeepStream SDK and provides GPU-accelerated dewarping for correcting distortion from fisheye and wide-angle cameras. This is essential for surveillance, automotive, and 360-degree video applications.

Requires Nvidia DeepStream SDK and compatible GPU. Use `NVDSDewarpBlock.IsAvailable()` to check availability.

#### Platforms

Linux (Requires Nvidia DeepStream SDK, Jetson or compatible GPU).

---END OF PAGE---


## OpenCV Computer Vision Blocks for Video Pipeline in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/OpenCV/
**Description:** Add object detection, tracking, and image processing to video pipelines with OpenCV blocks in VisioForge Media Blocks SDK. Computer vision on Windows and macOS.
**Tags:** Media Blocks SDK, .NET, Windows, macOS
**API:** SystemVideoSourceBlock, VideoRendererBlock, MediaBlocksPipeline, CVHandDetectBlock, CVDewarpBlock

# OpenCV Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

OpenCV (Open Source Computer Vision Library) blocks provide powerful video processing capabilities within the VisioForge Media Blocks SDK .Net. These blocks enable a wide range of computer vision tasks, from basic image manipulation to complex object detection and tracking.

To use OpenCV blocks, add the redistributable NuGet package for your platform: `VisioForge.CrossPlatform.OpenCV.Windows.x64`, `VisioForge.CrossPlatform.OpenCV.Windows.x86` or `VisioForge.CrossPlatform.OpenCV.macOS`. These are the platforms the OpenCV GStreamer plugin currently ships for; on any other platform each block's `IsAvailable()` returns `false`.

Most OpenCV blocks typically require a `videoconvert` element before them to ensure the input video stream is in a compatible format. The SDK handles this internally when you initialize the block.

## CV Dewarp Block

The CV Dewarp block applies dewarping effects to a video stream, which can correct distortions from wide-angle lenses, for example.

### Block info

Name: `CVDewarpBlock` (GStreamer element: `dewarp`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVDewarpBlock` is configured using `CVDewarpSettings`. Key properties:

- `DisplayMode` (`CVDewarpDisplayMode` enum): Specifies the display mode for dewarping (e.g., `SinglePanorama`, `DoublePanorama`). Default is `CVDewarpDisplayMode.SinglePanorama`.
- `InnerRadius` (double): Inner radius for dewarping.
- `InterpolationMethod` (`CVDewarpInterpolationMode` enum): Interpolation method used (e.g., `Bilinear`, `Bicubic`). Default is `CVDewarpInterpolationMode.Bilinear`.
- `OuterRadius` (double): Outer radius for dewarping.
- `XCenter` (double): X-coordinate of the center for dewarping.
- `XRemapCorrection` (double): X-coordinate remap correction factor.
- `YCenter` (double): Y-coordinate of the center for dewarping.
- `YRemapCorrection` (double): Y-coordinate remap correction factor.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVDewarpBlock;
    CVDewarpBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

// Create Dewarp settings
var dewarpSettings = new CVDewarpSettings
{
    DisplayMode = CVDewarpDisplayMode.SinglePanorama, // Example mode, default is SinglePanorama
    InnerRadius = 0.2, // Example value
    OuterRadius = 0.8, // Example value
    XCenter = 0.5,     // Example value, default is 0.5
    YCenter = 0.5,     // Example value, default is 0.5
    // InterpolationMethod = CVDewarpInterpolationMode.Bilinear, // This is the default
};

var dewarpBlock = new CVDewarpBlock(dewarpSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, dewarpBlock.Input);
pipeline.Connect(dewarpBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Ensure the VisioForge OpenCV NuGet package is referenced in your project.

## CV Dilate Block

The CV Dilate block performs a dilation operation on the video stream. Dilation is a morphological operation that typically expands bright regions and shrinks dark regions.

### Block info

Name: `CVDilateBlock` (GStreamer element: `cvdilate`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

This block does not have specific settings beyond the default behavior. The dilation is performed with a default structuring element.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVDilateBlock;
    CVDilateBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var dilateBlock = new CVDilateBlock();

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, dilateBlock.Input);
pipeline.Connect(dilateBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Ensure the VisioForge OpenCV NuGet package is referenced in your project.

## CV Edge Detect Block

The CV Edge Detect block uses the Canny edge detector algorithm to find edges in the video stream.

### Block info

Name: `CVEdgeDetectBlock` (GStreamer element: `edgedetect`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVEdgeDetectBlock` is configured using `CVEdgeDetectSettings`. Key properties:

- `ApertureSize` (int): Aperture size for the Sobel operator (e.g., 3, 5, or 7). Default is 3.
- `Threshold1` (int): First threshold for the hysteresis procedure. Default is 50.
- `Threshold2` (int): Second threshold for the hysteresis procedure. Default is 150.
- `Mask` (bool): If true, the output is a mask; otherwise, it's the original image with edges highlighted. Default is `false`.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVEdgeDetectBlock;
    CVEdgeDetectBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var edgeDetectSettings = new CVEdgeDetectSettings
{
    ApertureSize = 3, // Example value, default is 3
    Threshold1 = 2000, // Example value, actual C# type is int, default is 50
    Threshold2 = 4000, // Example value, actual C# type is int, default is 150
    Mask = true       // Example value, default is false
};

var edgeDetectBlock = new CVEdgeDetectBlock(edgeDetectSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, edgeDetectBlock.Input);
pipeline.Connect(edgeDetectBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Ensure the VisioForge OpenCV NuGet package is referenced in your project.

## CV Equalize Histogram Block

The CV Equalize Histogram block equalizes the histogram of a video frame using the `cvEqualizeHist` function. This typically improves the contrast of the image.

### Block info

Name: `CVEqualizeHistogramBlock` (GStreamer element: `cvequalizehist`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

This block does not have specific settings beyond the default behavior.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVEqualizeHistogramBlock;
    CVEqualizeHistogramBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var equalizeHistBlock = new CVEqualizeHistogramBlock();

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, equalizeHistBlock.Input);
pipeline.Connect(equalizeHistBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Ensure the VisioForge OpenCV NuGet package is referenced in your project.

## CV Erode Block

The CV Erode block performs an erosion operation on the video stream. Erosion is a morphological operation that typically shrinks bright regions and expands dark regions.

### Block info

Name: `CVErodeBlock` (GStreamer element: `cverode`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

This block does not have specific settings beyond the default behavior. The erosion is performed with a default structuring element.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVErodeBlock;
    CVErodeBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var erodeBlock = new CVErodeBlock();

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, erodeBlock.Input);
pipeline.Connect(erodeBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Ensure the VisioForge OpenCV NuGet package is referenced in your project.

## CV Face Blur Block

The CV Face Blur block detects faces in the video stream and applies a blur effect to them.

### Block info

Name: `CVFaceBlurBlock` (GStreamer element: `faceblur`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVFaceBlurBlock` is configured using `CVFaceBlurSettings`. Key properties:

- `MainCascadeFile` (string): Path to the XML file for the primary Haar cascade classifier used for face detection (e.g., `haarcascade_frontalface_default.xml`). Default is `"haarcascade_frontalface_default.xml"`.
- `MinNeighbors` (int): Minimum number of neighbors each candidate rectangle should have to retain it. Default is 3.
- `MinSize` (`Size`): Minimum possible object size. Objects smaller than this are ignored. Default `new Size(30, 30)`.
- `ScaleFactor` (double): How much the image size is reduced at each image scale. Default is 1.25.

Note: `ProcessPaths(Context)` should be called on the settings object to ensure correct path resolution for cascade files.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVFaceBlurBlock;
    CVFaceBlurBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var faceBlurSettings = new CVFaceBlurSettings
{
    MainCascadeFile = "haarcascade_frontalface_default.xml", // Adjust path as needed, this is the default
    MinNeighbors = 5, // Example value, default is 3
    ScaleFactor = 1.2, // Example value, default is 1.25
    // MinSize = new VisioForge.Core.Types.Size(30, 30) // This is the default
};
// It's important to call ProcessPaths if you are not providing an absolute path
// and relying on SDK's internal mechanisms to locate the file, especially when deployed.
// faceBlurSettings.ProcessPaths(pipeline.GetContext()); // or pass appropriate context

var faceBlurBlock = new CVFaceBlurBlock(faceBlurSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, faceBlurBlock.Input);
pipeline.Connect(faceBlurBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

This block requires Haar cascade XML files for face detection. These files are typically bundled with OpenCV distributions. Ensure the path to `MainCascadeFile` is correctly specified. The `ProcessPaths` method on the settings object can help resolve paths if files are placed in standard locations known to the SDK.

## CV Face Detect Block

The CV Face Detect block detects faces, and optionally eyes, noses, and mouths, in the video stream using Haar cascade classifiers.

### Block info

Name: `CVFaceDetectBlock` (GStreamer element: `facedetect`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVFaceDetectBlock` is configured using `CVFaceDetectSettings`. Key properties:

- `Display` (bool): If `true`, draws rectangles around detected features on the output video. Default is `true`.
- `MainCascadeFile` (string): Path to the XML for the primary Haar cascade. Default is `"haarcascade_frontalface_default.xml"`.
- `EyesCascadeFile` (string): Path to the XML for eyes detection. Default is `"haarcascade_mcs_eyepair_small.xml"`. Optional.
- `NoseCascadeFile` (string): Path to the XML for nose detection. Default is `"haarcascade_mcs_nose.xml"`. Optional.
- `MouthCascadeFile` (string): Path to the XML for mouth detection. Default is `"haarcascade_mcs_mouth.xml"`. Optional.
- `MinNeighbors` (int): Minimum neighbors for candidate retention. Default 3.
- `MinSize` (`Size`): Minimum object size. Default `new Size(30, 30)`.
- `MinDeviation` (int): Minimum standard deviation. Default 0.
- `ScaleFactor` (double): Image size reduction factor at each scale. Default 1.25.
- `UpdatesMode` (`CVFaceDetectUpdates` enum): Controls how updates/events are posted (`EveryFrame`, `OnChange`, `OnFace`, `None`). Default `CVFaceDetectUpdates.EveryFrame`.

Note: `ProcessPaths(Context)` should be called on the settings object for cascade files.

### Events

- `FaceDetected`: Occurs when faces (and other enabled features) are detected. Provides `CVFaceDetectedEventArgs` with an array of `CVFace` objects and a timestamp.
- `CVFace` contains `Rect` for `Position`, `Nose`, `Mouth`, and a list of `Rect` for `Eyes`.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVFaceDetectBlock;
    CVFaceDetectBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var faceDetectSettings = new CVFaceDetectSettings
{
    MainCascadeFile = "haarcascade_frontalface_default.xml", // Adjust path, default
    EyesCascadeFile = "haarcascade_mcs_eyepair_small.xml", // Adjust path, default, optional
    // NoseCascadeFile = "haarcascade_mcs_nose.xml", // Optional, default
    // MouthCascadeFile = "haarcascade_mcs_mouth.xml", // Optional, default
    Display = true, // Default
    UpdatesMode = CVFaceDetectUpdates.EveryFrame, // Default, possible values: EveryFrame, OnChange, OnFace, None
    MinNeighbors = 5, // Example value, default is 3
    ScaleFactor = 1.2, // Example value, default is 1.25
    // MinSize = new VisioForge.Core.Types.Size(30,30) // Default
};
// faceDetectSettings.ProcessPaths(pipeline.GetContext()); // or appropriate context

var faceDetectBlock = new CVFaceDetectBlock(faceDetectSettings);

faceDetectBlock.FaceDetected += (s, e) =>
{
    Console.WriteLine($"Timestamp: {e.Timestamp}, Faces found: {e.Faces.Length}");
    foreach (var face in e.Faces)
    {
        Console.WriteLine($"  Face at [{face.Position.Left},{face.Position.Top},{face.Position.Width},{face.Position.Height}]");
        if (face.Eyes.Any())
        {
            Console.WriteLine($"    Eyes at [{face.Eyes[0].Left},{face.Eyes[0].Top},{face.Eyes[0].Width},{face.Eyes[0].Height}]");
        }
    }
};

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, faceDetectBlock.Input);
pipeline.Connect(faceDetectBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Requires Haar cascade XML files. The `ProcessBusMessage` method in the C# class handles parsing messages from the GStreamer element to fire the `FaceDetected` event.

## CV Hand Detect Block

The CV Hand Detect block detects hand gestures (fist or palm) in the video stream using Haar cascade classifiers. It internally resizes the input video to 320x240 for processing.

### Block info

Name: `CVHandDetectBlock` (GStreamer element: `handdetect`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVHandDetectBlock` is configured using `CVHandDetectSettings`. Key properties:

- `Display` (bool): If `true`, draws rectangles around detected hands on the output video. Default is `true`.
- `FistCascadeFile` (string): Path to the XML for fist detection. Default is `"fist.xml"`.
- `PalmCascadeFile` (string): Path to the XML for palm detection. Default is `"palm.xml"`.
- `ROI` (`Rect`): Region Of Interest for detection. Coordinates are relative to the 320x240 processed image. Default (0,0,0,0) - full frame (corresponds to `new Rect()`).

Note: `ProcessPaths(Context)` should be called on the settings object for cascade files.

### Events

- `HandDetected`: Occurs when hands are detected. Provides `CVHandDetectedEventArgs` with an array of `CVHand` objects.
- `CVHand` contains `Rect` for `Position` and `CVHandGesture` for `Gesture` (Fist or Palm).

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVHandDetectBlock;
    CVHandDetectBlock-->VideoRendererBlock;
```

Note: The `CVHandDetectBlock` internally includes a `videoscale` element to resize input to 320x240 before the `handdetect` GStreamer element.

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var handDetectSettings = new CVHandDetectSettings
{
    FistCascadeFile = "fist.xml", // Adjust path, default
    PalmCascadeFile = "palm.xml", // Adjust path, default
    Display = true, // Default
    ROI = new VisioForge.Core.Types.Rect(0, 0, 320, 240) // Example: full frame of scaled image, default is new Rect()
};
// handDetectSettings.ProcessPaths(pipeline.GetContext()); // or appropriate context

var handDetectBlock = new CVHandDetectBlock(handDetectSettings);

handDetectBlock.HandDetected += (s, e) =>
{
    Console.WriteLine($"Hands found: {e.Hands.Length}");
    foreach (var hand in e.Hands)
    {
        Console.WriteLine($"  Hand at [{hand.Position.Left},{hand.Position.Top},{hand.Position.Width},{hand.Position.Height}], Gesture: {hand.Gesture}");
    }
};

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, handDetectBlock.Input);
pipeline.Connect(handDetectBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Requires Haar cascade XML files for fist and palm detection. The input video is internally scaled to 320x240 for processing by the `handdetect` element. The `ProcessBusMessage` method handles GStreamer messages to fire `HandDetected`.

## CV Laplace Block

The CV Laplace block applies a Laplace operator to the video stream, which highlights regions of rapid intensity change, often used for edge detection.

### Block info

Name: `CVLaplaceBlock` (GStreamer element: `cvlaplace`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVLaplaceBlock` is configured using `CVLaplaceSettings`. Key properties:

- `ApertureSize` (int): Aperture size for the Sobel operator used internally (e.g., 1, 3, 5, or 7). Default 3.
- `Scale` (double): Optional scale factor for the computed Laplacian values. Default 1.
- `Shift` (double): Optional delta value that is added to the results prior to storing them. Default 0.
- `Mask` (bool): If true, the output is a mask; otherwise, it's the original image with the effect applied. Default is true.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVLaplaceBlock;
    CVLaplaceBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var laplaceSettings = new CVLaplaceSettings
{
    ApertureSize = 3, // Example value
    Scale = 1.0,      // Example value
    Shift = 0.0,      // Example value
    Mask = true
};

var laplaceBlock = new CVLaplaceBlock(laplaceSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, laplaceBlock.Input);
pipeline.Connect(laplaceBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Ensure the VisioForge OpenCV NuGet package is referenced in your project.

## CV Motion Cells Block

The CV Motion Cells block detects motion in a video stream by dividing the frame into a grid of cells and analyzing changes within these cells.

### Block info

Name: `CVMotionCellsBlock` (GStreamer element: `motioncells`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVMotionCellsBlock` is configured using `CVMotionCellsSettings`. Key properties:

- `CalculateMotion` (bool): Enable or disable motion calculation. Default `true`.
- `CellsColor` (`SKColor`): Color to draw motion cells if `Display` is true. Default `SKColors.Red`.
- `DataFile` (string): Path to a data file for loading/saving cell configuration. Extension is handled separately by `DataFileExtension`.
- `DataFileExtension` (string): Extension for the data file (e.g., "dat").
- `Display` (bool): If `true`, draws the grid and motion indication on the output video. Default `true`.
- `Gap` (`TimeSpan`): Interval after which motion is considered finished and a "motion finished" bus message is posted. Default `TimeSpan.FromSeconds(5)`. (Note: This is different from a pixel gap between cells).
- `GridSize` (`Size`): Number of cells in the grid (Width x Height). Default `new Size(10, 10)`.
- `MinimumMotionFrames` (int): Minimum number of frames motion must be detected in a cell to trigger. Default 1.
- `MotionCellsIdx` (string): Comma-separated string of cell indices (e.g., "0:0,1:1") to monitor for motion.
- `MotionCellBorderThickness` (int): Thickness of the border for cells with detected motion. Default 1.
- `MotionMaskCellsPos` (string): String defining cell positions for a motion mask.
- `MotionMaskCoords` (string): String defining coordinates for a motion mask.
- `PostAllMotion` (bool): Post all motion events. Default `false`.
- `PostNoMotion` (`TimeSpan`): Time after which a "no motion" event is posted if no motion is detected. Default `TimeSpan.Zero` (disabled).
- `Sensitivity` (double): Motion sensitivity. Expected range might be 0.0 to 1.0. Default `0.5`.
- `Threshold` (double): Threshold for motion detection, representing the fraction of cells that need to have moved. Default `0.01`.
- `UseAlpha` (bool): Use alpha channel for drawing. Default `true`.

### Events

- `MotionDetected`: Occurs when motion is detected or changes state. Provides `CVMotionCellsEventArgs`:
- `Cells`: String indicating which cells have motion (e.g., "0:0,1:2").
- `StartedTime`: Timestamp when motion began in the current event scope.
- `FinishedTime`: Timestamp when motion finished (if applicable to the event).
- `CurrentTime`: Timestamp of the current frame related to the event.
- `IsMotion`: Boolean indicating if the event signifies motion (`true`) or no motion (`false`).

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVMotionCellsBlock;
    CVMotionCellsBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var motionCellsSettings = new CVMotionCellsSettings
{
    GridSize = new VisioForge.Core.Types.Size(8, 6), // Example: 8x6 grid, default is new Size(10,10)
    Sensitivity = 0.75, // Example value, C# default is 0.5. Represents sensitivity.
    Threshold = 0.05,   // Example value, C# default is 0.01. Represents fraction of moved cells.
    Display = true,     // Default is true
    CellsColor = SKColors.Aqua, // Example color, default is SKColors.Red
    PostNoMotion = TimeSpan.FromSeconds(5) // Post no_motion after 5s of inactivity, default is TimeSpan.Zero
};

var motionCellsBlock = new CVMotionCellsBlock(motionCellsSettings);

motionCellsBlock.MotionDetected += (s, e) =>
{
    if (e.IsMotion)
    {
        Console.WriteLine($"Motion DETECTED at {e.CurrentTime}. Cells: {e.Cells}. Started: {e.StartedTime}");
    }
    else
    {
        Console.WriteLine($"Motion FINISHED or NO MOTION at {e.CurrentTime}. Finished: {e.FinishedTime}");
    }
};

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, motionCellsBlock.Input);
pipeline.Connect(motionCellsBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

The `ProcessBusMessage` method handles GStreamer messages to fire `MotionDetected`. Event structure provides timestamps for motion start, finish, and current event time.

## CV Smooth Block

The CV Smooth block applies various smoothing (blurring) filters to the video stream.

### Block info

Name: `CVSmoothBlock` (GStreamer element: `cvsmooth`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVSmoothBlock` is configured using `CVSmoothSettings`. Key properties:

- `Type` (`CVSmoothType` enum): Type of smoothing filter to apply (`Blur`, `Gaussian`, `Median`, `Bilateral`). Default `CVSmoothType.Gaussian`.
- `KernelWidth` (int): Width of the kernel for `Blur`, `Gaussian`, `Median` filters. Default 3.
- `KernelHeight` (int): Height of the kernel for `Blur`, `Gaussian`, `Median` filters. Default 3.
- `Width` (int): Width of the area to blur. Default `int.MaxValue` (full frame).
- `Height` (int): Height of the area to blur. Default `int.MaxValue` (full frame).
- `PositionX` (int): X position for the blur area. Default 0.
- `PositionY` (int): Y position for the blur area. Default 0.
- `Color` (double): Sigma for color space (for Bilateral filter) or standard deviation (for Gaussian if `SpatialSigma` is 0). Default 0.
- `SpatialSigma` (double): Sigma for coordinate space (for Bilateral and Gaussian filters). For Gaussian, if 0, it's calculated from `KernelWidth`/`KernelHeight`. Default 0.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVSmoothBlock;
    CVSmoothBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var smoothSettings = new CVSmoothSettings
{
    Type = CVSmoothType.Gaussian, // Example: Gaussian blur, also the default
    KernelWidth = 5,  // Kernel width, default is 3
    KernelHeight = 5, // Kernel height, default is 3
    SpatialSigma = 1.5 // Sigma for Gaussian. If 0 (default), it's calculated from kernel size.
};

var smoothBlock = new CVSmoothBlock(smoothSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, smoothBlock.Input);
pipeline.Connect(smoothBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Ensure the VisioForge OpenCV NuGet package is referenced in your project. The specific parameters used by the GStreamer element (`color`, `spatial`, `kernel-width`, `kernel-height`) depend on the chosen `Type`. For kernel dimensions, use `KernelWidth` and `KernelHeight`. `Width` and `Height` define the area to apply the blur if not the full frame.

## CV Sobel Block

The CV Sobel block applies a Sobel operator to the video stream, which is used to calculate the derivative of an image intensity function, typically for edge detection.

### Block info

Name: `CVSobelBlock` (GStreamer element: `cvsobel`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVSobelBlock` is configured using `CVSobelSettings`. Key properties:

- `XOrder` (int): Order of the derivative x. Default 1.
- `YOrder` (int): Order of the derivative y. Default 1.
- `ApertureSize` (int): Size of the extended Sobel kernel (1, 3, 5, or 7). Default 3.
- `Mask` (bool): If true, the output is a mask; otherwise, it's the original image with the effect applied. Default is true.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVSobelBlock;
    CVSobelBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var sobelSettings = new CVSobelSettings
{
    XOrder = 1,       // Default is 1. Used for order of the derivative X.
    YOrder = 0,       // Example: Use 0 for Y-order to primarily detect vertical edges. C# class default is 1.
    ApertureSize = 3, // Default is 3. Size of the extended Sobel kernel.
    Mask = true       // Default is true. Output as a mask.
};

var sobelBlock = new CVSobelBlock(sobelSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, sobelBlock.Input);
pipeline.Connect(sobelBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Ensure the VisioForge OpenCV NuGet package is referenced in your project.

## CV Template Match Block

The CV Template Match block searches for occurrences of a template image within the video stream.

### Block info

Name: `CVTemplateMatchBlock` (GStreamer element: `templatematch`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVTemplateMatchBlock` is configured using `CVTemplateMatchSettings`. Key properties:

- `TemplateImage` (string): Path to the template image file (e.g., PNG, JPG) to search for.
- `Method` (`CVTemplateMatchMethod` enum): The comparison method to use (e.g., `Sqdiff`, `CcorrNormed`, `CcoeffNormed`). Default `CVTemplateMatchMethod.Correlation`.
- `Display` (bool): If `true`, draws a rectangle around the best match on the output video. Default `true`.

### Events

- `TemplateMatch`: Occurs when a template match is found. Provides `CVTemplateMatchEventArgs`:
- `Rect`: A `Types.Rect` object representing the location (`Left`, `Top`, `Right`, `Bottom`) of the best match. `Width` and `Height` are computed properties (`Right - Left`, `Bottom - Top`).
- `Result`: A double value representing the quality or result of the match, depending on the method used.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVTemplateMatchBlock;
    CVTemplateMatchBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'
// Ensure "template.png" exists and is accessible.
var templateMatchSettings = new CVTemplateMatchSettings("path/to/your/template.png") // Adjust path as needed
{
    // Method: Specifies the comparison method.
    // Example: CVTemplateMatchMethod.CcoeffNormed is often a good choice.
    // C# class default is CVTemplateMatchMethod.Correlation.
    Method = CVTemplateMatchMethod.CcoeffNormed,

    // Display: If true, draws a rectangle around the best match.
    // C# class default is true.
    Display = true
};

var templateMatchBlock = new CVTemplateMatchBlock(templateMatchSettings);

templateMatchBlock.TemplateMatch += (s, e) =>
{
    Console.WriteLine($"Template matched at [{e.Rect.Left},{e.Rect.Top},{e.Rect.Width},{e.Rect.Height}] with result: {e.Result}");
};

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, templateMatchBlock.Input);
pipeline.Connect(templateMatchBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Ensure the VisioForge OpenCV NuGet package and a valid template image file are available. The `ProcessBusMessage` method handles GStreamer messages to fire the `TemplateMatch` event.

## CV Text Overlay Block

The CV Text Overlay block renders text onto the video stream using OpenCV drawing functions.

### Block info

Name: `CVTextOverlayBlock` (GStreamer element: `opencvtextoverlay`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVTextOverlayBlock` is configured using `CVTextOverlaySettings`. Key properties:

- `Text` (string): The text string to overlay. Default: `"Default text"`.
- `X` (int): X-coordinate of the bottom-left corner of the text string. Default: `50`.
- `Y` (int): Y-coordinate of the bottom-left corner of the text string (from the top, OpenCV origin is top-left, GStreamer textoverlay might be bottom-left). Default: `50`.
- `FontWidth` (double): Font scale factor that is multiplied by the font-specific base size. Default: `1.0`.
- `FontHeight` (double): Font scale factor (similar to FontWidth, though GStreamer element usually has one `font-scale` or relies on point size). Default: `1.0`.
- `FontThickness` (int): Thickness of the lines used to draw a text. Default: `1`.
- `Color` (`SKColor`): Color of the text. Default: `SKColors.Black`.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVTextOverlayBlock;
    CVTextOverlayBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var textOverlaySettings = new CVTextOverlaySettings
{
    Text = "VisioForge MediaBlocks.Net ROCKS!", // Default: "Default text"
    X = 20, // X position of the text start. Default: 50
    Y = 40, // Y position of the text baseline (from top). Default: 50
    FontWidth = 1.2, // Font scale. Default: 1.0
    FontHeight = 1.2, // Font scale (usually FontWidth is sufficient for opencvtextoverlay). Default: 1.0
    FontThickness = 2, // Default: 1
    Color = SKColors.Blue // Default: SKColors.Black
};

var textOverlayBlock = new CVTextOverlayBlock(textOverlaySettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, textOverlayBlock.Input);
pipeline.Connect(textOverlayBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Ensure the VisioForge OpenCV NuGet package is referenced. The GStreamer properties `colorR`, `colorG`, `colorB` are set based on the `Color` property.

## CV Tracker Block

The CV Tracker block implements various object tracking algorithms to follow an object defined by an initial bounding box in a video stream.

### Block info

Name: `CVTrackerBlock` (GStreamer element: `cvtracker`).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Settings

The `CVTrackerBlock` is configured using `CVTrackerSettings`. Key properties:

- `Algorithm` (`CVTrackerAlgorithm` enum): Specifies the tracking algorithm (`Boosting`, `CSRT`, `KCF`, `MedianFlow`, `MIL`, `MOSSE`, `TLD`). Default: `CVTrackerAlgorithm.MedianFlow`.
- `InitialRect` (`Rect`): The initial bounding box of the object to track. `Rect` ctor is `(left, top, right, bottom)` — e.g., `new Rect(50, 50, 150, 150)` is a 100×100 box at (50, 50). Default: `new Rect()` (zero-sized).
- `DrawRect` (bool): If `true`, draws a rectangle around the tracked object on the output video. Default: `true`.

### Sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->CVTrackerBlock;
    CVTrackerBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming SystemVideoSourceBlock is already created and configured as 'videoSource'

var trackerSettings = new CVTrackerSettings
{
    Algorithm = CVTrackerAlgorithm.CSRT, // CSRT is often a good general-purpose tracker. Default: CVTrackerAlgorithm.MedianFlow
    InitialRect = new VisioForge.Core.Types.Rect(150, 120, 230, 200), // (left, top, right, bottom) — 80x80 box at (150,120). Default: new Rect()
    DrawRect = true // Default: true
};

var trackerBlock = new CVTrackerBlock(trackerSettings);

// Note: The tracker initializes with InitialRect.
// To re-initialize tracking on a new object/location at runtime:
// 1. Pause or Stop the pipeline.
// 2. Update trackerBlock.Settings.InitialRect (or create new CVTrackerSettings).
//    It's generally safer to update settings on a stopped/paused pipeline,
//    or if the block/element supports dynamic property changes, that might be an option.
//    Directly modifying `trackerBlock.Settings.InitialRect` might not re-initialize the underlying GStreamer element.
//    You may need to remove and re-add the block, or check SDK documentation for live update capabilities.
// 3. Resume/Start the pipeline.

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(videoSource.Output, trackerBlock.Input);
pipeline.Connect(trackerBlock.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

### Remarks

Ensure the VisioForge OpenCV NuGet package is referenced. The choice of tracking algorithm can significantly impact performance and accuracy. Some algorithms (like CSRT, KCF) are generally more robust than older ones (like Boosting, MedianFlow). Some trackers might require OpenCV contrib modules to be available in your OpenCV build/distribution.

---END OF PAGE---


## GPU-Accelerated OpenGL Video Effects and Shaders in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/OpenGL/
**Description:** Apply GPU-accelerated OpenGL video effects like blur, color correction, and shaders in real-time using VisioForge Media Blocks SDK pipelines.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS
**API:** GLBaseVideoEffect, GLShaderSettings, GLVideoMixerSettings, GLVirtualVideoSourceBlock

# OpenGL Video Effects - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

OpenGL video effects in VisioForge Media Blocks SDK .Net allow for powerful, hardware-accelerated manipulation of video streams. Each effect ships as its own stand-alone MediaBlock (e.g. `GLBlurBlock`, `GLFlipBlock`, `GLAlphaBlock`) and is chained between `GLUploadBlock` on the input side and `GLDownloadBlock` on the output side. This guide covers the available effects, their configuration settings, and other related OpenGL types.

## Base Effect: `GLBaseVideoEffect`

All OpenGL video effects inherit from the `GLBaseVideoEffect` class, which provides common properties and events.

| Property | Type | Description |
| --- | --- | --- |
| `Name` | `string` | The internal name of the effect (read-only). |
| `ID` | `GLVideoEffectID` | The unique identifier for the effect (read-only). |
| `Index` | `int` | The index of the effect in a chain. |

**Events:**

- `OnUpdate`: Occurs when effect properties need to be updated in the pipeline. Call `OnUpdateCall()` to trigger it.

## Available Video Effects

This section details the various OpenGL video effects you can use. Each effect is an independent MediaBlock — instantiate the block directly (e.g. `new GLBlurBlock()`) and connect it between `GLUploadBlock` and `GLDownloadBlock` (or between other GL blocks) in your pipeline.

### Alpha Effect (`GLAlphaVideoEffect`)

Replaces a selected color with an alpha channel or sets/adjusts the existing alpha channel.

**Properties:**

| Property | Type | Default Value | Description |
| --- | --- | --- | --- |
| `Alpha` | `double` | `1.0` | The value for the alpha channel. |
| `Angle` | `float` | `20` | The size of the colorcube to change (sensitivity radius for color matching). |
| `BlackSensitivity` | `uint` | `100` | The sensitivity to dark colors. |
| `Mode` | `GLAlphaVideoEffectMode` | `Set` | The method used for alpha modification. |
| `NoiseLevel` | `float` | `2` | The size of noise radius (pixels to ignore around the matched color). |
| `CustomColor` | `SKColor` | `SKColors.Green` | Custom color value for `Custom` chroma key mode. |
| `WhiteSensitivity` | `uint` | `100` | The sensitivity to bright colors. |

**Associated Enum: `GLAlphaVideoEffectMode`**

Defines the mode of operation for the Alpha video effect.

| Value | Description |
| --- | --- |
| `Set` | Set/adjust alpha channel directly using the `Alpha` property. |
| `Green` | Chroma Key on pure green. |
| `Blue` | Chroma Key on pure blue. |
| `Custom` | Chroma Key on the color specified by `CustomColor`. |

### Blur Effect (`GLBlurVideoEffect`)

Applies a blur effect using a 9x9 separable convolution. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Bulge Effect (`GLBulgeVideoEffect`)

Creates a bulge distortion on the video. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Color Balance Effect (`GLColorBalanceVideoEffect`)

Adjusts the color balance of the video, including brightness, contrast, hue, and saturation.

**Properties:**

| Property | Type | Default Value | Description |
| --- | --- | --- | --- |
| `Brightness` | `double` | `0` | Adjusts brightness (-1.0 to 1.0, 0 means no change). |
| `Contrast` | `double` | `1` | Adjusts contrast (0.0 to infinity, 1 means no change). |
| `Hue` | `double` | `0` | Adjusts hue (-1.0 to 1.0, 0 means no change). |
| `Saturation` | `double` | `1` | Adjusts saturation (0.0 to infinity, 1 means no change). |

### Deinterlace Effect (`GLDeinterlaceVideoEffect`)

Applies a deinterlacing filter to the video.

**Properties:**

| Property | Type | Default Value | Description |
| --- | --- | --- | --- |
| `Method` | `GLDeinterlaceMethod` | `VerticalBlur` | The deinterlacing method to use. |

**Associated Enum: `GLDeinterlaceMethod`**

Defines the method for the Deinterlace video effect.

| Value | Description |
| --- | --- |
| `VerticalBlur` | Vertical blur method. |
| `MAAD` | Motion Adaptive: Advanced Detection. |

### Fish Eye Effect (`GLFishEyeVideoEffect`)

Applies a fish-eye lens distortion effect. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Flip Effect (`GLFlipVideoEffect`)

Flips or rotates the video.

**Properties:**

| Property | Type | Default Value | Description |
| --- | --- | --- | --- |
| `Method` | `GLFlipVideoMethod` | `None` | The flip or rotation method to use. |

**Associated Enum: `GLFlipVideoMethod`**

Defines the video flip or rotation method.

| Value | Description |
| --- | --- |
| `None` | No rotation. |
| `Clockwise` | Rotate clockwise 90 degrees. |
| `Rotate180` | Rotate 180 degrees. |
| `CounterClockwise` | Rotate counter-clockwise 90 degrees. |
| `HorizontalFlip` | Flip horizontally. |
| `VerticalFlip` | Flip vertically. |
| `UpperLeftDiagonal` | Flip across upper left/lower right diagonal. |
| `UpperRightDiagonal` | Flip across upper right/lower left diagonal. |

### Glow Lighting Effect (`GLGlowLightingVideoEffect`)

Adds a glow lighting effect to the video. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Grayscale Effect (`GLGrayscaleVideoEffect`)

Converts the video to grayscale. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Heat Effect (`GLHeatVideoEffect`)

Applies a heat signature-like effect to the video. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Laplacian Effect (`GLLaplacianVideoEffect`)

Applies a Laplacian edge detection filter.

**Properties:**

| Property | Type | Default Value | Description |
| --- | --- | --- | --- |
| `Invert` | `bool` | `false` | If `true`, inverts colors to get dark edges on a bright background. |

### Light Tunnel Effect (`GLLightTunnelVideoEffect`)

Creates a light tunnel visual effect. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Luma Cross Processing Effect (`GLLumaCrossProcessingVideoEffect`)

Applies a luma cross-processing (often "xpro") effect. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Mirror Effect (`GLMirrorVideoEffect`)

Applies a mirror effect to the video. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Resize Effect (`GLResizeVideoEffect`)

Resizes the video to the specified dimensions.

**Properties:**

| Property | Type | Description |
| --- | --- | --- |
| `Width` | `int` | The target width for the video resize. |
| `Height` | `int` | The target height for the video resize. |

### Sepia Effect (`GLSepiaVideoEffect`)

Applies a sepia tone effect to the video. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Sin City Effect (`GLSinCityVideoEffect`)

Applies a "Sin City" movie style effect (grayscale with red highlights). This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Sobel Effect (`GLSobelVideoEffect`)

Applies a Sobel edge detection filter.

**Properties:**

| Property | Type | Default Value | Description |
| --- | --- | --- | --- |
| `Invert` | `bool` | `false` | If `true`, inverts colors to get dark edges on a bright background. |

### Square Effect (`GLSquareVideoEffect`)

Applies a "square" distortion or pixelation effect. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Squeeze Effect (`GLSqueezeVideoEffect`)

Applies a squeeze distortion effect. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Stretch Effect (`GLStretchVideoEffect`)

Applies a stretch distortion effect. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### Transformation Effect (`GLTransformationVideoEffect`)

Applies 3D transformations to the video, including rotation, scaling, and translation.

**Properties:**

| Property | Type | Default Value | Description |
| --- | --- | --- | --- |
| `FOV` | `float` | `90.0f` | Field of view angle in degrees for perspective projection. |
| `Ortho` | `bool` | `false` | If `true`, uses orthographic projection; otherwise, perspective. |
| `PivotX` | `float` | `0.0f` | X-coordinate of the rotation pivot point (0 is center). |
| `PivotY` | `float` | `0.0f` | Y-coordinate of the rotation pivot point (0 is center). |
| `PivotZ` | `float` | `0.0f` | Z-coordinate of the rotation pivot point (0 is center). |
| `RotationX` | `float` | `0.0f` | Rotation around the X-axis in degrees. |
| `RotationY` | `float` | `0.0f` | Rotation around the Y-axis in degrees. |
| `RotationZ` | `float` | `0.0f` | Rotation around the Z-axis in degrees. |
| `ScaleX` | `float` | `1.0f` | Scale multiplier for the X-axis. |
| `ScaleY` | `float` | `1.0f` | Scale multiplier for the Y-axis. |
| `TranslationX` | `float` | `0.0f` | Translation along the X-axis (universal coordinates [0-1]). |
| `TranslationY` | `float` | `0.0f` | Translation along the Y-axis (universal coordinates [0-1]). |
| `TranslationZ` | `float` | `0.0f` | Translation along the Z-axis (universal coordinates [0-1], depth). |

### Twirl Effect (`GLTwirlVideoEffect`)

Applies a twirl distortion effect. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

### X-Ray Effect (`GLXRayVideoEffect`)

Applies an X-ray like visual effect. This effect does not have additional configurable properties beyond those inherited from `GLBaseVideoEffect`.

## OpenGL Effect Identification: `GLVideoEffectID` Enum

This enumeration lists all available OpenGL video effect types, used by `GLBaseVideoEffect.ID`.

| Value | Description |
| --- | --- |
| `ColorBalance` | The color balance effect. |
| `Grayscale` | The grayscale effect. |
| `Resize` | The resize effect. |
| `Deinterlace` | The deinterlace effect. |
| `Flip` | The flip effect. |
| `Blur` | Blur with 9x9 separable convolution effect. |
| `FishEye` | The fish eye effect. |
| `GlowLighting` | The glow lighting effect. |
| `Heat` | The heat signature effect. |
| `LumaX` | The luma cross processing effect. |
| `Mirror` | The mirror effect. |
| `Sepia` | The sepia effect. |
| `Square` | The square effect. |
| `XRay` | The X-ray effect. |
| `Stretch` | The stretch effect. |
| `LightTunnel` | The light tunnel effect. |
| `Twirl` | The twirl effect. |
| `Squeeze` | The squeeze effect. |
| `SinCity` | The sin city movie gray-red effect. |
| `Bulge` | The bulge effect. |
| `Sobel` | The sobel effect. |
| `Laplacian` | The laplacian effect. |
| `Alpha` | The alpha channels effect. |
| `Transformation` | The transformation effect. |

## OpenGL Rendering and View Configuration

These types assist in configuring how video is rendered or viewed in an OpenGL context, especially for specialized scenarios like VR or custom display setups.

### Equirectangular View Settings (`GLEquirectangularViewSettings`)

Manages settings for rendering equirectangular (360-degree) video, commonly used in VR applications. Implements `IVRVideoControl`.

**Properties:**

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `VideoWidth` | `int` | (readonly) | Width of the source video. |
| `VideoHeight` | `int` | (readonly) | Height of the source video. |
| `FieldOfView` | `float` | `80.0f` | Field of view in degrees. |
| `Yaw` | `float` | `0.0f` | Yaw (rotation around Y-axis) in degrees. |
| `Pitch` | `float` | `0.0f` | Pitch (rotation around X-axis) in degrees. |
| `Roll` | `float` | `0.0f` | Roll (rotation around Z-axis) in degrees. |
| `Mode` | `VRMode` | `Equirectangular` | The VR mode (supports `Equirectangular`). |

**Methods:**

- `IsModeSupported(VRMode mode)`: Checks if the specified `VRMode` is supported.

**Events:**

- `SettingsChanged`: Occurs when any view setting is changed.

### Video Renderer Settings (`GLVideoRendererSettings`)

Configures general properties for an OpenGL-based video renderer.

**Properties:**

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `ForceAspectRatio` | `bool` | `true` | Whether scaling will respect the original aspect ratio. |
| `IgnoreAlpha` | `bool` | `true` | Whether alpha channel will be ignored (treated as black). |
| `PixelAspectRatio` | `System.Tuple<int, int>` | `(0, 1)` | Pixel aspect ratio of the display device (numerator, denominator). |
| `Rotation` | `GLVideoRendererRotateMethod` | `None` | Specifies the rotation applied to the video. |

**Associated Enum: `GLVideoRendererRotateMethod`**

Defines rotation methods for the OpenGL video renderer.

| Value | Description |
| --- | --- |
| `None` | No rotation. |
| `_90C` | Rotate 90 degrees clockwise. |
| `_180` | Rotate 180 degrees. |
| `_90CC` | Rotate 90 degrees counter-clockwise. |
| `FlipHorizontal` | Flip horizontally. |
| `FlipVertical` | Flip vertically. |

## Custom OpenGL Shaders

Allows for the application of custom GLSL shaders to the video stream.

### Shader Definition (`GLShader`)

Represents a pair of vertex and fragment shaders.

**Properties:**

| Property | Type | Description |
| --- | --- | --- |
| `VertexShader` | `string` | The GLSL source code for the vertex shader. |
| `FragmentShader` | `string` | The GLSL source code for the fragment shader. |

**Constructors:** - `GLShader()` - `GLShader(string vertexShader, string fragmentShader)`

### Shader Settings (`GLShaderSettings`)

Configures custom GLSL shaders for use in the pipeline.

**Properties:**

| Property | Type | Description |
| --- | --- | --- |
| `Vertex` | `string` | The GLSL source code for the vertex shader. |
| `Fragment` | `string` | The GLSL source code for the fragment shader. |
| `Uniforms` | `System.Collections.Generic.Dictionary<string, object>` | A dictionary of uniform variables (parameters) to be passed to the shaders. |

**Constructors:** - `GLShaderSettings()` - `GLShaderSettings(string vertex, string fragment)` - `GLShaderSettings(GLShader shader)`

## Image Overlays in OpenGL

Provides settings for overlaying static images onto a video stream within an OpenGL context.

### Overlay Settings (`GLOverlaySettings`)

Defines the properties of an image overlay.

**Properties:**

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Filename` | `string` | (N/A) | Path to the image file (read-only after init). |
| `Data` | `byte[]` | (N/A) | Image data as a byte array (read-only after init). |
| `X` | `int` |  | X-coordinate of the overlay's top-left corner. |
| `Y` | `int` |  | Y-coordinate of the overlay's top-left corner. |
| `Width` | `int` |  | Width of the overlay. |
| `Height` | `int` |  | Height of the overlay. |
| `Alpha` | `double` | `1.0` | Opacity of the overlay (0.0 transparent to 1.0 opaque). |

**Constructor:** - `GLOverlaySettings(string filename)`

## OpenGL Video Mixing

These types are used to configure an OpenGL-based video mixer, allowing multiple video streams to be combined and composited.

### Mixer Settings (`GLVideoMixerSettings`)

Extends `VideoMixerBaseSettings` for OpenGL-specific video mixing. It manages a list of `GLVideoMixerStream` objects and inherits properties like `Width`, `Height`, and `FrameRate`.

**Methods:** - `AddStream(GLVideoMixerStream stream)`: Adds a stream to the mixer. - `RemoveStream(GLVideoMixerStream stream)`: Removes a stream from the mixer. - `SetStream(int index, GLVideoMixerStream stream)`: Replaces a stream at a specific index.

**Constructors:** - `GLVideoMixerSettings(int width, int height, VideoFrameRate frameRate)` - `GLVideoMixerSettings(int width, int height, VideoFrameRate frameRate, List<VideoMixerStream> streams)`

### Mixer Stream (`GLVideoMixerStream`)

Extends `VideoMixerStream` and defines properties for an individual stream within the OpenGL video mixer. Inherits `Rectangle`, `ZOrder`, and `Alpha` from `VideoMixerStream`.

**Properties:**

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Crop` | `Rect` | (N/A) | Crop rectangle for the input stream. |
| `BlendConstantColorAlpha` | `double` | `0` | Alpha component for constant blend color. |
| `BlendConstantColorBlue` | `double` | `0` | Blue component for constant blend color. |
| `BlendConstantColorGreen` | `double` | `0` | Green component for constant blend color. |
| `BlendConstantColorRed` | `double` | `0` | Red component for constant blend color. |
| `BlendEquationAlpha` | `GLVideoMixerBlendEquation` | `Add` | Blend equation for the alpha channel. |
| `BlendEquationRGB` | `GLVideoMixerBlendEquation` | `Add` | Blend equation for RGB channels. |
| `BlendFunctionDestinationAlpha` | `GLVideoMixerBlendFunction` | `OneMinusSourceAlpha` | Blend function for destination alpha. |
| `BlendFunctionDesctinationRGB` | `GLVideoMixerBlendFunction` | `OneMinusSourceAlpha` | Blend function for destination RGB. |
| `BlendFunctionSourceAlpha` | `GLVideoMixerBlendFunction` | `One` | Blend function for source alpha. |
| `BlendFunctionSourceRGB` | `GLVideoMixerBlendFunction` | `SourceAlpha` | Blend function for source RGB. |

**Constructor:** - `GLVideoMixerStream(Rect rectangle, uint zorder, double alpha = 1.0)`

### Blend Equation (`GLVideoMixerBlendEquation` Enum)

Specifies how source and destination colors are combined during blending.

| Value | Description |
| --- | --- |
| `Add` | Source + Destination |
| `Subtract` | Source - Destination |
| `ReverseSubtract` | Destination - Source |

### Blend Function (`GLVideoMixerBlendFunction` Enum)

Defines factors for source and destination colors in blending operations. (Rs, Gs, Bs, As are source color components; Rd, Gd, Bd, Ad are destination; Rc, Gc, Bc, Ac are constant color components).

| Value | Description |
| --- | --- |
| `Zero` | Factor is (0, 0, 0, 0). |
| `One` | Factor is (1, 1, 1, 1). |
| `SourceColor` | Factor is (Rs, Gs, Bs, As). |
| `OneMinusSourceColor` | Factor is (1-Rs, 1-Gs, 1-Bs, 1-As). |
| `DestinationColor` | Factor is (Rd, Gd, Bd, Ad). |
| `OneMinusDestinationColor` | Factor is (1-Rd, 1-Gd, 1-Bd, 1-Ad). |
| `SourceAlpha` | Factor is (As, As, As, As). |
| `OneMinusSourceAlpha` | Factor is (1-As, 1-As, 1-As, 1-As). |
| `DestinationAlpha` | Factor is (Ad, Ad, Ad, Ad). |
| `OneMinusDestinationAlpha` | Factor is (1-Ad, 1-Ad, 1-Ad, 1-Ad). |
| `ConstantColor` | Factor is (Rc, Gc, Bc, Ac). |
| `OneMinusContantColor` | Factor is (1-Rc, 1-Gc, 1-Bc, 1-Ac). |
| `ConstantAlpha` | Factor is (Ac, Ac, Ac, Ac). |
| `OneMinusContantAlpha` | Factor is (1-Ac, 1-Ac, 1-Ac, 1-Ac). |
| `SourceAlphaSaturate` | Factor is (min(As, 1-Ad), min(As, 1-Ad), min(As, 1-Ad), 1). |

## Virtual Test Sources for OpenGL

These settings classes are used to configure virtual sources that generate test patterns directly within an OpenGL context.

### Virtual Video Source Settings (`GLVirtualVideoSourceSettings`)

Configures a source block (`GLVirtualVideoSourceBlock`) that produces test video data. Implements `IMediaPlayerBaseSourceSettings` and `IVideoCaptureBaseVideoSourceSettings`.

**Properties:**

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Width` | `int` | `1280` | Width of the output video. |
| `Height` | `int` | `720` | Height of the output video. |
| `FrameRate` | `VideoFrameRate` | `30/1` (30 fps) | Frame rate of the output video. |
| `IsLive` | `bool` | `true` | Indicates if the source is live. |
| `Mode` | `GLVirtualVideoSourceMode` | (N/A - must be set) | Specifies the type of test pattern to generate. |

**Associated Enum: `GLVirtualVideoSourceMode`**

Defines the test pattern generated by `GLVirtualVideoSourceBlock`.

| Value | Description |
| --- | --- |
| `SMPTE` | SMPTE 100% color bars. |
| `Snow` | Random (television snow). |
| `Black` | 100% Black. |
| `White` | 100% White. |
| `Red` | Solid Red color. |
| `Green` | Solid Green color. |
| `Blue` | Solid Blue color. |
| `Checkers1` | Checkerboard pattern (1px). |
| `Checkers2` | Checkerboard pattern (2px). |
| `Checkers4` | Checkerboard pattern (4px). |
| `Checkers8` | Checkerboard pattern (8px). |
| `Circular` | Circular pattern. |
| `Blink` | Blinking pattern. |
| `Mandelbrot` | Mandelbrot fractal. |

**Methods:** - `Task<MediaFileInfo> ReadInfoAsync()`: Asynchronously reads media information (returns synthetic info based on settings). - `MediaBlock CreateBlock()`: Creates a `GLVirtualVideoSourceBlock` instance configured with these settings.

## OpenGL Processing Blocks

In addition to the per-effect blocks listed above, the SDK ships several stand-alone OpenGL processing blocks for overlay compositing, GPU resizing, format conversion, multi-stream mixing, and hardware-accelerated rendering. Like the effect blocks, these operate on GPU memory and are typically chained between `GLUploadBlock` (CPU memory to GL) and `GLDownloadBlock` (GL to CPU memory), or fed directly from other OpenGL blocks. Each block exposes a static `IsAvailable()` method you can call to verify OpenGL support on the current system before building the pipeline.

### GL Overlay

The `GLOverlayBlock` composites a static image (logo, watermark, graphic) onto the video stream on the GPU, with positioning, scaling, and alpha blending.

#### Block info

Name: GLOverlayBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Video (GL memory) | 1 |
| Output | Video (GL memory) | 1 |

The overlay is configured with `GLOverlaySettings` (see [Overlay Settings](#overlay-settings-gloverlaysettings) above). Call `UpdateSettings()` after changing the `Settings` properties to apply changes to a running pipeline.

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->GLUploadBlock;
    GLUploadBlock-->GLOverlayBlock;
    GLOverlayBlock-->GLDownloadBlock;
    GLDownloadBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var glUpload = new GLUploadBlock();

// configure the image overlay
var overlaySettings = new GLOverlaySettings("logo.png")
{
    X = 20,
    Y = 20,
    Width = 160,
    Height = 80,
    Alpha = 0.8
};
var glOverlay = new GLOverlayBlock(overlaySettings);

var glDownload = new GLDownloadBlock();
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(source.VideoOutput, glUpload.Input);
pipeline.Connect(glUpload.Output, glOverlay.Input);
pipeline.Connect(glOverlay.Output, glDownload.Input);
pipeline.Connect(glDownload.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### GL Resize

The `GLResizeBlock` performs GPU-accelerated video scaling to a target resolution using `GLResizeVideoEffect`.

#### Block info

Name: GLResizeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Video (GL memory) | 1 |
| Output | Video (GL memory) | 1 |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->GLUploadBlock;
    GLUploadBlock-->GLResizeBlock;
    GLResizeBlock-->GLDownloadBlock;
    GLDownloadBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var glUpload = new GLUploadBlock();

// resize to 1280x720 on the GPU
var glResize = new GLResizeBlock(new GLResizeVideoEffect(1280, 720));

var glDownload = new GLDownloadBlock();
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(source.VideoOutput, glUpload.Input);
pipeline.Connect(glUpload.Output, glResize.Input);
pipeline.Connect(glResize.Output, glDownload.Input);
pipeline.Connect(glDownload.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### GL Square

The `GLSquareBlock` applies a "square" geometric distortion effect on the GPU. It has no additional configuration.

#### Block info

Name: GLSquareBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Video (GL memory) | 1 |
| Output | Video (GL memory) | 1 |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->GLUploadBlock;
    GLUploadBlock-->GLSquareBlock;
    GLSquareBlock-->GLDownloadBlock;
    GLDownloadBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var glUpload = new GLUploadBlock();
var glSquare = new GLSquareBlock();
var glDownload = new GLDownloadBlock();
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(source.VideoOutput, glUpload.Input);
pipeline.Connect(glUpload.Output, glSquare.Input);
pipeline.Connect(glSquare.Output, glDownload.Input);
pipeline.Connect(glDownload.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### GL Video Converter

The `GLVideoConverterBlock` performs GPU-accelerated pixel format and colorspace conversion. It has no additional configuration.

#### Block info

Name: GLVideoConverterBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Video (GL memory) | 1 |
| Output | Video (GL memory) | 1 |

#### The sample pipeline

```
graph LR;
    GLUploadBlock-->GLVideoConverterBlock;
    GLVideoConverterBlock-->GLSepiaBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var glUpload = new GLUploadBlock();
var glConverter = new GLVideoConverterBlock();
var glSepia = new GLSepiaBlock();
var glDownload = new GLDownloadBlock();
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(source.VideoOutput, glUpload.Input);
pipeline.Connect(glUpload.Output, glConverter.Input);
pipeline.Connect(glConverter.Output, glSepia.Input);
pipeline.Connect(glSepia.Output, glDownload.Input);
pipeline.Connect(glDownload.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### GL Video Mixer

The `GLVideoMixerBlock` composites multiple input video streams into a single output on the GPU, with per-stream positioning, scaling, Z-order, alpha blending, and chroma key. It is configured with `GLVideoMixerSettings` (see [Mixer Settings](#mixer-settings-glvideomixersettings) above) and exposes one input pad per configured stream. The block implements `IVideoMixerControl`, so input streams can be queried, updated, animated (`Input_Move`, `StartFadeIn`, `StartFadeOut`), and chroma-keyed at runtime.

#### Block info

Name: GLVideoMixerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Video (GL memory) | 1 per stream |
| Output | Video (GL memory) | 1 |

#### The sample pipeline

```
graph LR;
    Source1Block-->GLUpload1Block;
    Source2Block-->GLUpload2Block;
    GLUpload1Block-->GLVideoMixerBlock;
    GLUpload2Block-->GLVideoMixerBlock;
    GLVideoMixerBlock-->GLDownloadBlock;
    GLDownloadBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// configure the mixer output and two streams
var mixerSettings = new GLVideoMixerSettings(1280, 720, new VideoFrameRate(30));
mixerSettings.AddStream(new GLVideoMixerStream(new Rect(0, 0, 1280, 720), 0));
mixerSettings.AddStream(new GLVideoMixerStream(new Rect(960, 480, 1280, 720), 1)); // left, top, right, bottom
var glMixer = new GLVideoMixerBlock(mixerSettings);

// first source
var source1 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("background.mp4"));
var glUpload1 = new GLUploadBlock();
pipeline.Connect(source1.VideoOutput, glUpload1.Input);
pipeline.Connect(glUpload1.Output, glMixer.Inputs[0]);

// second source (picture-in-picture)
var source2 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("overlay.mp4"));
var glUpload2 = new GLUploadBlock();
pipeline.Connect(source2.VideoOutput, glUpload2.Input);
pipeline.Connect(glUpload2.Output, glMixer.Inputs[1]);

var glDownload = new GLDownloadBlock();
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(glMixer.Output, glDownload.Input);
pipeline.Connect(glDownload.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### GL Video Renderer

The `GLVideoRendererBlock` displays the video stream on an `IVideoView` surface using hardware-accelerated OpenGL rendering. It is a terminal block (input only) and accepts both CPU and GL memory input. The renderer is configured with `GLVideoRendererSettings` (see [Video Renderer Settings](#video-renderer-settings-glvideorenderersettings) above).

#### Block info

Name: GLVideoRendererBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Video | 1 |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->GLVideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

// VideoView1 is your IVideoView control on the form/page
var glRenderer = new GLVideoRendererBlock(VideoView1);

pipeline.Connect(source.VideoOutput, glRenderer.Input);

await pipeline.StartAsync();
```

On Android, use the constructor overload that also takes the pipeline: `new GLVideoRendererBlock(pipeline, VideoView1)`.

#### Platforms

Windows, macOS, Linux, iOS, Android.

---END OF PAGE---


## Media Output Blocks in C# .NET - MP4, MKV, WebM, RTMP
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Outputs/
**Description:** Save video to MP4, AVI, MKV, WebM files or stream via RTMP and HLS using VisioForge Media Blocks SDK output blocks with C# code examples.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming
**API:** MP4OutputBlock, IAACEncoderSettings, MediaBlocksPipeline, AudioSource, MediaBlockPadMediaType

# Output Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Output blocks, also known as sinks, are responsible for writing media data to files, network streams, or other destinations. They are typically the last blocks in any media processing chain. VisioForge Media Blocks SDK .Net provides a comprehensive collection of output blocks for various formats and protocols.

This guide covers file output blocks like MP4, AVI, WebM, MKV, and network streaming blocks for protocols such as RTMP (used by YouTube and Facebook Live).

## AVI Output Block

The `AVIOutputBlock` is used to create AVI files. It combines video and audio encoders with a file sink to produce `.avi` files.

### Block info

Name: `AVIOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Video | various | H264 (default), other `IVideoEncoder` compatible encoders |
| Input Audio | various | AAC (default), MP3, other `IAudioEncoder` compatible encoders |

### Settings

The `AVIOutputBlock` is configured using `AVISinkSettings` along with settings for the chosen video and audio encoders (e.g., `IH264EncoderSettings` and `IAACEncoderSettings` or `MP3EncoderSettings`).

Key `AVISinkSettings` properties:

- `Filename` (string): The path to the output AVI file.

Constructors:

- `AVIOutputBlock(string filename)`: Uses default H264 video and AAC audio encoders.
- `AVIOutputBlock(AVISinkSettings sinkSettings, IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)`: Uses specified H264 video and AAC audio encoders.
- `AVIOutputBlock(AVISinkSettings sinkSettings, IH264EncoderSettings h264settings, MP3EncoderSettings mp3Settings)`: Uses specified H264 video and MP3 audio encoders.

### The sample pipeline

```
graph LR;
    VideoSource-->VideoEncoder;
    AudioSource-->AudioEncoder;
    VideoEncoder-->AVIOutputBlock;
    AudioEncoder-->AVIOutputBlock;
```

Or, if using a source that provides encoded data, or if the `AVIOutputBlock` handles internal encoders based on settings:

```
graph LR;
    UniversalSourceBlock--Video Output-->AVIOutputBlock;
    UniversalSourceBlock--Audio Output-->AVIOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create video source (example: virtual source)
var videoSource = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());

// create audio source (example: virtual source)
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// create AVI output block
// This constructor uses default H264 video and AAC audio encoders internally.
var aviOutput = new AVIOutputBlock("output.avi");

// Create inputs for the AVI output block
var videoInputPad = aviOutput.CreateNewInput(MediaBlockPadMediaType.Video);
var audioInputPad = aviOutput.CreateNewInput(MediaBlockPadMediaType.Audio);

// connect video path
pipeline.Connect(videoSource.Output, videoInputPad);

// connect audio path
pipeline.Connect(audioSource.Output, audioInputPad);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

The `AVIOutputBlock` internally manages encoder instances (like `H264Encoder` and `AACEncoder` or `MP3Encoder`) based on the provided settings. Ensure the necessary GStreamer plugins and SDK components for these encoders and the AVI muxer are available.

To check availability: `AVIOutputBlock.IsAvailable(IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)`

### Platforms

Primarily Windows. Availability on other platforms depends on GStreamer plugin support for AVI muxing and the chosen encoders.

## Facebook Live Output Block

The `FacebookLiveOutputBlock` is designed to stream video and audio to Facebook Live using RTMP. It internally uses H.264 video and AAC audio encoders.

### Block info

Name: `FacebookLiveOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Video | various | H.264 (internal) |
| Input Audio | various | AAC (internal) |

### Settings

The `FacebookLiveOutputBlock` is configured using `FacebookLiveSinkSettings`, `IH264EncoderSettings`, and `IAACEncoderSettings`.

Key `FacebookLiveSinkSettings` properties:

- `Url` (string): The RTMP URL provided by Facebook Live for streaming.

Constructor:

- `FacebookLiveOutputBlock(FacebookLiveSinkSettings sinkSettings, IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)`

### The sample pipeline

```
graph LR;
    VideoSource-->FacebookLiveOutputBlock;
    AudioSource-->FacebookLiveOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create video source (e.g., SystemVideoSourceBlock)
var videoSource = new SystemVideoSourceBlock(videoSourceSettings); // Assuming videoSourceSettings are configured

// create audio source (e.g., SystemAudioSourceBlock)
var audioSource = new SystemAudioSourceBlock(audioSourceSettings); // Assuming audioSourceSettings are configured

// configure Facebook Live sink settings (ctor takes the stream key only — the SDK builds the RTMP URL)
var fbSinkSettings = new FacebookLiveSinkSettings("your-facebook-stream-key");

// configure H.264 encoder settings (use defaults or customize)
var h264Settings = H264EncoderBlock.GetDefaultSettings();
h264Settings.Bitrate = 4000000; // Example: 4 Mbps

// configure AAC encoder settings (use defaults or customize)
var aacSettings = AACEncoderBlock.GetDefaultSettings();
aacSettings.Bitrate = 128000; // Example: 128 Kbps

// create Facebook Live output block
var facebookOutput = new FacebookLiveOutputBlock(fbSinkSettings, h264Settings, aacSettings);

// Create inputs for the Facebook Live output block
var videoInputPad = facebookOutput.CreateNewInput(MediaBlockPadMediaType.Video);
var audioInputPad = facebookOutput.CreateNewInput(MediaBlockPadMediaType.Audio);

// connect video path
pipeline.Connect(videoSource.Output, videoInputPad);

// connect audio path
pipeline.Connect(audioSource.Output, audioInputPad);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

This block encapsulates the necessary H.264 and AAC encoders and the RTMP sink (`FacebookLiveSink`). Ensure that the `FacebookLiveSink`, `H264Encoder`, and `AACEncoder` are available. `FacebookLiveOutputBlock.IsAvailable()` can be used to check this (though the provided source shows `FacebookLiveSink.IsAvailable()`).

### Platforms

Windows, macOS, Linux, iOS, Android (Platform availability depends on GStreamer RTMP support and encoder availability).

## FLAC Output Block

The `FLACOutputBlock` is used for creating FLAC (Free Lossless Audio Codec) audio files. It takes uncompressed audio data, encodes it using a FLAC encoder, and saves it to a `.flac` file.

### Block info

Name: `FLACOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Audio | uncompressed audio | FLAC (internal) |

### Settings

The `FLACOutputBlock` is configured with a filename and `FLACEncoderSettings`.

Key `FLACEncoderSettings` properties (refer to `FLACEncoderSettings` documentation for full details):

- Quality level, compression level, etc.

Constructor:

- `FLACOutputBlock(string filename, FLACEncoderSettings settings)`

### The sample pipeline

```
graph LR;
    AudioSource-->FLACOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create audio source (example: virtual audio source)
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// configure FLAC encoder settings
var flacSettings = new FLACEncoderSettings();
// flacSettings.Quality = 8; // Example: Set quality level (0-8, default is 5)

// create FLAC output block
var flacOutput = new FLACOutputBlock("output.flac", flacSettings);

// connect audio path
pipeline.Connect(audioSource.Output, flacOutput.Input);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

This block combines a `FLACEncoder` and a `FileSink` internally. To check if the block and its dependencies are available: `FLACOutputBlock.IsAvailable()` (This checks for `FLACEncoder` and `FileSink` availability).

### Platforms

Windows, macOS, Linux, iOS, Android (Platform availability depends on GStreamer FLAC encoder and file sink support).

## M4A Output Block

The `M4AOutputBlock` creates M4A (MPEG-4 Audio) files, commonly used for AAC encoded audio. It uses an AAC audio encoder and an MP4 sink to produce `.m4a` files.

### Block info

Name: `M4AOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Audio | various | AAC (internal) |

### Settings

The `M4AOutputBlock` is configured using `MP4SinkSettings` and `IAACEncoderSettings`.

Key `MP4SinkSettings` properties:

- `Filename` (string): The path to the output M4A file.

Key `IAACEncoderSettings` properties (refer to `AACEncoderSettings` for details):

- Bitrate, profile, etc.

Constructors:

- `M4AOutputBlock(string filename)`: Uses default AAC encoder settings.
- `M4AOutputBlock(MP4SinkSettings sinkSettings, IAACEncoderSettings aacSettings)`: Uses specified AAC encoder settings.

### The sample pipeline

```
graph LR;
    AudioSource-->M4AOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create audio source (example: virtual audio source)
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// configure M4A output block with default AAC settings
var m4aOutput = new M4AOutputBlock("output.m4a");

// Or, with custom AAC settings:
// var sinkSettings = new MP4SinkSettings("output.m4a");
// var aacSettings = AACEncoderBlock.GetDefaultSettings();
// aacSettings.Bitrate = 192000; // Example: 192 Kbps
// var m4aOutput = new M4AOutputBlock(sinkSettings, aacSettings);

// Create input for the M4A output block
var audioInputPad = m4aOutput.CreateNewInput(MediaBlockPadMediaType.Audio);

// connect audio path
pipeline.Connect(audioSource.Output, audioInputPad);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

The `M4AOutputBlock` internally manages an `AACEncoder` and an `MP4Sink`. To check availability: `M4AOutputBlock.IsAvailable(IAACEncoderSettings aacSettings)`

### Platforms

Windows, macOS, Linux, iOS, Android (Platform availability depends on GStreamer MP4 muxer and AAC encoder support).

## MKV Output Block

The `MKVOutputBlock` is used to create Matroska (MKV) files. MKV is a flexible container format that can hold various video, audio, and subtitle streams. This block combines specified video and audio encoders with an MKV sink.

### Block info

Name: `MKVOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Video | various | `IVideoEncoder` (e.g., H.264, HEVC, VPX, AV1) |
| Input Audio | various | `IAudioEncoder` (e.g., AAC, MP3, Vorbis, Opus, Speex) |

### Settings

The `MKVOutputBlock` is configured using `MKVSinkSettings`, along with settings for the chosen video (`IVideoEncoder`) and audio (`IAudioEncoder`) encoders.

Key `MKVSinkSettings` properties:

- `Filename` (string): The path to the output MKV file.

Constructors:

- `MKVOutputBlock(MKVSinkSettings sinkSettings, IVideoEncoder videoSettings, IAudioEncoder audioSettings)`

### The sample pipeline

```
graph LR;
    VideoSource-->VideoEncoder;
    AudioSource-->AudioEncoder;
    VideoEncoder-->MKVOutputBlock;
    AudioEncoder-->MKVOutputBlock;
```

More directly, if `MKVOutputBlock` handles encoder instantiation internally:

```
graph LR;
    VideoSource-->MKVOutputBlock;
    AudioSource-->MKVOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create video source (example: virtual source)
var videoSource = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());

// create audio source (example: virtual source)
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// configure MKV sink settings
var mkvSinkSettings = new MKVSinkSettings("output.mkv");

// configure video encoder (example: H.264)
var h264Settings = H264EncoderBlock.GetDefaultSettings();
// h264Settings.Bitrate = 5000000; // Example

// configure audio encoder (example: AAC)
var aacSettings = AACEncoderBlock.GetDefaultSettings();
// aacSettings.Bitrate = 128000; // Example

// create MKV output block
var mkvOutput = new MKVOutputBlock(mkvSinkSettings, h264Settings, aacSettings);

// Create inputs for the MKV output block
var videoInputPad = mkvOutput.CreateNewInput(MediaBlockPadMediaType.Video);
var audioInputPad = mkvOutput.CreateNewInput(MediaBlockPadMediaType.Audio);

// connect video path
pipeline.Connect(videoSource.Output, videoInputPad);

// connect audio path
pipeline.Connect(audioSource.Output, audioInputPad);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

The `MKVOutputBlock` internally manages the specified video and audio encoder instances (e.g., `H264Encoder`, `HEVCEncoder`, `AACEncoder`, `VorbisEncoder`, etc.) and an `MKVSink`. Supported video encoders include H.264, HEVC, VPX (VP8/VP9), AV1. Supported audio encoders include AAC, MP3, Vorbis, Opus, Speex.

To check availability (example with H.264 and AAC): `MKVOutputBlock.IsAvailable(IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)`

### Platforms

Windows, macOS, Linux, iOS, Android (Platform availability depends on GStreamer MKV muxer and chosen encoder support).

## MP3 Output Block

The `MP3OutputBlock` is used for creating MP3 audio files. It encodes uncompressed audio data using an MP3 encoder and saves it to an `.mp3` file.

### Block info

Name: `MP3OutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Audio | uncompressed audio | MP3 (internal) |

### Settings

The `MP3OutputBlock` is configured with a filename and `MP3EncoderSettings`.

Key `MP3EncoderSettings` properties (refer to `MP3EncoderSettings` documentation for full details):

- Bitrate, quality, channel mode, etc.

Constructor:

- `MP3OutputBlock(string filename, MP3EncoderSettings mp3Settings)`

### The sample pipeline

```
graph LR;
    AudioSource-->MP3OutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create audio source (example: virtual audio source)
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// configure MP3 encoder settings
var mp3Settings = new MP3EncoderSettings();
// mp3Settings.Bitrate = 192;                               // bitrate in kbps
// mp3Settings.Quality = 2.0f;                              // 0.0 (best) … 10.0 (worst)
// mp3Settings.EncodingEngineQuality = MP3EncodingQuality.High; // Fast / Standard / High
// mp3Settings.RateControl = MP3EncoderRateControl.CBR;     // CBR / VBR / ABR

// create MP3 output block
var mp3Output = new MP3OutputBlock("output.mp3", mp3Settings);

// connect audio path
pipeline.Connect(audioSource.Output, mp3Output.Input);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

This block combines an `MP3Encoder` and a `FileSink` internally. To check if the block and its dependencies are available: `MP3OutputBlock.IsAvailable()` (This checks for `MP3Encoder` and `FileSink` availability).

### Platforms

Windows, macOS, Linux, iOS, Android (Platform availability depends on GStreamer MP3 encoder (e.g., LAME) and file sink support).

## MP4 Output Block

The `MP4OutputBlock` is used for creating MP4 files. It can combine various video and audio encoders with an MP4 sink to produce `.mp4` files.

### Block info

Name: `MP4OutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Video | various | `IVideoEncoder` (e.g., H.264, HEVC) |
| Input Audio | various | `IAudioEncoder` (e.g., AAC, MP3) |

### Settings

The `MP4OutputBlock` is configured using `MP4SinkSettings`, along with settings for the chosen video (`IVideoEncoder`, typically `IH264EncoderSettings` or `IHEVCEncoderSettings`) and audio (`IAudioEncoder`, typically `IAACEncoderSettings` or `MP3EncoderSettings`) encoders.

Key `MP4SinkSettings` properties:

- `Filename` (string): The path to the output MP4 file.
- Can also be `MP4SplitSinkSettings` for recording in segments.

Constructors:

- `MP4OutputBlock(string filename)`: Uses default H.264 video and AAC audio encoders.
- `MP4OutputBlock(MP4SinkSettings sinkSettings, IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)`
- `MP4OutputBlock(MP4SinkSettings sinkSettings, IH264EncoderSettings h264settings, MP3EncoderSettings mp3Settings)`
- `MP4OutputBlock(MP4SinkSettings sinkSettings, IHEVCEncoderSettings hevcSettings, IAACEncoderSettings aacSettings)`
- `MP4OutputBlock(MP4SinkSettings sinkSettings, IHEVCEncoderSettings hevcSettings, MP3EncoderSettings mp3Settings)`

### Segment events

When `MP4OutputBlock` is configured with `MP4SplitSinkSettings`, it raises segment-lifecycle events: `OnSegmentCreated` and `OnSegmentClosed` (notified when a segment file is opened and finished/closed), and `OnSegmentFileNameRequested` (supply a custom per-segment file name). The same events are available on `MP4SinkBlock` and `MPEGTSSinkBlock`. See [MP4 output](../../general/output-formats/mp4/) for details and a custom-naming / rename-on-close example.

### The sample pipeline

```
graph LR;
    VideoSource-->VideoEncoder;
    AudioSource-->AudioEncoder;
    VideoEncoder-->MP4OutputBlock;
    AudioEncoder-->MP4OutputBlock;
```

If `MP4OutputBlock` uses its default internal encoders:

```
graph LR;
    VideoSource-->MP4OutputBlock;
    AudioSource-->MP4OutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create video source (example: virtual source)
var videoSource = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());

// create audio source (example: virtual source)
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// create MP4 output block with default H.264 video and AAC audio encoders
var mp4Output = new MP4OutputBlock("output.mp4");

// Or, with custom H.264 and AAC settings:
// var sinkSettings = new MP4SinkSettings("output.mp4");
// var h264Settings = H264EncoderBlock.GetDefaultSettings();
// h264Settings.Bitrate = 8000000; // Example: 8 Mbps
// var aacSettings = AACEncoderBlock.GetDefaultSettings();
// aacSettings.Bitrate = 192000; // Example: 192 Kbps
// var mp4Output = new MP4OutputBlock(sinkSettings, h264Settings, aacSettings);

// Create inputs for the MP4 output block
var videoInputPad = mp4Output.CreateNewInput(MediaBlockPadMediaType.Video);
var audioInputPad = mp4Output.CreateNewInput(MediaBlockPadMediaType.Audio);

// connect video path
pipeline.Connect(videoSource.Output, videoInputPad);

// connect audio path
pipeline.Connect(audioSource.Output, audioInputPad);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

The `MP4OutputBlock` internally manages video (e.g., `H264Encoder`, `HEVCEncoder`) and audio (e.g., `AACEncoder`, `MP3Encoder`) encoder instances along with an `MP4Sink`. To check availability (example with H.264 and AAC): `MP4OutputBlock.IsAvailable(IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)`

### Platforms

Windows, macOS, Linux, iOS, Android (Platform availability depends on GStreamer MP4 muxer and chosen encoder support).

## OGG Opus Output Block

The `OGGOpusOutputBlock` is used for creating Ogg Opus audio files. It encodes uncompressed audio data using an Opus encoder and multiplexes it into an Ogg container, saving to an `.opus` or `.ogg` file.

### Block info

Name: `OGGOpusOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Audio | uncompressed audio | Opus (internal) |

### Settings

The `OGGOpusOutputBlock` is configured with a filename and `OPUSEncoderSettings`.

Key `OPUSEncoderSettings` properties (refer to `OPUSEncoderSettings` documentation for full details):

- Bitrate, complexity, frame duration, audio type (voice/music), etc.

Constructor:

- `OGGOpusOutputBlock(string filename, OPUSEncoderSettings settings)`

### The sample pipeline

```
graph LR;
    AudioSource-->OGGOpusOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create audio source (example: virtual audio source)
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// configure Opus encoder settings
var opusSettings = new OPUSEncoderSettings();
// opusSettings.Bitrate = 64000; // Example: Set bitrate to 64 kbps
// opusSettings.AudioType = OpusEncoderAudioType.Music; // Example

// create OGG Opus output block
var oggOpusOutput = new OGGOpusOutputBlock("output.opus", opusSettings);

// connect audio path
pipeline.Connect(audioSource.Output, oggOpusOutput.Input);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

This block combines an `OPUSEncoder` and an `OGGSink` internally. To check if the block and its dependencies are available: `OGGOpusOutputBlock.IsAvailable()` (This checks for `OGGSink`, `OPUSEncoder`, and `FileSink` - though `FileSink` might be implicitly part of `OGGSink` logic for file output).

### Platforms

Windows, macOS, Linux, iOS, Android (Platform availability depends on GStreamer Ogg muxer and Opus encoder support).

## OGG Speex Output Block

The `OGGSpeexOutputBlock` is used for creating Ogg Speex audio files, typically for voice. It encodes uncompressed audio data using a Speex encoder, multiplexes it into an Ogg container, and saves to an `.spx` or `.ogg` file.

### Block info

Name: `OGGSpeexOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Audio | uncompressed audio | Speex (internal) |

### Settings

The `OGGSpeexOutputBlock` is configured with a filename and `SpeexEncoderSettings`.

Key `SpeexEncoderSettings` properties (refer to `SpeexEncoderSettings` documentation for full details):

- Quality, complexity, encoding mode (VBR/ABR/CBR), etc.

Constructor:

- `OGGSpeexOutputBlock(string filename, SpeexEncoderSettings settings)`

### The sample pipeline

```
graph LR;
    AudioSource-->OGGSpeexOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create audio source (example: virtual audio source)
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// configure Speex encoder settings
var speexSettings = new SpeexEncoderSettings();
// speexSettings.Quality = 8; // Example: Set quality (0-10)
// speexSettings.Mode = SpeexEncoderMode.VBR; // Example: Use Variable Bitrate

// create OGG Speex output block
var oggSpeexOutput = new OGGSpeexOutputBlock("output.spx", speexSettings);

// connect audio path
pipeline.Connect(audioSource.Output, oggSpeexOutput.Input);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

This block combines a `SpeexEncoder` and an `OGGSink` internally. To check if the block and its dependencies are available: `OGGSpeexOutputBlock.IsAvailable()` (This checks for `OGGSink`, `SpeexEncoder`, and `FileSink` - `FileSink` might be implicit to `OGGSink` for file output).

### Platforms

Windows, macOS, Linux, iOS, Android (Platform availability depends on GStreamer Ogg muxer and Speex encoder support).

## OGG Vorbis Output Block

The `OGGVorbisOutputBlock` is used for creating Ogg Vorbis audio files. It encodes uncompressed audio data using a Vorbis encoder, multiplexes it into an Ogg container, and saves to an `.ogg` file.

### Block info

Name: `OGGVorbisOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Audio | uncompressed audio | Vorbis (internal) |

### Settings

The `OGGVorbisOutputBlock` is configured with a filename and `VorbisEncoderSettings`.

Key `VorbisEncoderSettings` properties (refer to `VorbisEncoderSettings` documentation for full details):

- Quality, bitrate, managed/unmanaged bitrate settings, etc.

Constructor:

- `OGGVorbisOutputBlock(string filename, VorbisEncoderSettings settings)`

### The sample pipeline

```
graph LR;
    AudioSource-->OGGVorbisOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create audio source (example: virtual audio source)
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// configure Vorbis encoder settings
var vorbisSettings = new VorbisEncoderSettings();
// vorbisSettings.Quality = 0.8f; // Example: Set quality (0.0 to 1.0)
// vorbisSettings.Bitrate = 128000; // Example if not using quality based encoding

// create OGG Vorbis output block
var oggVorbisOutput = new OGGVorbisOutputBlock("output.ogg", vorbisSettings);

// connect audio path
pipeline.Connect(audioSource.Output, oggVorbisOutput.Input);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

This block combines a `VorbisEncoder` and an `OGGSink` internally. To check if the block and its dependencies are available: `OGGVorbisOutputBlock.IsAvailable()` (This checks for `OGGSink`, `VorbisEncoder`, and `FileSink` - `FileSink` might be implicit to `OGGSink` for file output).

### Platforms

Windows, macOS, Linux, iOS, Android (Platform availability depends on GStreamer Ogg muxer and Vorbis encoder support).

## WebM Output Block

The `WebMOutputBlock` is used for creating WebM files, typically containing VP8 or VP9 video and Vorbis audio. It combines a VPX video encoder and a Vorbis audio encoder with a WebM sink.

### Block info

Name: `WebMOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Video | various | VPX (VP8/VP9 - internal) |
| Input Audio | various | Vorbis (internal) |

### Settings

The `WebMOutputBlock` is configured using `WebMSinkSettings`, `IVPXEncoderSettings` (for VP8 or VP9), and `VorbisEncoderSettings`.

Key `WebMSinkSettings` properties:

- `Filename` (string): The path to the output WebM file.

Key `IVPXEncoderSettings` properties (refer to `VPXEncoderSettings` for details):

- Bitrate, quality, speed, threads, etc.

Key `VorbisEncoderSettings` properties:

- Quality, bitrate, etc.

Constructor:

- `WebMOutputBlock(WebMSinkSettings sinkSettings, IVPXEncoderSettings videoEncoderSettings, VorbisEncoderSettings vorbisSettings)`

### The sample pipeline

```
graph LR;
    VideoSource-->WebMOutputBlock;
    AudioSource-->WebMOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create video source (example: virtual source)
var videoSource = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());

// create audio source (example: virtual source)
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// configure WebM sink settings
var webmSinkSettings = new WebMSinkSettings("output.webm");

// configure VP9 encoder settings. VPXEncoderSettings is an abstract base — instantiate
// the concrete VP9EncoderSettings (or VP8EncoderSettings). Encoder type is implicit per subclass.
var vp9Settings = new VP9EncoderSettings
{
    RateControl = VPXRateControl.CBR,      // CBR / VBR / CQ / ...
    TargetBitrate = 2000,                  // kbit/s
    Deadline = 1,                          // 1 = realtime; higher values = slower/better quality
};

// configure Vorbis encoder settings
var vorbisSettings = new VorbisEncoderSettings();
// vorbisSettings.Quality = 0.7f; // Example: Set quality

// create WebM output block
var webmOutput = new WebMOutputBlock(webmSinkSettings, vp9Settings, vorbisSettings);

// Create inputs for the WebM output block
var videoInputPad = webmOutput.CreateNewInput(MediaBlockPadMediaType.Video);
var audioInputPad = webmOutput.CreateNewInput(MediaBlockPadMediaType.Audio);

// connect video path
pipeline.Connect(videoSource.Output, videoInputPad);

// connect audio path
pipeline.Connect(audioSource.Output, audioInputPad);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

The `WebMOutputBlock` internally manages a `VPXEncoder` (for VP8/VP9), a `VorbisEncoder`, and a `WebMSink`. To check availability: `WebMOutputBlock.IsAvailable(IVPXEncoderSettings videoEncoderSettings)`

### Platforms

Windows, macOS, Linux, iOS, Android (Platform availability depends on GStreamer WebM muxer, VPX encoder, and Vorbis encoder support).

## Separate Output Block

The `SeparateOutputBlock` provides a flexible way to configure custom output pipelines, allowing you to specify distinct video and audio encoders, processors, and a final writer/sink. It uses bridge sources (`BridgeVideoSourceBlock`, `BridgeAudioSourceBlock`) to tap into the main pipeline, enabling recording independently from preview or other processing chains.

### Block info

Name: `SeparateOutputBlock`.

This block itself doesn't have direct input pads in the traditional sense; it orchestrates a sub-pipeline.

### Settings

The `SeparateOutputBlock` is configured using the `SeparateOutput` settings object.

Key `SeparateOutput` properties:

- `Sink` (`MediaBlock`): The final sink/muxer for the output (e.g., `MP4OutputBlock`, `FileSink`). Must implement `IMediaBlockDynamicInputs` if separate encoders are used, or `IMediaBlockSinkAllInOne` if it handles encoding internally.
- `VideoEncoder` (`MediaBlock`): An optional video encoder block.
- `AudioEncoder` (`MediaBlock`): An optional audio encoder block.
- `VideoProcessor` (`MediaBlock`): An optional video processing block to insert before the video encoder.
- `AudioProcessor` (`MediaBlock`): An optional audio processing block to insert before the audio encoder.
- `Writer` (`MediaBlock`): An optional writer block that takes the output of the `Sink` (e.g., for custom file writing or network streaming logic if the `Sink` is just a muxer).
- `GetFilename()`: Method to retrieve the configured output filename if applicable.

Constructor:

- `SeparateOutputBlock(MediaBlocksPipeline pipeline, SeparateOutput settings, BridgeVideoSourceSettings bridgeVideoSourceSettings, BridgeAudioSourceSettings bridgeAudioSourceSettings)`

### The conceptual pipeline

This block creates an independent processing branch. For video:

```
graph LR;
    MainVideoPath --> BridgeVideoSink;
    BridgeVideoSourceBlock --> OptionalVideoProcessor --> VideoEncoder --> SinkOrWriter;
```

For audio:

```
graph LR;
    MainAudioPath --> BridgeAudioSink;
    BridgeAudioSourceBlock --> OptionalAudioProcessor --> AudioEncoder --> SinkOrWriter;
```

### Sample code

```
// Assuming 'pipeline' is your main MediaBlocksPipeline
// Assuming 'mainVideoSourceOutputPad' and 'mainAudioSourceOutputPad' are outputs from your main sources

// 1. Configure Bridge Sinks in your main pipeline
// BridgeVideoSinkSettings/BridgeAudioSinkSettings require a channel name + format info (VideoFrameInfoX / AudioInfoX).
var videoInfo = new VideoFrameInfoX(1920, 1080, new VideoFrameRate(30));
var audioInfo = new AudioInfoX(AudioFormatX.S16LE, 48000, 2);

var bridgeVideoSinkSettings = new BridgeVideoSinkSettings("sep_video_bridge", videoInfo);
var bridgeVideoSink = new BridgeVideoSinkBlock(bridgeVideoSinkSettings);
pipeline.Connect(mainVideoSourceOutputPad, bridgeVideoSink.Input);

var bridgeAudioSinkSettings = new BridgeAudioSinkSettings("sep_audio_bridge", audioInfo);
var bridgeAudioSink = new BridgeAudioSinkBlock(bridgeAudioSinkSettings);
pipeline.Connect(mainAudioSourceOutputPad, bridgeAudioSink.Input);

// 2. Configure Bridge Sources for the SeparateOutputBlock's sub-pipeline (must use the same channel name + matching format info as the sink)
var bridgeVideoSourceSettings = new BridgeVideoSourceSettings("sep_video_bridge", videoInfo);
var bridgeAudioSourceSettings = new BridgeAudioSourceSettings("sep_audio_bridge", audioInfo);

// 3. Configure encoders and sink for the SeparateOutput
var h264Settings = H264EncoderBlock.GetDefaultSettings();
var videoEncoder = new H264EncoderBlock(h264Settings);

var aacSettings = AACEncoderBlock.GetDefaultSettings();
var audioEncoder = new AACEncoderBlock(aacSettings);

var mp4SinkSettings = new MP4SinkSettings("separate_output.mp4");
var mp4Sink = new MP4OutputBlock(mp4SinkSettings, h264Settings, aacSettings); // Using MP4OutputBlock which handles muxing.
                                                                            // Alternatively, use a raw MP4Sink and connect encoders to it.

// 4. Configure SeparateOutput settings. SeparateOutput has a parameterless ctor — populate
// the Sink / VideoEncoder / AudioEncoder properties rather than passing them to the constructor.
var separateOutputSettings = new SeparateOutput
{
    Sink = mp4Sink,
    VideoEncoder = videoEncoder,
    AudioEncoder = audioEncoder,
};

// 5. Create the SeparateOutputBlock (this will internally connect its components)
var separateOutput = new SeparateOutputBlock(pipeline, separateOutputSettings, bridgeVideoSourceSettings, bridgeAudioSourceSettings);

// 6. Build the sources, encoders, and sink used by SeparateOutputBlock
// Note: Building these might be handled by the pipeline if they are added to it,
// or might need to be done explicitly if they are part of a sub-graph not directly in the main pipeline's block list.
// The SeparateOutputBlock's Build() method will handle building its internal sources (_videoSource, _audioSource)
// and the provided encoders/sink if they haven't been built.

// pipeline.Add(bridgeVideoSink);
// pipeline.Add(bridgeAudioSink);
// pipeline.Add(separateOutput); // Add the orchestrator block

// Start main pipeline
// await pipeline.StartAsync(); // This will also start the separate output processing via bridges

// To change filename later:
// separateOutput.SetFilenameOrURL("new_separate_output.mp4");
```

### Remarks

The `SeparateOutputBlock` itself is more of an orchestrator for a sub-pipeline that's fed by bridge sinks/sources from the main pipeline. It allows for complex recording or streaming configurations that can be started/stopped or modified independently to some extent.

The `VideoEncoder`, `AudioEncoder`, `Sink`, and `Writer` components must be built correctly. The `SeparateOutputBlock.Build()` method attempts to build these components.

### Platforms

Depends on the components used within the `SeparateOutput` configuration (encoders, sinks, processors). Generally cross-platform if GStreamer elements are available.

## WMV Output Block

The `WMVOutputBlock` is used for creating Windows Media Video (WMV) files. It uses WMV video (`WMVEncoder`) and WMA audio (`WMAEncoder`) encoders with an ASF (Advanced Systems Format) sink to produce `.wmv` files.

### Block info

Name: `WMVOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Video | various | WMV (internal) |
| Input Audio | various | WMA (internal) |

### Settings

The `WMVOutputBlock` is configured using `ASFSinkSettings`, `WMVEncoderSettings`, and `WMAEncoderSettings`.

Key `ASFSinkSettings` properties:

- `Filename` (string): The path to the output WMV file.

Key `WMVEncoderSettings` properties (refer to `WMVEncoderSettings` documentation):

- Bitrate, GOP size, quality, etc.

Key `WMAEncoderSettings` properties (refer to `WMAEncoderSettings` documentation):

- Bitrate, WMA version, etc.

Constructors:

- `WMVOutputBlock(string filename)`: Uses default WMV video and WMA audio encoder settings.
- `WMVOutputBlock(ASFSinkSettings sinkSettings, WMVEncoderSettings videoSettings, WMAEncoderSettings audioSettings)`: Uses specified encoder settings.

### The sample pipeline

```
graph LR;
    VideoSource-->WMVOutputBlock;
    AudioSource-->WMVOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create video source (example: virtual source)
var videoSource = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());

// create audio source (example: virtual source)
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// create WMV output block with default settings
var wmvOutput = new WMVOutputBlock("output.wmv");

// Or, with custom settings:
// var asfSinkSettings = new ASFSinkSettings("output.wmv");
// var wmvEncSettings = WMVEncoderBlock.GetDefaultSettings();
// wmvEncSettings.Bitrate = 3000000; // Example: 3 Mbps
// var wmaEncSettings = WMAEncoderBlock.GetDefaultSettings();
// wmaEncSettings.Bitrate = 160000; // Example: 160 Kbps
// var wmvOutput = new WMVOutputBlock(asfSinkSettings, wmvEncSettings, wmaEncSettings);

// Create inputs for the WMV output block
var videoInputPad = wmvOutput.CreateNewInput(MediaBlockPadMediaType.Video);
var audioInputPad = wmvOutput.CreateNewInput(MediaBlockPadMediaType.Audio);

// connect video path
pipeline.Connect(videoSource.Output, videoInputPad);

// connect audio path
pipeline.Connect(audioSource.Output, audioInputPad);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

The `WMVOutputBlock` internally manages `WMVEncoder`, `WMAEncoder`, and `ASFSink`. To check availability: `WMVOutputBlock.IsAvailable()`

### Platforms

Primarily Windows. Availability on other platforms depends on GStreamer plugin support for ASF muxing, WMV, and WMA encoders (which may be limited outside of Windows).

## YouTube Output Block

The `YouTubeOutputBlock` is designed for streaming video and audio to YouTube Live using RTMP. It internally utilizes H.264 video and AAC audio encoders.

### Block info

Name: `YouTubeOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Video | various | H.264 (internal) |
| Input Audio | various | AAC (internal) |

### Settings

The `YouTubeOutputBlock` is configured using `YouTubeSinkSettings`, `IH264EncoderSettings`, and `IAACEncoderSettings`.

Key `YouTubeSinkSettings` properties:

- `Url` (string): The RTMP URL provided by YouTube Live for streaming (e.g., "rtmp://a.rtmp.youtube.com/live2/YOUR-STREAM-KEY").

Constructor:

- `YouTubeOutputBlock(YouTubeSinkSettings sinkSettings, IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)`

### The sample pipeline

```
graph LR;
    VideoSource-->YouTubeOutputBlock;
    AudioSource-->YouTubeOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create video source (e.g., SystemVideoSourceBlock)
var videoSource = new SystemVideoSourceBlock(videoSourceSettings); // Assuming videoSourceSettings are configured

// create audio source (e.g., SystemAudioSourceBlock)
var audioSource = new SystemAudioSourceBlock(audioSourceSettings); // Assuming audioSourceSettings are configured

// configure YouTube sink settings (ctor takes the stream key only — the SDK builds the RTMP URL)
var ytSinkSettings = new YouTubeSinkSettings("YOUR-STREAM-KEY");

// configure H.264 encoder settings (use defaults or customize per YouTube recommendations)
var h264Settings = H264EncoderBlock.GetDefaultSettings();
// h264Settings.Bitrate = 6000000; // Example: 6 Mbps for 1080p
// h264Settings.UsagePreset = H264UsagePreset.None; // Adjust based on performance/quality needs

// configure AAC encoder settings (use defaults or customize per YouTube recommendations)
var aacSettings = AACEncoderBlock.GetDefaultSettings();
// aacSettings.Bitrate = 128000; // Example: 128 Kbps stereo

// create YouTube output block
var youTubeOutput = new YouTubeOutputBlock(ytSinkSettings, h264Settings, aacSettings);

// Create inputs for the YouTube output block
var videoInputPad = youTubeOutput.CreateNewInput(MediaBlockPadMediaType.Video);
var audioInputPad = youTubeOutput.CreateNewInput(MediaBlockPadMediaType.Audio);

// connect video path
pipeline.Connect(videoSource.Output, videoInputPad);

// connect audio path
pipeline.Connect(audioSource.Output, audioInputPad);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

This block encapsulates the H.264 and AAC encoders and the RTMP sink (`YouTubeSink`). Ensure that the `YouTubeSink`, `H264Encoder`, and `AACEncoder` are available. `YouTubeOutputBlock.IsAvailable(IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)` can be used to check this. It's crucial to configure encoder settings (bitrate, resolution, frame rate) according to YouTube's recommended settings for live streaming to ensure optimal quality and compatibility.

### Platforms

Windows, macOS, Linux, iOS, Android (Platform availability depends on GStreamer RTMP support and H.264/AAC encoder availability).

## Enhanced FLV Output Block

The `EFLVOutputBlock` creates Enhanced FLV (Flash Video) files with Enhanced RTMP (V2) support. Unlike the classic FLV container, the Enhanced FLV muxer signals codecs through FOURCC values, so it can carry modern video codecs such as H.265/HEVC alongside H.264, and supports multiple video and audio tracks. It combines per-track video and audio encoders with an Enhanced FLV sink to produce `.flv` files.

### Block info

Name: `EFLVOutputBlock`.

| Pin direction | Media type | Expected Encoders |
| --- | --- | --- |
| Input Video | various | H.264 (`IH264EncoderSettings`), HEVC (`IHEVCEncoderSettings`) |
| Input Audio | various | AAC (`IAACEncoderSettings`), MP3 (`MP3EncoderSettings`) |

Input pads are dynamic. Call `CreateNewInput(MediaBlockPadMediaType.Video)` and `CreateNewInput(MediaBlockPadMediaType.Audio)` to add tracks; each input pad gets its own encoder instance built from the supplied encoder settings.

### Settings

The `EFLVOutputBlock` is configured using `EFLVSinkSettings` along with settings for the chosen video and audio encoders.

Key `EFLVSinkSettings` properties:

- `Filename` (string): The path to the output Enhanced FLV file. Defaults to `output.flv`.

`EFLVSinkSettings` constructors:

- `EFLVSinkSettings()`: Uses the default filename.
- `EFLVSinkSettings(string filename)`: Sets the output filename.

`EFLVOutputBlock` constructor:

- `EFLVOutputBlock(EFLVSinkSettings sinkSettings, IVideoEncoder videoSettings, IAudioEncoder audioSettings)`

### The sample pipeline

```
graph LR;
    VideoSource-->VideoEncoder;
    AudioSource-->AudioEncoder;
    VideoEncoder-->EFLVOutputBlock;
    AudioEncoder-->EFLVOutputBlock;
```

### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create sources
var videoSource = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());
var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());

// configure encoders (HEVC video + AAC audio for Enhanced FLV)
var videoSettings = HEVCEncoderBlock.GetDefaultSettings();
var audioSettings = new VOAACEncoderSettings();

// create Enhanced FLV output block
var sinkSettings = new EFLVSinkSettings("output.flv");
var eflvOutput = new EFLVOutputBlock(sinkSettings, videoSettings, audioSettings);

// create dynamic inputs for the Enhanced FLV output block
var videoInputPad = eflvOutput.CreateNewInput(MediaBlockPadMediaType.Video);
var audioInputPad = eflvOutput.CreateNewInput(MediaBlockPadMediaType.Audio);

// connect
pipeline.Connect(videoSource.Output, videoInputPad);
pipeline.Connect(audioSource.Output, audioInputPad);

// start pipeline
await pipeline.StartAsync();

// ... later, to stop ...
// await pipeline.StopAsync();
```

### Remarks

The `EFLVOutputBlock` manages its own encoder instances internally based on the provided `IVideoEncoder` / `IAudioEncoder` settings (H.264 or HEVC for video; AAC or MP3 for audio). The output destination can be changed at runtime with `SetFilenameOrURL(string)` and queried with `GetFilenameOrURL()`.

To check availability: `EFLVOutputBlock.IsAvailable(IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)`

### Platforms

Windows, macOS, Linux, iOS, Android (depends on the availability of the Enhanced FLV muxer and the chosen encoder plugins).

## Pre-Event Recording Block

The `PreEventRecordingBlock` implements circular buffer (pre-event) recording. It continuously buffers encoded video and audio in memory and writes event clips to disk on trigger, including footage from before the event occurred.

For full documentation, settings, state machine, and code samples, see the dedicated [Pre-Event Recording Block](pre-event-recording/) page.

## Pre-Event Separate Output Block

The `PreEventSeparateOutputBlock` combines the independent sub-pipeline pattern of the [Separate Output Block](#separate-output-block) with [pre-event (circular buffer) recording](pre-event-recording/). Instead of routing the encoded streams into a muxer + file sink, it routes them into a `PreEventRecordingBlock`, so the pre-event branch records event clips (including pre-trigger footage) independently from the main preview/processing chain. It taps the main pipeline through bridge sources (`BridgeVideoSourceBlock`, `BridgeAudioSourceBlock`).

### Block info

Name: `PreEventSeparateOutputBlock`.

This block is a sink that orchestrates a sub-pipeline; it has no direct input pads. Video and audio enter through the bridge sources and leave through the supplied `PreEventRecordingBlock`.

### Settings

The block reuses the `SeparateOutput` settings object to describe the encoding branch.

Key `SeparateOutput` properties used by this block:

- `VideoEncoder` (`MediaBlock`): An optional video encoder block. When set, a video branch is wired from the bridge video source into the pre-event block.
- `AudioEncoder` (`MediaBlock`): An optional audio encoder block. When set, an audio branch is wired from the bridge audio source into the pre-event block.
- `VideoProcessor` (`MediaBlock`): An optional video processing block inserted before the video encoder.
- `AudioProcessor` (`MediaBlock`): An optional audio processing block inserted before the audio encoder.

Constructor:

- `PreEventSeparateOutputBlock(MediaBlocksPipeline pipeline, SeparateOutput settings, BridgeVideoSourceSettings bridgeVideoSourceSettings, BridgeAudioSourceSettings bridgeAudioSourceSettings, PreEventRecordingBlock preEventBlock)`

### The conceptual pipeline

```
graph LR;
    MainVideoPath --> BridgeVideoSink;
    BridgeVideoSourceBlock --> OptionalVideoProcessor --> VideoEncoder --> PreEventRecordingBlock;
    MainAudioPath --> BridgeAudioSink;
    BridgeAudioSourceBlock --> OptionalAudioProcessor --> AudioEncoder --> PreEventRecordingBlock;
```

### Sample code

```
// Assuming 'pipeline' is your main MediaBlocksPipeline
// Assuming bridge sinks for the main video/audio paths are already configured
// with the channel names "pe_video_bridge" / "pe_audio_bridge".

// 1. Configure bridge sources for the separate sub-pipeline (match the sink channel names + format info)
var videoInfo = new VideoFrameInfoX(1920, 1080, new VideoFrameRate(30));
var audioInfo = new AudioInfoX(AudioFormatX.S16LE, 48000, 2);

var bridgeVideoSourceSettings = new BridgeVideoSourceSettings("pe_video_bridge", videoInfo);
var bridgeAudioSourceSettings = new BridgeAudioSourceSettings("pe_audio_bridge", audioInfo);

// 2. Configure encoders for the recording branch
var h264Settings = H264EncoderBlock.GetDefaultSettings();
var videoEncoder = new H264EncoderBlock(h264Settings);

var aacSettings = AACEncoderBlock.GetDefaultSettings();
var audioEncoder = new AACEncoderBlock(aacSettings);

var separateOutputSettings = new SeparateOutput
{
    VideoEncoder = videoEncoder,
    AudioEncoder = audioEncoder,
};

// 3. Create the pre-event recording block (see the Pre-Event Recording Block page for its settings)
var preEventBlock = new PreEventRecordingBlock(new PreEventRecordingSettings());

// 4. Create the PreEventSeparateOutputBlock (wires bridge sources -> encoders -> pre-event block)
var preEventOutput = new PreEventSeparateOutputBlock(
    pipeline,
    separateOutputSettings,
    bridgeVideoSourceSettings,
    bridgeAudioSourceSettings,
    preEventBlock);

// start main pipeline (the sub-pipeline runs through the bridges)
await pipeline.StartAsync();

// ... trigger an event clip on the pre-event block when needed ...
```

### Remarks

The `PreEventSeparateOutputBlock` writes pre-event and main segments to separate output files through the `PreEventRecordingBlock`; the filename is set per recording when the event is triggered, not on the output block. `GetFilenameOrURL()` returns the pre-event block's current filename. Building the block builds the supplied encoders, the pre-event block, and the bridge sources.

### Platforms

Depends on the components used within the `SeparateOutput` configuration and the `PreEventRecordingBlock` (encoders, processors). Generally cross-platform if the required GStreamer elements are available.

## See Also

- [Getting Started with Media Blocks](../GettingStarted/) — pipeline basics, installation, and first project setup
- [Pipeline Architecture](../GettingStarted/pipeline/) — MediaBlocksPipeline lifecycle, connecting blocks, and error handling
- [Video Encoders](../VideoEncoders/) — H.264, HEVC, VP8/VP9, AV1, and GPU-accelerated encoder blocks
- [Media Sources](../Sources/) — camera, screen, file, and network source blocks
- [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) — product page and downloads

---END OF PAGE---


## Pre-Event Buffering and Recording with Ring Buffer in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Outputs/pre-event-recording/
**Description:** Buffer and record pre-event surveillance video from IP cameras with ring buffer in VisioForge Media Blocks SDK. Motion-triggered capture in C# .NET.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, GStreamer, Encoding, MP4, TS, H.264, AAC, C#
**API:** PreEventRecordingBlock, PreEventRecordingEventArgs, PreEventRecordingSettings, MotionDetector, H264Encoder

# Pre-Event Recording Block - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The `PreEventRecordingBlock` continuously buffers encoded video and audio frames in a memory-based circular (ring) buffer. When an event triggers (motion detection, alarm, API call), it flushes the buffered pre-event footage to a file and continues recording live frames for a configurable post-event duration. This creates complete event clips that include footage from before the trigger occurred.

This block is commonly used in surveillance and security applications where you need to capture what happened before and after an event, without continuously writing to disk.

## Block info

Name: `PreEventRecordingBlock`.

| Pin direction | Media type | Description |
| --- | --- | --- |
| Input video | encoded video (H.264, H.265) | Encoded video stream from an encoder or passthrough source |
| Input audio | encoded audio (AAC, MP3, etc.) | Encoded audio stream (optional, can be disabled) |

This is a sink block — it has no output pads. Recorded files are written directly to disk when a recording is triggered.

## Settings

The `PreEventRecordingBlock` is configured using `PreEventRecordingSettings`.

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `PreEventDuration` | TimeSpan | 30 seconds | Duration of video/audio to keep buffered in memory. When a trigger occurs, this amount of footage is flushed to the output file. |
| `PostEventDuration` | TimeSpan | 10 seconds | Duration to continue recording after trigger. After this time elapses, recording stops automatically and the block returns to buffering mode. |
| `MaxBufferBytes` | long | 0 (unlimited) | Maximum buffer memory in bytes. When exceeded, oldest frames are evicted regardless of time-based duration. Set to 0 for time-based eviction only. |

### Constructor

```
public PreEventRecordingBlock(PreEventRecordingSettings settings, string muxFactoryName = "mp4mux")
```

**Parameters:**

- `settings` — Pre-event recording configuration. Uses defaults if null.
- `muxFactoryName` — GStreamer muxer element factory name. Default: `"mp4mux"`. Other options: `"matroskamux"` (MKV), `"mpegtsmux"` (MPEG-TS).

### Block properties

| Property | Type | Description |
| --- | --- | --- |
| `AudioEnabled` | bool | Enable/disable audio capture. Set before pipeline start. Default: `true`. |
| `State` | PreEventRecordingState | Current block state (read-only, thread-safe). |
| `CurrentFilename` | string | Current recording filename. Null when not recording. |
| `BufferTotalBytes` | long | Total bytes currently stored in the ring buffer. |
| `BufferedDuration` | TimeSpan | Current duration of buffered media. |
| `DebugLogPath` | string | Path to debug log file. When non-null, writes detailed frame timestamp debugging. |

## State machine

The block follows a well-defined state machine:

```
stateDiagram-v2
    [*] --> Idle
    Idle --> Buffering : Build() / StartBuffering()
    Buffering --> Recording : TriggerRecording()
    Recording --> PostEventRecording : Pre-event buffer flushed
    PostEventRecording --> Buffering : Post-event timer expires
    PostEventRecording --> Buffering : StopRecording()
    Buffering --> Stopped : StopBuffering()
    PostEventRecording --> Stopped : StopBuffering()
    Stopped --> Buffering : StartBuffering()
```

| State | Description |
| --- | --- |
| `Idle` | Not initialized or not started. |
| `Buffering` | Actively buffering frames in the ring buffer, not recording to file. |
| `Recording` | Flushing pre-event buffer to file and capturing live frames. |
| `PostEventRecording` | Post-event phase — recording live frames until the timer expires. |
| `Stopped` | Stopped and idle. |

## Events

```
public event EventHandler<PreEventRecordingEventArgs> OnRecordingStarted;
public event EventHandler<PreEventRecordingEventArgs> OnRecordingStopped;
public event EventHandler<PreEventRecordingEventArgs> OnStateChanged;
```

`PreEventRecordingEventArgs` properties:

| Property | Type | Description |
| --- | --- | --- |
| `State` | PreEventRecordingState | Current state at the time of the event. |
| `Filename` | string | Output filename for the recording. |
| `PreEventDuration` | TimeSpan | Actual pre-event duration included in the file (may be less than configured if insufficient buffered data or keyframe alignment adjusted the start). |

## Methods

| Method | Description |
| --- | --- |
| `TriggerRecording(string filename)` | Flush the ring buffer to the specified file and start recording live frames. If already recording, extends the current recording (resets post-event timer). |
| `ExtendRecording()` | Reset the post-event timer. Call this when the trigger condition is still active (e.g., motion continues). |
| `StopRecording()` | Manually stop the current recording and return to buffering mode. |
| `StartBuffering()` | Start or resume buffering after being stopped. |
| `StopBuffering()` | Stop everything including buffering and clear the buffer. |

## The sample pipeline

With a local camera source, motion detection, video preview, and pre-event recording:

```
graph LR;
    VideoSource-->MotionDetector;
    MotionDetector-->VideoTee;
    VideoTee-->VideoRenderer;
    VideoTee-->H264Encoder;
    H264Encoder-->PreEventRecordingBlock;
    AudioSource-->AudioTee;
    AudioTee-->AudioRenderer;
    AudioTee-->AACEncoder;
    AACEncoder-->PreEventRecordingBlock;
```

When `TriggerRecording()` is called, the block internally creates a dynamic output pipeline:

```
graph LR;
    RingBuffer-->AppSrcVideo;
    RingBuffer-->AppSrcAudio;
    AppSrcVideo-->Muxer;
    AppSrcAudio-->Muxer;
    Muxer-->FileSink;
```

## Sample code

The following snippet shows how to create and connect the block. For a complete working application with motion detection, video preview, RTSP camera support, and full WPF UI, see the [Pre-Event Recording Guide](../../Guides/pre-event-recording/).

```
// Configure pre-event settings
var preEventSettings = new PreEventRecordingSettings
{
    PreEventDuration = TimeSpan.FromSeconds(10),
    PostEventDuration = TimeSpan.FromSeconds(5)
};

// Create the block (MP4 output)
var preEventBlock = new PreEventRecordingBlock(preEventSettings, "mp4mux");
preEventBlock.AudioEnabled = true;

// Subscribe to events
preEventBlock.OnRecordingStarted += (s, args) =>
    Debug.WriteLine($"Recording started: {args.Filename}");
preEventBlock.OnRecordingStopped += (s, args) =>
    Debug.WriteLine($"Recording stopped: {args.Filename}");

// Connect encoded video and audio to the block
pipeline.Connect(h264Encoder.Output, preEventBlock.VideoInput);
pipeline.Connect(aacEncoder.Output, preEventBlock.AudioInput);

// Start pipeline — buffering begins immediately
await pipeline.StartAsync();

// Later: trigger recording on event
preEventBlock.TriggerRecording("/recordings/event_001.mp4");

// Extend if trigger condition persists
preEventBlock.ExtendRecording();

// Or stop manually
preEventBlock.StopRecording();
```

## Container format options

| Format | Muxer Factory Name | Pros | Cons |
| --- | --- | --- | --- |
| **MP4** | `mp4mux` | Most compatible, widely supported | Requires finalization (moov atom); file may be corrupt if process crashes during recording |
| **MPEG-TS** | `mpegtsmux` | Crash-safe — no finalization step needed; file is always playable | Slightly larger file size; less universal support in some players |
| **MKV** | `matroskamux` | Flexible container; supports many codecs | Less compatible with some mobile players |

Crash Safety

For surveillance applications where process crashes are a concern, use **MPEG-TS** (`mpegtsmux`). MP4 files that are not properly finalized (e.g., due to a crash or power loss during recording) may be unplayable.

## Platforms

Windows, macOS, Linux, Android, iOS (platform availability depends on GStreamer muxer and encoder support).

---END OF PAGE---


## Stream Parser Blocks - H.264, HEVC, AV1 Pipelines in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Parsers/
**Description:** Parse elementary video and audio streams to extract metadata and prepare content for decoding and multiplexing in VisioForge Media Blocks SDK.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS
**API:** VideoRendererBlock, DataSourceBlock, AV1ParseBlock, H263ParseBlock, H264ParseBlock

# Parser Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Parser blocks are essential components in media processing pipelines. They are used to parse elementary streams, which might be raw or partially processed, to extract metadata, and to prepare the streams for further processing like decoding or multiplexing. VisioForge Media Blocks SDK .Net offers a variety of parser blocks for common video and audio codecs.

## Video Parser Blocks

### AV1 Parser Block

The `AV1ParseBlock` is used to parse AV1 video elementary streams. It helps in identifying frame boundaries and extracting codec-specific information.

#### Block info

Name: `AV1ParseBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | AV1 video | 1 |
| Output video | AV1 video | 1 |

#### The sample pipeline

```
graph LR;
    DataSourceBlock["Data Source (e.g., File or Network)"] --> AV1ParseBlock;
    AV1ParseBlock --> AV1DecoderBlock["AV1 Decoder Block"];
    AV1DecoderBlock --> VideoRendererBlock["Video Renderer Block"];
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

---

### H.263 Parser Block

The `H263ParseBlock` is designed to parse H.263 video elementary streams. This is useful for older video conferencing and mobile video applications.

#### Block info

Name: `H263ParseBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | H.263 video | 1 |
| Output video | H.263 video | 1 |

#### The sample pipeline

```
graph LR;
    DataSourceBlock["Data Source"] --> H263ParseBlock;
    H263ParseBlock --> H263DecoderBlock["H.263 Decoder Block"];
    H263DecoderBlock --> VideoRendererBlock["Video Renderer Block"];
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

---

### H.264 Parser Block

The `H264ParseBlock` parses H.264 (AVC) video elementary streams. This is one of the most widely used video codecs. The parser helps in identifying NAL units and other stream properties.

#### Block info

Name: `H264ParseBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | H.264 video | 1 |
| Output video | H.264 video | 1 |

#### The sample pipeline

```
graph LR;
    PushDataSource["Push Data Source (H.264 NALUs)"] --> H264ParseBlock;
    H264ParseBlock --> H264DecoderBlock["H.264 Decoder Block"];
    H264DecoderBlock --> VideoRendererBlock["Video Renderer Block"];
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

---

### H.265 Parser Block

The `H265ParseBlock` parses H.265 (HEVC) video elementary streams. H.265 offers better compression than H.264. The parser helps in identifying NAL units and other stream properties.

#### Block info

Name: `H265ParseBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | H.265 video | 1 |
| Output video | H.265 video | 1 |

#### The sample pipeline

```
graph LR;
    PushDataSource["Push Data Source (H.265 NALUs)"] --> H265ParseBlock;
    H265ParseBlock --> H265DecoderBlock["H.265 Decoder Block"];
    H265DecoderBlock --> VideoRendererBlock["Video Renderer Block"];
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

---

### JPEG 2000 Parser Block

The `JPEG2000ParseBlock` is used to parse JPEG 2000 video streams. JPEG 2000 is a wavelet-based compression standard that can be used for still images and video.

#### Block info

Name: `JPEG2000ParseBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | JPEG 2000 video | 1 |
| Output video | JPEG 2000 video | 1 |

#### The sample pipeline

```
graph LR;
    DataSourceBlock["Data Source"] --> JPEG2000ParseBlock;
    JPEG2000ParseBlock --> JPEG2000DecoderBlock["JPEG 2000 Decoder Block"];
    JPEG2000DecoderBlock --> VideoRendererBlock["Video Renderer Block"];
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

---

### MPEG-1/2 Video Parser Block

The `MPEG12VideoParseBlock` parses MPEG-1 and MPEG-2 video elementary streams. These are older but still relevant video codecs, especially MPEG-2 for DVDs and broadcast.

#### Block info

Name: `MPEG12VideoParseBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | MPEG-1/2 video | 1 |
| Output video | MPEG-1/2 video | 1 |

#### The sample pipeline

```
graph LR;
    DataSourceBlock["Data Source"] --> MPEG12VideoParseBlock;
    MPEG12VideoParseBlock --> MPEGVideoDecoderBlock["MPEG-1/2 Decoder Block"];
    MPEGVideoDecoderBlock --> VideoRendererBlock["Video Renderer Block"];
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

---

### MPEG-4 Video Parser Block

The `MPEG4ParseBlock` parses MPEG-4 Part 2 video elementary streams (often referred to as DivX/Xvid in its early forms).

#### Block info

Name: `MPEG4ParseBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | MPEG-4 video | 1 |
| Output video | MPEG-4 video | 1 |

#### The sample pipeline

```
graph LR;
    DataSourceBlock["Data Source"] --> MPEG4ParseBlock;
    MPEG4ParseBlock --> MPEG4DecoderBlock["MPEG-4 Decoder Block"];
    MPEG4DecoderBlock --> VideoRendererBlock["Video Renderer Block"];
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

---

### PNG Parser Block

The `PNGParseBlock` is used to parse PNG image data. While PNG is primarily an image format, this parser can be useful in scenarios where PNG images are part of a stream or need to be processed within the Media Blocks pipeline.

#### Block info

Name: `PNGParseBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | PNG image data | 1 |
| Output video | PNG image data | 1 |

#### The sample pipeline

```
graph LR;
    DataSourceBlock["Data Source (PNG data)"] --> PNGParseBlock;
    PNGParseBlock --> PNGDecoderBlock["PNG Decoder Block"];
    PNGDecoderBlock --> VideoRendererBlock["Video Renderer Block (or Image Overlay)"];
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

---

### VC-1 Parser Block

The `VC1ParseBlock` parses VC-1 video elementary streams. VC-1 was developed by Microsoft and was used in Blu-ray Discs and Windows Media Video.

#### Block info

Name: `VC1ParseBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | VC-1 video | 1 |
| Output video | VC-1 video | 1 |

#### The sample pipeline

```
graph LR;
    DataSourceBlock["Data Source"] --> VC1ParseBlock;
    VC1ParseBlock --> VC1DecoderBlock["VC-1 Decoder Block"];
    VC1DecoderBlock --> VideoRendererBlock["Video Renderer Block"];
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

---

### VP9 Parser Block

The `VP9ParseBlock` parses VP9 video elementary streams. VP9 is an open and royalty-free video coding format developed by Google, often used for web video.

#### Block info

Name: `VP9ParseBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | VP9 video | 1 |
| Output video | VP9 video | 1 |

#### The sample pipeline

```
graph LR;
    DataSourceBlock["Data Source"] --> VP9ParseBlock;
    VP9ParseBlock --> VP9DecoderBlock["VP9 Decoder Block"];
    VP9DecoderBlock --> VideoRendererBlock["Video Renderer Block"];
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

---

## Audio Parser Blocks

### MPEG Audio Parser Block

The `MPEGAudioParseBlock` parses MPEG audio elementary streams, which includes MP1, MP2, and MP3 audio.

#### Block info

Name: `MPEGAudioParseBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | MPEG audio | 1 |
| Output audio | MPEG audio | 1 |

#### The sample pipeline

```
graph LR;
    DataSourceBlock["Data Source (MP3 data)"] --> MPEGAudioParseBlock;
    MPEGAudioParseBlock --> MP3DecoderBlock["MP3 Decoder Block"];
    MP3DecoderBlock --> AudioRendererBlock["Audio Renderer Block"];
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Individual Parser Blocks

### AV1 Parse

Parses AV1 video streams to extract frame boundaries and metadata.

#### Block info

Name: AV1ParseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | AV1 compressed | 1 |
| Output | AV1 parsed | 1 |

#### Sample code

```
var pipeline = new MediaBlocksPipeline();
var av1Parse = new AV1ParseBlock();
// Connect to AV1 stream source and decoder
await pipeline.StartAsync();
```

### H263 Parse

Parses H.263 video streams for frame boundary detection.

#### Block info

Name: H263ParseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | H.263 compressed | 1 |
| Output | H.263 parsed | 1 |

### H264 Parse

Parses H.264/AVC video streams to extract NAL units and frame information.

#### Block info

Name: H264ParseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | H.264 compressed | 1 |
| Output | H.264 parsed | 1 |

### H265 Parse

Parses H.265/HEVC video streams to extract NAL units and coding information.

#### Block info

Name: H265ParseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | H.265 compressed | 1 |
| Output | H.265 parsed | 1 |

### JPEG2000 Parse

Parses JPEG2000 video streams.

#### Block info

Name: JPEG2000ParseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | JPEG2000 compressed | 1 |
| Output | JPEG2000 parsed | 1 |

### MPEG-1/2 Video Parse

Parses MPEG-1 and MPEG-2 video streams.

#### Block info

Name: MPEG12VideoParseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | MPEG-1/2 compressed | 1 |
| Output | MPEG-1/2 parsed | 1 |

### MPEG-4 Parse

Parses MPEG-4 video streams.

#### Block info

Name: MPEG4ParseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | MPEG-4 compressed | 1 |
| Output | MPEG-4 parsed | 1 |

### MPEG Audio Parse

Parses MPEG audio streams (MP1, MP2, MP3).

#### Block info

Name: MPEGAudioParseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | MPEG audio compressed | 1 |
| Output | MPEG audio parsed | 1 |

### PNG Parse

Parses PNG image streams.

#### Block info

Name: PNGParseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | PNG compressed | 1 |
| Output | PNG parsed | 1 |

### VC-1 Parse

Parses VC-1 video streams (Windows Media Video 9).

#### Block info

Name: VC1ParseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | VC-1 compressed | 1 |
| Output | VC-1 parsed | 1 |

### VP9 Parse

Parses VP9 video streams.

#### Block info

Name: VP9ParseBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | VP9 compressed | 1 |
| Output | VP9 parsed | 1 |

## Platforms

Windows, macOS, Linux, iOS, Android.

---END OF PAGE---


## RTSP Server Streaming in C# .NET — Developer Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/RTSPServer/
**Description:** Create RTSP streaming servers for low-latency audio and video delivery with H.264/H.265 codec support using VisioForge Media Blocks SDK.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming
**API:** RTSPServerBlock, RTSPServerSettings, H264EncoderBlock, AACEncoderBlock, SystemVideoSourceBlock

# RTSP Server Block - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Cross-platform support

The `RTSPServerBlock` runs on **Windows, macOS, and Linux** via GStreamer (requires the `gst-rtsp-server` plugin). See the [platform support matrix](../../platform-matrix/) for codec and hardware-acceleration details, and the [Linux deployment guide](../../deployment-x/Ubuntu/) for Ubuntu / NVIDIA Jetson / Raspberry Pi setup.

The RTSP Server block creates an RTSP (Real-Time Streaming Protocol) server endpoint for streaming audio/video content over networks. Clients can connect to receive live or recorded media streams with low latency.

## Overview

The RTSPServerBlock provides a complete RTSP streaming server implementation with the following capabilities:

- **Multiple Client Support**: Handles simultaneous connections from multiple RTSP clients
- **Standard Compliance**: Compatible with VLC, FFmpeg, GStreamer, and IP camera viewers
- **Video Codecs**: H.264, H.265, and other compressed formats
- **Audio Codecs**: AAC, MP3, Opus, and other formats
- **Transport Protocols**: RTP/RTCP for reliable media delivery
- **Authentication**: Optional RTSP authentication support
- **Configurable**: Custom port binding and mount points
- **Low Latency**: Optimized for real-time streaming applications

## Block Info

Name: RTSPServerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | compressed video (H.264, H.265) | 1 |
| Input audio | compressed audio (AAC, MP3, etc.) | 1 |

## The Sample Pipeline

```
graph LR;
    SystemVideoSourceBlock-->H264EncoderBlock;
    SystemAudioSourceBlock-->AACEncoderBlock;
    H264EncoderBlock-->RTSPServerBlock;
    AACEncoderBlock-->RTSPServerBlock;
```

## Settings

The RTSPServerBlock is configured using `RTSPServerSettings`:

### RTSPServerSettings Properties

- `Port` (`int`): The TCP port for the RTSP server. Default `8554`.
- `Point` (`string`): The URL path under which the stream is served (for example `/live`). Default `/live`.
- `Username` (`string`): Optional username for basic RTSP authentication.
- `Password` (`string`): Optional password for basic RTSP authentication.
- `Address` (`string`): Address the server binds to. Default `127.0.0.1`; set to `0.0.0.0` to bind all interfaces.
- `Name` (`string`): Server display name announced to clients. Default `"VisioForge RTSP Server"`.
- `Description` (`string`): Human-readable description. Default `"VisioForge RTSP Server"`.
- `Latency` (`TimeSpan`): Buffering latency applied by the server. Default `250 ms`.
- `URL` (`string`, read-only): Computed `rtsp://{Address}:{Port}{Point}` URL — use this after constructing the settings to log the client-facing URL.
- `VideoEncoder` (`IVideoEncoder`): Video encoder settings. Pass `null` to disable the video stream.
- `AudioEncoder` (`IAudioEncoder`): Audio encoder settings. Pass `null` to disable the audio stream.

`RTSPServerSettings` has **no parameterless constructor**. Use one of:

- `new RTSPServerSettings(IVideoEncoder videoEncoder, IAudioEncoder audioEncoder)`
- `new RTSPServerSettings(Uri uri, IVideoEncoder videoEncoder, IAudioEncoder audioEncoder)` — parses host / port / point from the URI.

## Sample Code

### Basic RTSP Server

```
var pipeline = new MediaBlocksPipeline();

// Create video source
var videoDevice = (await DeviceEnumerator.Shared.VideoSourcesAsync())[0];
var videoFormat = videoDevice.VideoFormats[0];
var videoSettings = new VideoCaptureDeviceSourceSettings(videoDevice)
{
    Format = videoFormat.ToFormat()
};
var videoSource = new SystemVideoSourceBlock(videoSettings);

// Create audio source
var audioDevice = (await DeviceEnumerator.Shared.AudioSourcesAsync())[0];
var audioFormat = audioDevice.Formats[0];
var audioSettings = audioDevice.CreateSourceSettings(audioFormat.ToFormat());
var audioSource = new SystemAudioSourceBlock(audioSettings);

// Create video encoder (concrete settings class — use NVENC/QSV/AMF where available, OpenH264 as the portable fallback)
var h264Settings = new OpenH264EncoderSettings
{
    Bitrate = 2000 // kbps
};
var h264Encoder = new H264EncoderBlock(h264Settings);
pipeline.Connect(videoSource.Output, h264Encoder.Input);

// Create audio encoder (cross-platform AAC)
var aacSettings = new VOAACEncoderSettings
{
    Bitrate = 128 // kbps
};
var aacEncoder = new AACEncoderBlock(aacSettings);
pipeline.Connect(audioSource.Output, aacEncoder.Input);

// Create RTSP server (settings ctor takes videoEncoder + audioEncoder).
// Since we pre-encode above, pass null for both here — RTSPServerBlock just forwards the encoded
// streams. Pass concrete encoders only when you want the server to encode internally.
var rtspSettings = new RTSPServerSettings(videoEncoder: null, audioEncoder: null)
{
    Port = 8554,
    Point = "/live",
    Address = "0.0.0.0"   // listen on all interfaces; defaults to 127.0.0.1
};
var rtspServer = new RTSPServerBlock(rtspSettings);
pipeline.Connect(h264Encoder.Output, rtspServer.VideoInput);
pipeline.Connect(aacEncoder.Output, rtspServer.AudioInput);

// Start streaming
await pipeline.StartAsync();

// rtspSettings.URL returns the client-facing URL:
Console.WriteLine($"RTSP server started at {rtspSettings.URL}");
Console.WriteLine($"Connect with: vlc {rtspSettings.URL}");
```

### Letting the server encode internally

If you'd rather feed raw camera frames straight into the RTSP server and let the server do its own H.264 encoding, construct `RTSPServerSettings` with concrete encoder settings and skip the standalone `H264EncoderBlock` / `AACEncoderBlock`:

```
var rtspSettings = new RTSPServerSettings(
    videoEncoder: H264EncoderBlock.GetDefaultSettings(),
    audioEncoder: null)
{
    Port = 8554,
    Point = "/live",
    Address = "0.0.0.0"
};

var rtspServer = new RTSPServerBlock(rtspSettings);

// Connect raw (unencoded) sources — the server will encode.
pipeline.Connect(videoSource.Output, rtspServer.VideoInput);

await pipeline.StartAsync();
Console.WriteLine(rtspSettings.URL);
```

### RTSP Server with Authentication

```
var rtspSettings = new RTSPServerSettings(
    videoEncoder: H264EncoderBlock.GetDefaultSettings(),
    audioEncoder: AACEncoderBlock.GetDefaultSettings())
{
    Port = 8554,
    Point = "/secure",
    Username = "admin",
    Password = "password123"
};
var rtspServer = new RTSPServerBlock(rtspSettings);

// Configure encoders and connect as above
// ...

await pipeline.StartAsync();

// Clients must authenticate: rtsp://admin:password123@localhost:8554/secure
Console.WriteLine($"Secure RTSP server started at {rtspSettings.URL}");
```

### File Streaming over RTSP

```
var pipeline = new MediaBlocksPipeline();

// Use file as source
var fileSettings = await UniversalSourceSettings.CreateAsync("video.mp4");
var fileSource = new UniversalSourceBlock(fileSettings);

// Create RTSP server — let it encode both streams internally
var rtspSettings = new RTSPServerSettings(
    videoEncoder: H264EncoderBlock.GetDefaultSettings(),
    audioEncoder: AACEncoderBlock.GetDefaultSettings())
{
    Port = 8554,
    Point = "/vod"
};
var rtspServer = new RTSPServerBlock(rtspSettings);

// Connect raw video and audio from file
pipeline.Connect(fileSource.VideoOutput, rtspServer.VideoInput);
pipeline.Connect(fileSource.AudioOutput, rtspServer.AudioInput);

await pipeline.StartAsync();

// Stream file content via RTSP
Console.WriteLine($"Video-on-Demand RTSP server started at {rtspSettings.URL}");
```

## Client Connection

Clients can connect to the RTSP server using the URL format:

```
rtsp://hostname:port/mountpoint
```

Examples: - `rtsp://localhost:8554/live` - `rtsp://192.168.1.100:8554/stream1` - `rtsp://username:password@server.com:8554/secure`

### VLC Player

```
vlc rtsp://localhost:8554/live
```

### FFmpeg

```
ffplay rtsp://localhost:8554/live
ffmpeg -i rtsp://localhost:8554/live -c copy output.mp4
```

### GStreamer

```
gst-launch-1.0 rtspsrc location=rtsp://localhost:8554/live ! decodebin ! autovideosink
```

## Use Cases

- **Live Streaming**: Broadcast live camera feeds over networks
- **Security Systems**: Stream surveillance cameras to monitoring stations
- **Video Distribution**: Distribute media content to multiple clients
- **Remote Monitoring**: Enable remote viewing of industrial processes
- **Broadcasting**: Create low-latency streaming solutions
- **Video Conferencing**: Stream participant feeds to viewers
- **IoT Cameras**: Provide RTSP endpoint for smart camera devices

## Performance Considerations

- **Encoding**: Video/audio must be encoded before streaming
- **Bandwidth**: Monitor network bandwidth for multiple clients
- **Latency**: Optimize encoder settings for low-latency requirements
- **Clients**: Each client consumes server resources and bandwidth
- **Port**: Ensure firewall allows traffic on the configured port
- **Multicast**: Use for efficient one-to-many streaming on local networks

## Remarks

- Video and audio streams should be compressed/encoded before feeding to RTSP server
- The server supports H.264/H.265 for video and AAC/MP3/Opus for audio
- Port 8554 is the standard RTSP port but can be changed
- Mount point defines the URL path for accessing the stream
- Server continues streaming as long as the pipeline is running
- Multiple RTSPServerBlock instances can run on different ports simultaneously
- Use authentication for secure streaming environments

## Platforms

Windows, macOS, Linux.

Note: Requires GStreamer with RTSP server support (gst-rtsp-server plugin).

## Sample Applications

- [RTSP Webcam Server](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/Console/RTSP%20Webcam%20Server)

## Related Blocks

- [H264EncoderBlock](../VideoEncoders/#h264-encoder) - H.264 video encoding
- [H265EncoderBlock](../VideoEncoders/#hevch265-encoder) - H.265 video encoding
- [AACEncoderBlock](../AudioEncoders/#aac-encoder) - AAC audio encoding
- [SystemVideoSourceBlock](../Sources/#system-video-source) - Camera capture
- [SystemAudioSourceBlock](../Sources/#system-audio-source) - Audio capture

## Related Guides

- [RTSP protocol deep-dive](../../general/network-streaming/rtsp/) — how RTSP works under the hood
- [RTSP camera source configuration](../../videocapture/video-sources/ip-cameras/rtsp/) — consume RTSP streams in your own applications
- [Media Blocks RTSP player](../Guides/rtsp-player-csharp/) — a client pipeline for RTSP streams (pair with this server)
- [Save RTSP stream without re-encoding](../Guides/rtsp-save-original-stream/) — archive streams from an RTSP source to disk
- [RTSP reconnection and fallback switch](../../general/network-sources/reconnection-and-fallback/) — handle upstream source drops with reconnect events and `FallbackSwitch` when you feed this server from an RTSP camera

---END OF PAGE---


## Media Sink Blocks for File and Network Output in .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Sinks/
**Description:** Write media to MP4, MKV, AVI files or stream via RTMP, HLS, SRT protocols using VisioForge Media Blocks SDK sink blocks in C# .NET.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming
**API:** UniversalSourceBlock, MediaBlockPadMediaType, H264EncoderBlock, AACEncoderBlock, MediaBlocksPipeline

# Sinks

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Sinks are blocks that save or stream data. They are the last blocks in the pipeline. Optionally, some sinks can have output pins to pass data to the next block in the pipeline.

SDK provides a lot of different sinks for different purposes.

**File sinks**

The following file sinks are available:

- [ASF](#asf)
- [AVI](#avi)
- [File](#raw-file)
- [MKV](#mkv)
- [MOV](#mov)
- [MP4](#mp4)
- [MPEG-PS](#mpeg-ps)
- [MPEG-TS](#mpeg-ts)
- [MXF](#mxf)
- [OGG](#ogg)
- [WAV](#wav)
- [WebM](#webm)

**Network streaming**

The following network streaming sinks are available:

- [DASH](#dash)
- [Facebook Live](#facebook-live)
- [HLS](#hls)
- [MJPEG over HTTP](#mjpeg-over-http)
- [NDI](#ndi)
- [SRT](#srt)
- [SRT MPEG-TS](#srt-mpeg-ts)
- [RTMP](#rtmp)
- [Shoutcast](#shoutcast)
- [WHIP](#whip)
- [YouTube Live](#youtube-live)
- [RIST MPEG-TS](#rist-mpeg-ts)

**Utility sinks**

The following utility sinks are available:

- [Stream Sink](#stream-sink)
- [File Descriptor Sink](#file-descriptor-sink)
- [KLV File Sink](#klv-file-sink)
- [Buffer Sink](#buffer-sink)
- [Virtual Camera Sink](#virtual-camera-sink)

## File Sinks

### ASF

`ASF (Advanced Systems Format)`: A Microsoft digital container format used to store multimedia data, designed to be platform-independent and to support scalable media types like audio and video.

Use the `ASFSinkSettings` class to set the parameters.

#### Block info

Name: ASFSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/mpeg |  |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
|  | audio/x-wma |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-divx |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |
|  | video/x-dv |  |
|  | video/x-huffyuv |  |
|  | video/x-wmv |  |
|  | video/x-jpc |  |
|  | video/x-vp8 |  |
|  | image/png |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->WMVEncoderBlock;
    UniversalSourceBlock-->WMAEncoderBlock;
    WMVEncoderBlock-->ASFSinkBlock;
    WMAEncoderBlock-->ASFSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new WMAEncoderBlock(new WMAEncoderSettings());
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

var videoEncoderBlock = new WMVEncoderBlock(new WMVEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var sinkBlock = new ASFSinkBlock(new ASFSinkSettings(@"output.wmv"));
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### AVI

AVI (Audio Video Interleave) is a multimedia container format introduced by Microsoft. It enables simultaneous audio-with-video playback by alternating segments of audio and video data.

Use the `AVISinkSettings` class to set the parameters.

#### Block info

Name: AVISinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/mpeg |  |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-divx |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |
|  | video/x-dv |  |
|  | video/x-huffyuv |  |
|  | image/png |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MP3EncoderBlock;
    UniversalSourceBlock-->DIVXEncoderBlock;
    MP3EncoderBlock-->AVISinkBlock;
    DIVXEncoderBlock-->AVISinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new MP3EncoderBlock(new MP3EncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

var videoEncoderBlock = new DIVXEncoderBlock(new DIVXEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var sinkBlock = new AVISinkBlock(new AVISinkSettings(@"output.avi"));
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### RAW File

Universal output to a file. This sink is used inside all other higher-level sinks, e.g. MP4Sink. It can be used to write RAW video or audio to a file.

#### Block info

Name: FileSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any stream format | 1 |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MP3EncoderBlock;
    MP3EncoderBlock-->AVISinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var mp3EncoderBlock = new MP3EncoderBlock(new MP3EncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, mp3EncoderBlock.Input);

var fileSinkBlock = new FileSinkBlock(@"output.mp3");
pipeline.Connect(mp3EncoderBlock.Output, fileSinkBlock.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### MKV

MKV (Matroska) is an open standard free container format, similar to MP4 and AVI but with more flexibility and advanced features.

Use the `MKVSinkSettings` class to set the parameters.

#### Block info

Name: MKVSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/mpeg |  |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
|  | audio/x-wma |  |
|  | audio/x-vorbis |  |
|  | audio/x-opus |  |
|  | audio/x-flac |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-divx |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |
|  | video/x-h265 |  |
|  | video/x-dv |  |
|  | video/x-huffyuv |  |
|  | video/x-wmv |  |
|  | video/x-jpc |  |
|  | video/x-vp8 |  |
|  | video/x-vp9 |  |
|  | video/x-theora |  |
|  | image/png |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VorbisEncoderBlock;
    UniversalSourceBlock-->VP9EncoderBlock;
    VorbisEncoderBlock-->MKVSinkBlock;
    VP9EncoderBlock-->MKVSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new VorbisEncoderBlock(new VorbisEncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

var videoEncoderBlock = new VP9EncoderBlock(new VP9EncoderSettings() { Bitrate = 2000 });
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var sinkBlock = new MKVSinkBlock(new MKVSinkSettings(@"output.mkv"));
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### MOV

MOV (QuickTime File Format) is a multimedia container format developed by Apple for storing video, audio, and other time-based media. It supports various codecs and is widely used for multimedia content on Apple platforms, and also in professional video editing.

Use the `MOVSinkSettings` class to set the parameters.

#### Block info

Name: MOVSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/mpeg |  |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
|  | audio/AAC |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-divx |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |
|  | video/x-h265 |  |
|  | video/x-dv |  |
|  | video/x-huffyuv |  |
|  | image/png |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AACEncoderBlock;
    UniversalSourceBlock-->H264EncoderBlock;
    AACEncoderBlock-->MOVSinkBlock;
    H264EncoderBlock-->MOVSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new AACEncoderBlock(new AACEncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

var videoEncoderBlock = new H264EncoderBlock(new OpenH264EncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var sinkBlock = new MOVSinkBlock(new MOVSinkSettings(@"output.mov"));
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### MP4

MP4 (MPEG-4 Part 14) is a digital multimedia container format used to store video, audio, and other data such as subtitles and images. It's widely used for sharing video content online and is compatible with a wide range of devices and platforms.

Use the `MP4SinkSettings` class to set the parameters.

#### Block info

Name: MP4SinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/mpeg |  |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
|  | audio/AAC |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-divx |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |
|  | video/x-h265 |  |
|  | video/x-dv |  |
|  | video/x-huffyuv |  |
|  | image/png |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AACEncoderBlock;
    UniversalSourceBlock-->H264EncoderBlock;
    AACEncoderBlock-->MP4SinkBlock;
    H264EncoderBlock-->MP4SinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new AACEncoderBlock(new AACEncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

var videoEncoderBlock = new H264EncoderBlock(new OpenH264EncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var sinkBlock = new MP4SinkBlock(new MP4SinkSettings(@"output.mp4"));
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### MPEG-PS

MPEG-PS (MPEG Program Stream) is a container format for multiplexing digital audio, video, and other data. It is designed for reasonably reliable media, such as DVDs, CD-ROMs, and other disc media.

Construct via `new MPEGPSSinkBlock(string filename)` — the block ships with a single filename-only ctor; there is no separate settings class.

#### Block info

Name: MPEGPSSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/mpeg |  |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MP2EncoderBlock;
    UniversalSourceBlock-->MPEG2EncoderBlock;
    MP2EncoderBlock-->MPEGPSSinkBlock;
    MPEG2EncoderBlock-->MPEGPSSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new MP2EncoderBlock(new MP2EncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

var videoEncoderBlock = new MPEG2EncoderBlock(new MPEG2VideoEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var sinkBlock = new MPEGPSSinkBlock(@"output.mpg");
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### MPEG-TS

MPEG-TS (MPEG Transport Stream) is a standard digital container format for transmission and storage of audio, video, and Program and System Information Protocol (PSIP) data. It is used in broadcast systems such as DVB, ATSC and IPTV.

Use the `MPEGTSSinkSettings` class to set the parameters.

#### Block info

Name: MPEGTSSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/mpeg |  |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
|  | audio/AAC |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |
|  | video/x-h265 |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AACEncoderBlock;
    UniversalSourceBlock-->H264EncoderBlock;
    AACEncoderBlock-->MPEGTSSinkBlock;
    H264EncoderBlock-->MPEGTSSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new AACEncoderBlock(new AACEncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

var videoEncoderBlock = new H264EncoderBlock(new OpenH264EncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var sinkBlock = new MPEGTSSinkBlock(new MPEGTSSinkSettings(@"output.ts"));
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### MXF

MXF (Material Exchange Format) is a container format for professional digital video and audio media, developed to address issues such as file exchange, interoperability, and to improve project workflow between production houses and content/equipment providers.

Use the `MXFSinkSettings` class to set the parameters.

#### Block info

Name: MXFSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/mpeg |  |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
|  | audio/AAC |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-divx |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |
|  | video/x-h265 |  |
|  | video/x-dv |  |
|  | image/png |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->PCMEncoderBlock;
    UniversalSourceBlock-->DIVXEncoderBlock;
    PCMEncoderBlock-->MXFSinkBlock;
    DIVXEncoderBlock-->MXFSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioBlock = new PCMEncoderBlock(new PCMEncoderSettings());
pipeline.Connect(fileSource.AudioOutput, audioBlock.Input);

var videoEncoderBlock = new DIVXEncoderBlock(new DIVXEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var sinkBlock = new MXFSinkBlock(new MXFSinkSettings(@"output.mxf"));
pipeline.Connect(audioBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### OGG

OGG is a free, open container format designed for efficient streaming and manipulation of high quality digital multimedia. It is developed by the Xiph.Org Foundation and supports audio codecs like Vorbis, Opus, and FLAC, and video codecs like Theora.

Use the `OGGSinkSettings` class to set the parameters.

#### Block info

Name: OGGSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/x-vorbis |  |
|  | audio/x-flac |  |
|  | audio/x-speex |  |
|  | audio/x-celt |  |
|  | audio/x-opus |  |
| Input video | video/x-raw | one or more |
|  | video/x-theora |  |
|  | video/x-dirac |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VorbisEncoderBlock;
    UniversalSourceBlock-->TheoraEncoderBlock;
    VorbisEncoderBlock-->OGGSinkBlock;
    TheoraEncoderBlock-->OGGSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new VorbisEncoderBlock(new VorbisEncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

var videoEncoderBlock = new TheoraEncoderBlock(new TheoraEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var sinkBlock = new OGGSinkBlock(new OGGSinkSettings(@"output.ogg"));
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### WAV

WAV (Waveform Audio File Format) is an audio file format standard developed by IBM and Microsoft for storing audio bitstreams on PCs. It is the main format used on Windows systems for raw and typically uncompressed audio.

The sink takes its destination either as a filename argument or as a `WAVSinkSettings` object, which is also the form a saved pipeline document carries. Sample format comes from the upstream `PCMEncoderBlock` settings.

#### Block info

Name: WAVSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->PCMEncoderBlock;
    PCMEncoderBlock-->WAVSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp3";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioBlock = new PCMEncoderBlock(new PCMEncoderSettings());
pipeline.Connect(fileSource.AudioOutput, audioBlock.Input);

var sinkBlock = new WAVSinkBlock(@"output.wav");
pipeline.Connect(audioBlock.Output, sinkBlock.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### WebM

WebM is an open, royalty-free, media file format designed for the web. WebM defines the file container structure, video and audio formats. WebM files consist of video streams compressed with the VP8 or VP9 video codecs and audio streams compressed with the Vorbis or Opus audio codecs.

Use the `WebMSinkSettings` class to set the parameters.

#### Block info

Name: WebMSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/x-vorbis |  |
|  | audio/x-opus |  |
| Input video | video/x-raw | one or more |
|  | video/x-vp8 |  |
|  | video/x-vp9 |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VorbisEncoderBlock;
    UniversalSourceBlock-->VP9EncoderBlock;
    VorbisEncoderBlock-->WebMSinkBlock;
    VP9EncoderBlock-->WebMSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new VorbisEncoderBlock(new VorbisEncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

var videoEncoderBlock = new VP9EncoderBlock(new VP9EncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var sinkBlock = new WebMSinkBlock(new WebMSinkSettings(@"output.webm"));
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Network Streaming Sinks

### RTMP

`RTMP (Real-Time Messaging Protocol)`: Developed by Adobe, RTMP is a protocol used for streaming audio, video, and data over the Internet, optimized for high-performance transmission. It enables efficient, low-latency communication, commonly used in live broadcasting like sports events and concerts.

Use the `RTMPSinkSettings` class to set the parameters.

#### Block info

Name: RTMPSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/mpeg [1,2,4] | one |
|  | audio/x-adpcm |  |
|  | PCM [U8, S16LE] |  |
|  | audio/x-speex |  |
|  | audio/x-mulaw |  |
|  | audio/x-alaw |  |
|  | audio/x-nellymoser |  |
| Input video | video/x-h264 | one |

#### The sample pipeline

```
graph LR;
    VirtualVideoSourceBlock-->H264EncoderBlock;
    VirtualAudioSourceBlock-->AACEncoderBlock;
    H264EncoderBlock-->RTMPSinkBlock;
    AACEncoderBlock-->RTMPSinkBlock;
```

#### Sample code

```
// Pipeline
var pipeline = new MediaBlocksPipeline();

// video and audio sources
var virtualVideoSource = new VirtualVideoSourceSettings
{
    Width = 1280,
    Height = 720,
    FrameRate = VideoFrameRate.FPS_25,
};

var videoSource = new VirtualVideoSourceBlock(virtualVideoSource);

var virtualAudioSource = new VirtualAudioSourceSettings
{
     Channels = 2,
     SampleRate = 44100,
};

var audioSource = new VirtualAudioSourceBlock(virtualAudioSource);

// H264/AAC encoders
var h264Encoder = new H264EncoderBlock(new OpenH264EncoderSettings());
var aacEncoder = new AACEncoderBlock();

pipeline.Connect(videoSource.Output, h264Encoder.Input);
pipeline.Connect(audioSource.Output, aacEncoder.Input);

// RTMP sink
var sink = new RTMPSinkBlock(new RTMPSinkSettings());
pipeline.Connect(h264Encoder.Output, sink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output, sink.CreateNewInput(MediaBlockPadMediaType.Audio));

// Start
await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Facebook Live

Facebook Live is a feature that allows live streaming of video on Facebook. The livestream can be published to personal profiles, pages, or groups.

Use the `FacebookLiveSinkSettings` class to set the parameters.

#### Block info

Name: FacebookLiveSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/mpeg [1,2,4] | one |
|  | audio/x-adpcm |  |
|  | PCM [U8, S16LE] |  |
|  | audio/x-speex |  |
|  | audio/x-mulaw |  |
|  | audio/x-alaw |  |
|  | audio/x-nellymoser |  |
| Input video | video/x-h264 | one |

#### The sample pipeline

```
graph LR;
    VirtualVideoSourceBlock-->H264EncoderBlock;
    VirtualAudioSourceBlock-->AACEncoderBlock;
    H264EncoderBlock-->FacebookLiveSinkBlock;
    AACEncoderBlock-->FacebookLiveSinkBlock;
```

#### Sample code

```
// Pipeline
var pipeline = new MediaBlocksPipeline();

// video and audio sources
var virtualVideoSource = new VirtualVideoSourceSettings
{
    Width = 1280,
    Height = 720,
    FrameRate = VideoFrameRate.FPS_25,
};

var videoSource = new VirtualVideoSourceBlock(virtualVideoSource);

var virtualAudioSource = new VirtualAudioSourceSettings
{
     Channels = 2,
     SampleRate = 44100,
};

var audioSource = new VirtualAudioSourceBlock(virtualAudioSource);

// H264/AAC encoders
var h264Encoder = new H264EncoderBlock(new OpenH264EncoderSettings());
var aacEncoder = new AACEncoderBlock();

pipeline.Connect(videoSource.Output, h264Encoder.Input);
pipeline.Connect(audioSource.Output, aacEncoder.Input);

// Facebook Live sink — FacebookLiveSinkSettings takes the stream KEY only.
var sink = new FacebookLiveSinkBlock(new FacebookLiveSinkSettings("your_stream_key"));
pipeline.Connect(h264Encoder.Output, sink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output, sink.CreateNewInput(MediaBlockPadMediaType.Audio));

// Start
await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### HLS

HLS (HTTP Live Streaming) is an HTTP-based adaptive streaming communications protocol developed by Apple. It enables adaptive bitrate streaming by breaking the stream into a sequence of small HTTP-based file segments.

The HLS sink supports multiple implementations: - **hlssink3** (recommended): Latest implementation with MPEG-TS segments and advanced features - **hlsmultivariantsink**: Multi-bitrate adaptive streaming with automatic master playlist generation - **hlscmafsink**: CMAF/fMP4 segments for better compatibility with modern players - **hlssink2** (legacy): Original implementation with MPEG-TS segments

Use the `HLSSinkSettings` class to configure parameters. The sink automatically selects the best available implementation by default.

#### Block info

Name: HLSSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/mpeg | one or more |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
|  | audio/AAC |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |
|  | video/x-h265 |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AACEncoderBlock;
    UniversalSourceBlock-->H264EncoderBlock1;
    UniversalSourceBlock-->H264EncoderBlock2;
    UniversalSourceBlock-->H264EncoderBlock3;
    AACEncoderBlock-->HLSSinkBlock;
    H264EncoderBlock1-->HLSSinkBlock;
    H264EncoderBlock2-->HLSSinkBlock;
    H264EncoderBlock3-->HLSSinkBlock;
```

#### Sample code

##### Basic HLS Streaming (Auto mode)

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new AACEncoderBlock(new AACEncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

// 3 video encoders with different bitrates for adaptive streaming
var videoEncoderBlock1 = new H264EncoderBlock(new OpenH264EncoderSettings { Bitrate = 3000, Width = 1920, Height = 1080 });
var videoEncoderBlock2 = new H264EncoderBlock(new OpenH264EncoderSettings { Bitrate = 1500, Width = 1280, Height = 720 });
var videoEncoderBlock3 = new H264EncoderBlock(new OpenH264EncoderSettings { Bitrate = 800, Width = 854, Height = 480 });

pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock1.Input);
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock2.Input);
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock3.Input);

// Configure HLS sink with automatic selection (prefers hlssink3)
var hlsSettings = new HLSSinkSettings()
{
    Location = @"c:\inetpub\wwwroot\hls\segment_%05d.ts",
    PlaylistLocation = @"c:\inetpub\wwwroot\hls\playlist.m3u8",
    PlaylistRoot = "http://localhost/hls/",
    TargetDuration = TimeSpan.FromSeconds(6),
    PlaylistLength = 5,
    MaxFiles = 10,
    PlaylistType = HLSPlaylistType.Event,
    Custom_HTTP_Server_Enabled = true,
    Custom_HTTP_Server_Port = 8080
};

var sinkBlock = new HLSSinkBlock(hlsSettings);

// Connect audio
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));

// Connect video variants
pipeline.Connect(videoEncoderBlock1.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(videoEncoderBlock2.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(videoEncoderBlock3.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

##### CMAF/fMP4 Streaming (for better compatibility)

```
// Configure HLS sink with CMAF/fMP4 segments
var hlsSettings = new HLSSinkSettings()
{
    SinkType = HLSSinkType.HlsCmafSink,
    Location = @"c:\inetpub\wwwroot\hls\segment_%05d.m4s",
    InitLocation = @"c:\inetpub\wwwroot\hls\init_%03d.mp4",
    PlaylistLocation = @"c:\inetpub\wwwroot\hls\playlist.m3u8",
    TargetDuration = TimeSpan.FromSeconds(6),
    PlaylistType = HLSPlaylistType.Event,
    EnableProgramDateTime = true,
    Sync = true  // Required for live streaming with CMAF
};

var sinkBlock = new HLSSinkBlock(hlsSettings);
// Connect streams as in the basic example
```

##### VOD (Video on Demand) Streaming

```
// Configure HLS sink for VOD
var hlsSettings = new HLSSinkSettings()
{
    SinkType = HLSSinkType.HlsSink3,
    Location = @"c:\videos\hls\segment_%05d.ts",
    PlaylistLocation = @"c:\videos\hls\playlist.m3u8",
    TargetDuration = TimeSpan.FromSeconds(10),
    PlaylistType = HLSPlaylistType.Vod,  // VOD mode
    EnableEndlist = true,  // Adds #EXT-X-ENDLIST tag
    PlaylistLength = 0  // Keep all segments for VOD
};

var sinkBlock = new HLSSinkBlock(hlsSettings);
// Connect streams as in the basic example
```

##### Multi-Variant Adaptive Streaming (Master Playlist)

```
// Configure HLS sink with multivariant support for true adaptive bitrate streaming
var hlsSettings = new HLSSinkSettings()
{
    SinkType = HLSSinkType.HlsMultivariantSink,
    PlaylistLocation = @"c:\inetpub\wwwroot\hls\master.m3u8",
    TargetDuration = TimeSpan.FromSeconds(6)
};

var sinkBlock = new HLSSinkBlock(hlsSettings);

// Connect multiple video variants with different qualities
// hlsmultivariantsink automatically creates variant playlists and master playlist
pipeline.Connect(videoEncoderBlock1.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(videoEncoderBlock2.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(videoEncoderBlock3.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
```

#### HLS Sink Features

##### Sink Types

- **Auto** (default): Automatically selects the best available implementation (prefers hlssink3 → hlsmultivariantsink → hlscmafsink → hlssink2)
- **HlsSink3**: Latest implementation with MPEG-TS segments, supports playlist types, program date time, and improved features
- **HlsMultivariantSink**: Multi-bitrate adaptive streaming with automatic master playlist generation for multiple quality variants
- **HlsCmafSink**: CMAF/fMP4 segments for better compatibility with modern browsers and players
- **HlsSink2**: Legacy implementation for backward compatibility

##### Playlist Types

- **Unspecified**: Live streaming without explicit playlist type tag
- **Event**: Event-style playlist where segments are not removed. #EXT-X-ENDLIST is added at the end
- **Vod**: Video on Demand playlist. Behaves like Event but sets #EXT-X-PLAYLIST-TYPE:VOD at completion

##### Key Settings

| Property | Description | Sink Support |
| --- | --- | --- |
| `SinkType` | Choose sink implementation (Auto, HlsSink2, HlsSink3, HlsCmafSink, HlsMultivariantSink) | All |
| `Location` | Segment file pattern (e.g., segment\_%05d.ts or .m4s) | All except HlsMultivariantSink |
| `InitLocation` | Init segment pattern for CMAF (e.g., init\_%03d.mp4) | HlsCmafSink |
| `PlaylistLocation` | Output playlist file path (.m3u8, master.m3u8 for multivariant) | All |
| `PlaylistRoot` | Base URL for segments in playlist | All except HlsMultivariantSink |
| `TargetDuration` | Target segment duration (TimeSpan) | All |
| `PlaylistLength` | Number of segments in playlist (0=unlimited) | All except HlsMultivariantSink |
| `MaxFiles` | Maximum files to keep on disk | All except HlsMultivariantSink |
| `PlaylistType` | Playlist type (Unspecified, Event, Vod) | HlsSink3, HlsCmafSink |
| `EnableProgramDateTime` | Add #EXT-X-PROGRAM-DATE-TIME tags | HlsSink3, HlsCmafSink |
| `EnableEndlist` | Add #EXT-X-ENDLIST at end | HlsSink3, HlsCmafSink |
| `IFramesOnly` | Create I-frames only playlist | HlsSink3 |
| `Sync` | Sync with clock (required for live CMAF) | HlsCmafSink |
| `Latency` | Latency (TimeSpan) | HlsCmafSink |
| `SendKeyframeRequests` | Request keyframes from encoder | HlsSink2, HlsSink3 |

#### Platforms

Windows, macOS, Linux, iOS, Android.

### MJPEG over HTTP

HTTP MJPEG (Motion JPEG) Live is a video streaming format where each video frame is compressed separately as a JPEG image and transmitted over HTTP. It is widely used in IP cameras and webcams due to its simplicity, although it is less efficient than modern codecs.

Construct via `new HTTPMJPEGLiveSinkBlock(int port)` — the block ships with a port-only ctor; the URL path is fixed (`http://<host>:<port>/`). There is no separate settings class.

#### Block info

Name: HTTPMJPEGLiveSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | video/x-raw | one |
|  | image/jpeg |  |

#### The sample pipeline

```
graph LR;
    VirtualVideoSourceBlock-->MJPEGEncoderBlock;
    MJPEGEncoderBlock-->HTTPMJPEGLiveSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create virtual video source
var virtualVideoSource = new VirtualVideoSourceSettings
{
    Width = 1280,
    Height = 720,
    FrameRate = VideoFrameRate.FPS_30,
};

var videoSource = new VirtualVideoSourceBlock(virtualVideoSource);

// MJPEG encoder
var mjpegEncoder = new MJPEGEncoderBlock(new MJPEGEncoderSettings { Quality = 80 });
pipeline.Connect(videoSource.Output, mjpegEncoder.Input);

// HTTP MJPEG server (port only — listens at http://<host>:8080/)
var sink = new HTTPMJPEGLiveSinkBlock(8080);
pipeline.Connect(mjpegEncoder.Output, sink.Input);

// Start
await pipeline.StartAsync();

Console.WriteLine("MJPEG stream available at http://localhost:8080/stream");
Console.WriteLine("Press any key to stop...");
Console.ReadKey();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

### NDI

NDI (Network Device Interface) is a royalty-free video transport standard developed by NewTek that enables video-compatible products to communicate, deliver, and receive broadcast-quality video in a high-quality, low-latency manner over standard Ethernet networks.

Use the `NDISinkSettings` class to set the parameters.

#### Block info

Name: NDISinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one |
| Input video | video/x-raw | one |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->NDISinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var sinkBlock = new NDISinkBlock(new NDISinkSettings("My NDI Stream"));
// NDISinkBlock exposes dynamic pads via CreateNewInput — no fixed AudioInput/VideoInput properties.
pipeline.Connect(fileSource.AudioOutput, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(fileSource.VideoOutput, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux.

### SRT

SRT (Secure Reliable Transport) is an open source video transport protocol that enables the delivery of high-quality, secure, low-latency video across unpredictable networks like the public internet. It was developed by Haivision.

Use the `SRTSinkSettings` class to set the parameters.

#### Block info

Name: SRTSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any stream format | 1 |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SRTSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Create SRT sink in caller mode (connecting to a listener).
// SRTSinkBlock carries MPEG-TS internally — connect encoded elementary streams directly.
var srtSettings = new SRTSinkSettings
{
    Host = "srt-server.example.com",
    Port = 1234,
    Mode = SRTMode.Caller,
    Latency = 200, // milliseconds
    Passphrase = "optional-encryption-passphrase"
};

var srtSink = new SRTSinkBlock(srtSettings);
pipeline.Connect(fileSource.AudioOutput, srtSink.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(fileSource.VideoOutput, srtSink.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### SRT MPEG-TS

SRT MPEG-TS is a combination of the SRT transport protocol with MPEG-TS container format. This allows secure, reliable transport of MPEG-TS streams over public networks, which is useful for broadcast and professional video workflows.

Use the `SRTMPEGTSSinkSettings` class to set the parameters.

#### Block info

Name: SRTMPEGTSSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/mpeg |  |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
|  | audio/AAC |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |
|  | video/x-h265 |  |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AACEncoderBlock;
    UniversalSourceBlock-->H264EncoderBlock;
    AACEncoderBlock-->SRTMPEGTSSinkBlock;
    H264EncoderBlock-->SRTMPEGTSSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new AACEncoderBlock(new AACEncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

var videoEncoderBlock = new H264EncoderBlock(new OpenH264EncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

// Configure SRT MPEG-TS sink
var srtMpegtsSinkSettings = new SRTMPEGTSSinkSettings
{
    Host = "srt-server.example.com",
    Port = 1234,
    Mode = SRTMode.Caller,
    Latency = 200,
    Passphrase = "optional-encryption-passphrase"
};

var sinkBlock = new SRTMPEGTSSinkBlock(srtMpegtsSinkSettings);
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### YouTube Live

YouTube Live is a live streaming service provided by YouTube. It allows creators to broadcast live videos to their audience through the YouTube platform.

Use the `YouTubeSinkSettings` class to set the parameters.

#### Block info

Name: YouTubeSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/mpeg [1,2,4] | one |
|  | audio/x-adpcm |  |
|  | PCM [U8, S16LE] |  |
|  | audio/x-speex |  |
|  | audio/x-mulaw |  |
|  | audio/x-alaw |  |
|  | audio/x-nellymoser |  |
| Input video | video/x-h264 | one |

#### The sample pipeline

```
graph LR;
    VirtualVideoSourceBlock-->H264EncoderBlock;
    VirtualAudioSourceBlock-->AACEncoderBlock;
    H264EncoderBlock-->YouTubeSinkBlock;
    AACEncoderBlock-->YouTubeSinkBlock;
```

#### Sample code

```
// Pipeline
var pipeline = new MediaBlocksPipeline();

// video and audio sources
var virtualVideoSource = new VirtualVideoSourceSettings
{
    Width = 1920,
    Height = 1080,
    FrameRate = VideoFrameRate.FPS_30,
};

var videoSource = new VirtualVideoSourceBlock(virtualVideoSource);

var virtualAudioSource = new VirtualAudioSourceSettings
{
     Channels = 2,
     SampleRate = 48000,
};

var audioSource = new VirtualAudioSourceBlock(virtualAudioSource);

// H264/AAC encoders
var h264Settings = new OpenH264EncoderSettings
{
    Bitrate = 4000, // 4 Mbps for 1080p
    KeyframeInterval = 2 // Keyframe every 2 seconds
};
var h264Encoder = new H264EncoderBlock(h264Settings);

var aacSettings = new AACEncoderSettings
{
    Bitrate = 192 // 192 kbps for audio
};
var aacEncoder = new AACEncoderBlock(aacSettings);

pipeline.Connect(videoSource.Output, h264Encoder.Input);
pipeline.Connect(audioSource.Output, aacEncoder.Input);

// YouTube Live sink — YouTubeSinkSettings takes the stream KEY only.
var sink = new YouTubeSinkBlock(new YouTubeSinkSettings("your_youtube_stream_key"));
pipeline.Connect(h264Encoder.Output, sink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output, sink.CreateNewInput(MediaBlockPadMediaType.Audio));

// Start
await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Shoutcast

`Shoutcast` is a service for streaming media over the internet to media players, using its own cross-platform proprietary software. It allows digital audio content, primarily in MP3 or High-Efficiency Advanced Audio Coding (HE-AAC) format, to be broadcast. The most common use of Shoutcast is for creating or listening to Internet audio broadcasts.

Use the `ShoutcastSinkSettings` class to set the parameters.

#### Block info

Name: ShoutcastSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/mpeg | one |
|  | audio/aac |  |
|  | audio/x-aac |  |

#### The sample pipeline

```
graph LR;
    subgraph MainPipeline
        direction LR
        A[Audio Source e.g. UniversalSourceBlock or VirtualAudioSourceBlock] --> B{Optional Audio Encoder e.g. MP3EncoderBlock};
        B --> C[ShoutcastSinkBlock];
    end
    subgraph AlternativeIfSourceEncoded
         A2[Encoded Audio Source] --> C2[ShoutcastSinkBlock];
    end
```

#### Sample code

```
// Pipeline
var pipeline = new MediaBlocksPipeline();

// Audio source (e.g., from a file with MP3/AAC or raw audio)
var universalSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("input.mp3"));
// Or use VirtualAudioSourceBlock for live raw audio input:
// var audioSource = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings { Channels = 2, SampleRate = 44100 });

// Optional: Audio Encoder (if source is raw audio or needs re-encoding for Shoutcast)
// Example: MP3EncoderBlock if Shoutcast server expects MP3
var mp3Encoder = new MP3EncoderBlock(new MP3EncoderSettings() { Bitrate = 128000 }); // Bitrate in bps
pipeline.Connect(universalSource.AudioOutput, mp3Encoder.Input);
// If using VirtualAudioSourceBlock: pipeline.Connect(audioSource.Output, mp3Encoder.Input);

// Shoutcast sink
// Configure the Shoutcast/Icecast server connection details
var shoutcastSettings = new ShoutcastSinkSettings
{
    IP = "your-shoutcast-server-ip", // Server hostname or IP address
    Port = 8000,                      // Server port
    Mount = "/mountpoint",            // Mount point (e.g., "/stream", "/live.mp3")
    Password = "your-password",         // Source password for the server
    Protocol = ShoutProtocol.ICY,     // ShoutProtocol.ICY for Shoutcast v1/v2 (e.g., icy://)
                                      // ShoutProtocol.HTTP for Icecast 2.x (e.g., http://)
                                      // ShoutProtocol.XAudiocast for older Shoutcast/XAudioCast

    // Metadata for the stream
    StreamName = "My Radio Stream",
    Genre = "Various",
    Description = "My awesome internet radio station",
    URL = "https://my-radio-website.com", // Homepage URL for your stream (shows up in directory metadata)
    Public = true,                       // Set to true to list on public directories (if server supports)
    Username = "source"                  // Username for authentication (often "source"; check server config)
    // Other stream parameters like audio bitrate, samplerate, channels are typically determined
    // by the properties of the encoded input audio stream fed to the ShoutcastSinkBlock.
};
var shoutcastSink = new ShoutcastSinkBlock(shoutcastSettings);

// Connect encoder's output (or source's audio output if already encoded and compatible) to Shoutcast sink
pipeline.Connect(mp3Encoder.Output, shoutcastSink.Input);
// If source is already encoded and compatible (e.g. MP3 file to MP3 Shoutcast):
// pipeline.Connect(universalSource.AudioOutput, shoutcastSink.Input);

// Start the pipeline
await pipeline.StartAsync();

// For display purposes, you can construct a string representing the connection:
string protocolScheme = shoutcastSettings.Protocol switch
{
    ShoutProtocol.ICY => "icy",
    ShoutProtocol.HTTP => "http",
    ShoutProtocol.XAudiocast => "xaudiocast", // Note: actual scheme might be http for XAudiocast
    _ => "unknown"
};
Console.WriteLine($"Streaming to Shoutcast server: {protocolScheme}://{shoutcastSettings.IP}:{shoutcastSettings.Port}{shoutcastSettings.Mount}");
Console.WriteLine($"Stream metadata URL (for directories): {shoutcastSettings.URL}");
Console.WriteLine("Press any key to stop the stream...");
Console.ReadKey();

// Stop the pipeline (important for graceful disconnection and resource cleanup)
await pipeline.StopAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

---

### DASH

The `DASHSinkBlock` creates MPEG-DASH (Dynamic Adaptive Streaming over HTTP) output — an MPD manifest and media segments — compatible with any DASH-capable player. It supports both VOD (static) and live (dynamic) streaming modes. Multiple video and audio streams can be connected simultaneously to create adaptive bitrate manifests.

#### Block info

Name: DASHSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | video/x-h264 | one or more |
|  | video/x-h265 |  |
|  | video/x-vp9 |  |
|  | video/x-av1 |  |
| Input audio | audio/mpeg | one or more |
|  | audio/x-aac |  |
|  | audio/x-opus |  |

#### Settings

Use `DASHSinkSettings` to configure the DASH output:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `MPDFilename` | `string` | `c:\inetpub\wwwroot\dash\manifest.mpd` | Full path for the MPD manifest file |
| `MPDBaseURL` | `string` | `""` | Base URL prepended to segment filenames in the manifest |
| `TargetDuration` | `TimeSpan` | 5 s | Target duration per media segment |
| `MinBufferTime` | `TimeSpan` | 2 s | Minimum buffer time advertised in the manifest |
| `Dynamic` | `bool` | `false` | `false` = VOD/static; `true` = live stream |
| `PresentationDelay` | `TimeSpan` | 0 | Presentation delay (live only) |
| `MinimumUpdatePeriod` | `TimeSpan` | 0 | MPD refresh interval (live only) |
| `TimeShiftBufferDepth` | `TimeSpan` | 0 | DVR window depth (live only) |
| `SendKeyframeRequests` | `bool` | `true` | Request keyframes at segment boundaries |
| `Custom_HTTP_Server_Enabled` | `bool` | `false` | Enable built-in HTTP server for serving segments |
| `Custom_HTTP_Server_Port` | `int` | 80 | Port for the built-in HTTP server |

Call `settings.CheckAndCreateFolders()` before starting the pipeline to ensure the output directory exists.

Input pads are created dynamically: call `dashSink.CreateNewInput(MediaBlockPadMediaType.Video)` or `dashSink.CreateNewInput(MediaBlockPadMediaType.Audio)` to obtain a pad, then connect your encoder output to it.

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock -- Raw Video --> H264EncoderBlock;
    UniversalSourceBlock -- Raw Audio --> AACEncoderBlock;
    H264EncoderBlock -- H.264 Video --> DASHSinkBlock;
    AACEncoderBlock -- AAC Audio --> DASHSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var dashSettings = new DASHSinkSettings
{
    MPDFilename = @"c:\output\dash\manifest.mpd",
    MPDBaseURL = "http://localhost/dash/",
    TargetDuration = TimeSpan.FromSeconds(5),
    Dynamic = false // VOD/static mode; set true for live streaming
};
dashSettings.CheckAndCreateFolders();
var dashSink = new DASHSinkBlock(dashSettings);

var universalSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("input.mp4"));
var h264Encoder = new H264EncoderBlock(new OpenH264EncoderSettings());
var aacEncoder = new AACEncoderBlock();

pipeline.Connect(universalSource.VideoOutput, h264Encoder.Input);
pipeline.Connect(universalSource.AudioOutput, aacEncoder.Input);
pipeline.Connect(h264Encoder.Output, dashSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output, dashSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

#### Availability

Check availability using `DASHSinkBlock.IsAvailable()`. Requires the GStreamer `dash` plugin and the correct VisioForge SDK redistribution package.

#### Platforms

Windows, macOS, Linux.

---

### WHIP

The `WHIPSinkBlock` streams media to WebRTC servers using the WHIP (WebRTC-HTTP Ingestion Protocol), enabling low-latency live streaming to services such as MediaMTX, Janus, Cloudflare Stream, and other WHIP-compatible endpoints. Video must be H.264 encoded and audio must be Opus encoded — RTP payloading is handled internally by the block.

#### Block info

Name: WHIPSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | video/x-h264 | 1 |
| Input audio | audio/x-opus | 1 |

#### Settings

Use `WHIPSinkSettings` to configure the WHIP endpoint:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Location` | `string` | `http://localhost:8889/stream/whip` | WHIP endpoint URL |
| `AuthToken` | `string` | `null` | Bearer token sent in the `Authorization` HTTP header |
| `StunServer` | `string` | `null` | STUN server URL (format: `stun://hostname:port`) |
| `TurnServer` | `string` | `null` | TURN server URL (format: `turn(s)://username:password@host:port`) |
| `UseLinkHeaders` | `bool` | `true` | Auto-configure ICE servers from WHIP server response `Link` headers |
| `Timeout` | `TimeSpan` | 15 s | Timeout for WHIP HTTP requests |
| `IceTransportPolicy` | `WHIPIceTransportPolicy` | `All` | `All` = use STUN and TURN; `Relay` = TURN relay only |

Input pads are created dynamically: call `whipSink.CreateNewInput(MediaBlockPadMediaType.Video)` and `whipSink.CreateNewInput(MediaBlockPadMediaType.Audio)` to obtain pads, then connect your encoders.

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock -- Raw Video --> H264EncoderBlock;
    UniversalSourceBlock -- Raw Audio --> OPUSEncoderBlock;
    H264EncoderBlock -- H.264 Video --> WHIPSinkBlock;
    OPUSEncoderBlock -- Opus Audio --> WHIPSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var whipSettings = new WHIPSinkSettings
{
    Location = "http://localhost:8889/live/whip",
    AuthToken = "your-bearer-token", // optional
    StunServer = "stun://stun.l.google.com:19302"
};
var whipSink = new WHIPSinkBlock(whipSettings);

var universalSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("input.mp4"));
var h264Encoder = new H264EncoderBlock(new OpenH264EncoderSettings());
var opusEncoder = new OPUSEncoderBlock();

pipeline.Connect(universalSource.VideoOutput, h264Encoder.Input);
pipeline.Connect(universalSource.AudioOutput, opusEncoder.Input);
pipeline.Connect(h264Encoder.Output, whipSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(opusEncoder.Output, whipSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

#### Availability

Check availability using `WHIPSinkBlock.IsAvailable()`. Requires the GStreamer `webrtc` plugin and the correct VisioForge SDK redistribution package.

#### Platforms

Windows, macOS, Linux.

### RIST MPEG-TS

The `RISTMPEGTSSinkBlock` multiplexes audio and video streams into MPEG-TS, wraps the transport in RTP, and sends it over RIST (Reliable Internet Stream Transport). RIST adds ARQ-based retransmission over UDP, providing reliable low-latency media delivery without the overhead of TCP.

Multiple audio and video input pads are supported. Call `CreateNewInput(MediaBlockPadMediaType.Video)` and `CreateNewInput(MediaBlockPadMediaType.Audio)` to obtain pads before connecting encoders.

#### Block info

Name: RISTMPEGTSSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Encoded video | Dynamic |
| Input audio | Encoded audio | Dynamic |

#### Settings

Use `RISTSinkSettings` to configure the destination:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Address` | `string` | `"localhost"` | Destination IPv4 or IPv6 address |
| `Port` | `uint` | `5004` | Destination RTP port (must be even; RTCP uses Port + 1) |
| `SenderBuffer` | `TimeSpan` | 1200 ms | Retransmission queue size |
| `BondingAddresses` | `string` | `null` | Comma-separated `address:port` pairs for bonding; overrides Address/Port |
| `BondingMethod` | `RISTBondingMethod` | `Broadcast` | `Broadcast` = send to all destinations; `RoundRobin` = alternate |
| `MulticastInterface` | `string` | `null` | Network interface for multicast |
| `MulticastTTL` | `int` | `1` | Multicast time-to-live |
| `DropNullTSPackets` | `bool` | `false` | Remove null MPEG-TS padding packets |
| `SequenceNumberExtension` | `bool` | `false` | Add RTP sequence number extension |
| `MinRTCPInterval` | `uint` | `100` | Minimum RTCP packet interval (ms) |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock -- Raw Video --> H264EncoderBlock;
    UniversalSourceBlock -- Raw Audio --> AACEncoderBlock;
    H264EncoderBlock --> RISTMPEGTSSinkBlock;
    AACEncoderBlock --> RISTMPEGTSSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("input.mp4"));

var h264Encoder = new H264EncoderBlock(new OpenH264EncoderSettings());
var aacEncoder = new AACEncoderBlock();

pipeline.Connect(source.VideoOutput, h264Encoder.Input);
pipeline.Connect(source.AudioOutput, aacEncoder.Input);

var ristSettings = new RISTSinkSettings
{
    Address = "192.168.1.100",
    Port = 5004,
    SenderBuffer = TimeSpan.FromMilliseconds(1200)
};

var ristSink = new RISTMPEGTSSinkBlock(ristSettings);
pipeline.Connect(h264Encoder.Output, ristSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output, ristSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

#### Availability

`RISTMPEGTSSinkBlock.IsAvailable()` returns `true` if the GStreamer `rist` plugin is present.

#### Platforms

Windows, macOS, Linux.

### UDP

UDP (User Datagram Protocol) is a lightweight, connectionless transport protocol that provides low-latency streaming with minimal overhead. Unlike TCP-based protocols, UDP doesn't guarantee packet delivery, making it ideal for real-time applications where speed is crucial.

Use the `UDPSinkSettings` class to set the parameters.

#### Block info

Name: UDPSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any stream format | 1 |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->UDPMPEGTSSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// UDPMPEGTSSinkBlock wraps the MPEG-TS muxer internally —
// connect encoded elementary streams directly via CreateNewInput.
var udpSettings = new UDPSinkSettings
{
    Host = "192.168.1.100",
    Port = 5004
};
var udpSink = new UDPMPEGTSSinkBlock(udpSettings);
pipeline.Connect(fileSource.AudioOutput, udpSink.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(fileSource.VideoOutput, udpSink.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### UDP MPEG-TS

UDP MPEG-TS combines MPEG-TS multiplexing with UDP transport. This allows low-latency delivery of multiplexed audio and video streams over UDP, which is widely used in broadcast, IPTV, and video surveillance workflows.

Use the `UDPSinkSettings` class to set the parameters.

#### Block info

Name: UDPMPEGTSSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/mpeg |  |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
|  | audio/AAC |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |
|  | video/x-h265 |  |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Host` | `string` | `"localhost"` | Destination host/IP/multicast group |
| `Port` | `int` | `5004` | Destination port |
| `TTL` | `int` | `64` | Unicast time-to-live |
| `MulticastTTL` | `int` | `1` | Multicast time-to-live |
| `AutoMulticast` | `bool` | `true` | Auto join/leave multicast groups |
| `MulticastInterface` | `string` | `null` | Network interface for multicast |
| `Loop` | `bool` | `true` | Multicast loopback |
| `BufferSize` | `int` | `0` | Kernel send buffer size (0 = default) |
| `QosDscp` | `int` | `-1` | DSCP value (-1 = default) |
| `BindAddress` | `string` | `null` | Local address to bind |
| `BindPort` | `int` | `0` | Local port to bind (0 = auto) |
| `MuxerLatency` | `TimeSpan` | 1000 ms | MPEG-TS muxer aggregator latency |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AACEncoderBlock;
    UniversalSourceBlock-->H264EncoderBlock;
    AACEncoderBlock-->UDPMPEGTSSinkBlock;
    H264EncoderBlock-->UDPMPEGTSSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var audioEncoderBlock = new AACEncoderBlock(new AACEncoderSettings() { Bitrate = 192 });
pipeline.Connect(fileSource.AudioOutput, audioEncoderBlock.Input);

var videoEncoderBlock = new H264EncoderBlock(new OpenH264EncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

// Configure UDP MPEG-TS sink
var udpSettings = new UDPSinkSettings
{
    Host = "192.168.1.100",
    Port = 5004,
    TTL = 64
};

var sinkBlock = new UDPMPEGTSSinkBlock(udpSettings);
pipeline.Connect(audioEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Availability

`UDPMPEGTSSinkBlock.IsAvailable()` returns `true` if the GStreamer `udp` plugin is present.

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Multi-destination UDP

The `MultiUDPSinkBlock` sends raw data over UDP to one or multiple recipients simultaneously. Destinations are specified as comma-separated host:port pairs and can be managed using helper methods on the settings class.

Use the `MultiUDPSinkSettings` class to set the parameters.

#### Block info

Name: MultiUDPSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any stream format | 1 |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MultiUDPMPEGTSSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// MultiUDPMPEGTSSinkBlock wraps the MPEG-TS muxer internally —
// register destinations via AddClient, connect elementary streams via CreateNewInput.
var multiUdpSettings = new MultiUDPSinkSettings();
multiUdpSettings.AddClient("192.168.1.100", 5004);
multiUdpSettings.AddClient("192.168.1.101", 5004);

var multiUdpSink = new MultiUDPMPEGTSSinkBlock(multiUdpSettings);
pipeline.Connect(fileSource.AudioOutput, multiUdpSink.CreateNewInput(MediaBlockPadMediaType.Audio));
pipeline.Connect(fileSource.VideoOutput, multiUdpSink.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Multi-destination UDP MPEG-TS

The `MultiUDPMPEGTSSinkBlock` multiplexes audio and video streams into MPEG-TS and sends the result over UDP to one or more destinations simultaneously. This is useful for broadcasting the same stream to multiple receivers, recording servers, or redundant endpoints.

Multiple audio and video input pads are supported. Call `CreateNewInput(MediaBlockPadMediaType.Video)` and `CreateNewInput(MediaBlockPadMediaType.Audio)` to obtain pads before connecting encoders.

#### Block info

Name: MultiUDPMPEGTSSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input audio | audio/x-raw | one or more |
|  | audio/mpeg |  |
|  | audio/x-ac3 |  |
|  | audio/x-alaw |  |
|  | audio/x-mulaw |  |
|  | audio/AAC |  |
| Input video | video/x-raw | one or more |
|  | image/jpeg |  |
|  | video/x-msmpeg |  |
|  | video/mpeg |  |
|  | video/x-h263 |  |
|  | video/x-h264 |  |
|  | video/x-h265 |  |

#### Settings

Use `MultiUDPSinkSettings` to configure the destinations:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Clients` | `string` | `""` | Comma-separated `host:port` pairs |
| `SendDuplicates` | `bool` | `true` | Send duplicates when same destination is added multiple times |
| `TTL` | `int` | `64` | Unicast time-to-live |
| `MulticastTTL` | `int` | `1` | Multicast time-to-live |
| `AutoMulticast` | `bool` | `true` | Auto join/leave multicast groups |
| `MulticastInterface` | `string` | `null` | Network interface for multicast |
| `Loop` | `bool` | `true` | Multicast loopback |
| `BufferSize` | `int` | `0` | Kernel send buffer size (0 = default) |
| `QosDscp` | `int` | `-1` | DSCP value (-1 = default) |
| `BindAddress` | `string` | `null` | Local address to bind |
| `BindPort` | `int` | `0` | Local port to bind (0 = auto) |
| `MuxerLatency` | `TimeSpan` | 1000 ms | MPEG-TS muxer aggregator latency |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock -- Raw Video --> H264EncoderBlock;
    UniversalSourceBlock -- Raw Audio --> AACEncoderBlock;
    H264EncoderBlock --> MultiUDPMPEGTSSinkBlock;
    AACEncoderBlock --> MultiUDPMPEGTSSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("input.mp4"));

var h264Encoder = new H264EncoderBlock(new OpenH264EncoderSettings());
var aacEncoder = new AACEncoderBlock();

pipeline.Connect(source.VideoOutput, h264Encoder.Input);
pipeline.Connect(source.AudioOutput, aacEncoder.Input);

var multiUdpSettings = new MultiUDPSinkSettings();
multiUdpSettings.AddClient("192.168.1.100", 5004);
multiUdpSettings.AddClient("192.168.1.101", 5004);

var multiUdpSink = new MultiUDPMPEGTSSinkBlock(multiUdpSettings);
pipeline.Connect(h264Encoder.Output, multiUdpSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output, multiUdpSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

#### Availability

`MultiUDPMPEGTSSinkBlock.IsAvailable()` returns `true` if the GStreamer `udp` plugin is present.

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Utility Sinks

### Stream Sink

The `StreamSinkBlock` writes media data to any .NET `Stream` object, enabling flexible output to memory buffers, files, network connections, encryption layers, or any writable stream.

The stream must remain open and writable for the lifetime of the pipeline. The block does not dispose the stream when the pipeline stops.

#### Block info

Name: StreamSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any | 1 |

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

using var outputStream = new FileStream("output.raw", FileMode.Create, FileAccess.Write);
var streamSink = new StreamSinkBlock(outputStream);
pipeline.Connect(fileSource.VideoOutput, streamSink.Input);

await pipeline.StartAsync();
```

#### Availability

`StreamSinkBlock.IsAvailable()` returns `true` if the GStreamer `appsink` element is available.

#### Platforms

Windows, macOS, Linux, iOS, Android.

### File Descriptor Sink

The `FDSinkBlock` writes media data to a Unix file descriptor (an integer handle). This is useful for outputting to pipes, sockets, or stdin of a child process.

Pass `addQueue: true` (default) to add a buffering queue that prevents the pipeline from blocking on slow descriptor writes.

The descriptor must be open and writable before the pipeline starts. The block does not close it when the pipeline stops.

#### Block info

Name: FDSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any | 1 |

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Write to stdout (fd 1)
var fdSink = new FDSinkBlock(descriptor: 1);
pipeline.Connect(fileSource.VideoOutput, fdSink.Input);

await pipeline.StartAsync();
```

#### Availability

`FDSinkBlock.IsAvailable()` returns `true` if the GStreamer `fdsink` element is available.

#### Platforms

Linux, macOS. Limited support on Windows.

### KLV File Sink

The `KLVFileSinkBlock` writes KLV (Key-Length-Value) metadata streams to a file. KLV is used in MISB/STANAG 4609 compliant applications — including UAV video, surveillance, and aerospace — to embed geospatial metadata alongside video.

The block accepts `meta/x-klv` data on its input and writes it directly to the specified file via the GStreamer `filesink` element.

#### Block info

Name: KLVFileSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | meta/x-klv | 1 |

#### Sample code

```
// The SDK does not ship a dedicated KLV source block — KLV streams are produced
// by upstream MPEG-TS / MISB-aware sources or the application itself, then routed
// into KLVFileSinkBlock for file storage.
var pipeline = new MediaBlocksPipeline();

var klvFileSink = new KLVFileSinkBlock("output_metadata.klv");
pipeline.Connect(klvProducer.Output, klvFileSink.Input); // klvProducer = your KLV-emitting block

await pipeline.StartAsync();
```

For an end-to-end workflow — extracting KLV from an MPEG-TS file, decoding MISB ST 0601 elements, and muxing KLV back into MPEG-TS — see the [KLV / MISB Metadata in MPEG-TS](../Guides/klv-metadata-mpegts-csharp/) guide.

#### Platforms

Windows, macOS, Linux.

### Buffer Sink

The `BufferSinkBlock` captures media data into memory and delivers it frame-by-frame via event callbacks, instead of writing to a file or network. It supports video, audio, and arbitrary data streams.

Three constructors cover the common scenarios:

- `BufferSinkBlock(VideoFormatX, bool allowFrameDrop)` — video capture with optional format conversion
- `BufferSinkBlock(AudioFormatX, bool allowFrameDrop)` — audio capture with optional resampling
- `BufferSinkBlock()` — auto-detects the media type from the connected upstream element

Key events:

- `OnVideoFrameBuffer` — raised for each decoded video frame
- `OnAudioFrameBuffer` — raised for each decoded audio frame
- `OnDataFrameBuffer` — raised for non-AV data streams
- `OnSample` — low-level GStreamer sample access; when subscribed it suppresses the three events above. **Always dispose the sample after use** to prevent memory leaks.

Set `IsSync = false` for transcoding or analysis workflows where real-time pacing is not required.

#### Block info

Name: BufferSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `AllowFrameDrop` | `bool` | `false` | Drop frames when callbacks cannot keep up with the media rate |
| `IsSync` | `bool` | `true` | `true` = pace to real time; `false` = process as fast as possible |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->BufferSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("input.mp4"));

// VideoFormatX is an enum (one of BGRA / RGBA / NV12 / I420 / ...). Frame size and
// rate are inherited from the upstream caps; pass allowFrameDrop=true if your callback
// can fall behind the source.
var bufferSink = new BufferSinkBlock(VideoFormatX.BGRA, allowFrameDrop: false);
bufferSink.OnVideoFrameBuffer += (sender, e) =>
{
    // e.Frame contains pixel data, dimensions, and timestamp
    Console.WriteLine($"Frame at {e.Frame.Timestamp}: {e.Frame.Width}x{e.Frame.Height}");
};

pipeline.Connect(source.VideoOutput, bufferSink.Input);

await pipeline.StartAsync();
```

#### Availability

`BufferSinkBlock.IsAvailable()` returns `true` if the GStreamer `appsink` element is available.

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Virtual Camera Sink

The `VirtualCameraSinkBlock` exposes the pipeline output as a system virtual camera (and virtual microphone), so any other Windows application — Zoom, Teams, OBS, a browser — can pick up your processed video and audio as if it were a real capture device. Frames are delivered to the VisioForge Virtual Camera and Virtual Audio Card DirectShow source filters through shared memory.

Both inputs are optional: create a video input, an audio input, or both. Use `CreateNewInput(MediaBlockPadMediaType.Video)` and `CreateNewInput(MediaBlockPadMediaType.Audio)` to add the pads you need.

This block is **Windows-only**. The Virtual Camera and Virtual Audio Card source filters must be COM-registered on the machine before the virtual devices appear. Use `VirtualCameraSinkBlock.IsCOMRegistered()` to check, and `VirtualCameraSinkBlock.COMRegisterAsAdmin()` to register them with an elevation (UAC) prompt.

Configure the output with `VirtualCameraSinkSettings`.

#### Block info

Name: VirtualCameraSinkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | video/x-raw | zero or one |
| Input audio | audio/x-raw | zero or one |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Width` | `int` | `1280` | Video frame width in pixels (must be even) |
| `Height` | `int` | `720` | Video frame height in pixels |
| `FrameRate` | `double` | `30.0` | Target frame rate |
| `VideoStreamName` | `string` | `"VideoStream1"` | Shared-memory stream name; must match the virtual camera source filter |
| `AudioSampleRate` | `int` | `48000` | Audio sample rate in Hz |
| `AudioChannels` | `int` | `2` | Audio channel count (1 = mono, 2 = stereo) |
| `AudioBitsPerSample` | `int` | `16` | Audio bits per sample |
| `AudioStreamName` | `string` | `"AudioStream1"` | Shared-memory stream name; must match the virtual audio card source filter |
| `CustomVideoProcessor` | `MediaBlock` | `null` | Optional custom video processor block |
| `CustomAudioProcessor` | `MediaBlock` | `null` | Optional custom audio processor block |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VirtualCameraSinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("input.mp4"));

var settings = new VirtualCameraSinkSettings
{
    Width = 1280,
    Height = 720,
    FrameRate = 30.0
};

var virtualCameraSink = new VirtualCameraSinkBlock(settings);

// connect video and audio (both inputs are optional)
pipeline.Connect(source.VideoOutput, virtualCameraSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(source.AudioOutput, virtualCameraSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

#### Availability

`VirtualCameraSinkBlock.IsAvailable()` returns `true` if the underlying virtual camera sink is available on this system. `VirtualCameraSinkBlock.IsCOMRegistered()` returns `true` when both the Virtual Camera and Virtual Audio Card source filters are registered.

#### Platforms

Windows.

---END OF PAGE---


## Media Blocks SDK Sources — Webcam, File, RTSP, Screen in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Sources/
**Description:** Connect any input to a Media Blocks pipeline — webcams, video files, RTSP, RTMP, SRT, NDI, Decklink, screen, virtual. C# / .NET device enumeration API.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming, USB, UVC
**API:** VideoRendererBlock, MediaBlocksPipeline, AudioRendererBlock, UniversalSourceBlock, DeviceEnumerator, AndroidUVCSourceBlock

# Source Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Source blocks provide data to the pipeline and are typically the first blocks in any media processing chain. VisioForge Media Blocks SDK .Net provides a comprehensive collection of source blocks for various inputs including hardware devices, files, networks, and virtual sources.

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Hardware Source Blocks

### System Video Source

SystemVideoSourceBlock is used to access webcams and other video capture devices.

#### Block info

Name: SystemVideoSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | uncompressed video | 1 |

#### Enumerate available devices

Use the `DeviceEnumerator.Shared.VideoSourcesAsync()` method to get a list of available devices and their specifications: available resolutions, frame rates, and video formats. This method returns a list of `VideoCaptureDeviceInfo` objects. Each `VideoCaptureDeviceInfo` object provides detailed information about a capture device.

#### The sample pipeline

```
graph LR;
    SystemVideoSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create video source
VideoCaptureDeviceSourceSettings videoSourceSettings = null;

// select the first device
var device = (await DeviceEnumerator.Shared.VideoSourcesAsync())[0];
if (device != null)
{
    // select the first format (maybe not the best, but it is just a sample)
    var formatItem = device.VideoFormats[0];
    if (formatItem != null)
    {
        videoSourceSettings = new VideoCaptureDeviceSourceSettings(device)
        {
            Format = formatItem.ToFormat()
        };

        // select the first frame rate
        videoSourceSettings.Format.FrameRate = formatItem.FrameRateList[0];
    }
}

// create video source block using the selected device and format
var videoSource = new SystemVideoSourceBlock(videoSourceSettings);

// create video renderer block
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// connect blocks
pipeline.Connect(videoSource.Output, videoRenderer.Input);

// start pipeline
await pipeline.StartAsync();
```

#### Sample applications

- [Simple Video Capture Demo (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Simple%20Capture%20Demo)

#### Remarks

You can specify an API to use during the device enumeration (refer to the `VideoCaptureDeviceAPI` enum description under `SystemVideoSourceBlock` for typical values). Android and iOS platforms have only one API, while Windows and Linux have multiple APIs.

On Android this block enumerates cameras through Camera2, which sees a USB camera attached over OTG only on devices whose vendor ships the External Camera HAL - and many phones do not. To capture from a USB camera on Android, use the [USB (UVC) Camera Source Block](#usb-uvc-camera-source-block) instead.

#### Platforms

Windows, macOS, Linux, iOS, Android.

### System Audio Source

SystemAudioSourceBlock is used to access mics and other audio capture devices.

#### Block info

Name: SystemAudioSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output audio | uncompressed audio | 1 |

#### Enumerate available devices

Use the `DeviceEnumerator.Shared.AudioSourcesAsync()` method call to get a list of available devices and their specifications.

During device enumeration, you can get the list of available devices and their specifications. You can select the device and its format to create the source settings.

#### The sample pipeline

```
graph LR;
    SystemAudioSourceBlock-->AudioRendererBlock;
```

#### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create audio source block
IAudioCaptureDeviceSourceSettings audioSourceSettings = null;

// select first device
var device = (await DeviceEnumerator.Shared.AudioSourcesAsync())[0];
if (device != null)
{
    // select first format
    var formatItem = device.Formats[0];
    if (formatItem != null)
    {
        audioSourceSettings = device.CreateSourceSettings(formatItem.ToFormat());
    }
}

// create audio source block using selected device and format
var audioSource = new SystemAudioSourceBlock(audioSourceSettings);

// create audio renderer block
var audioRenderer = new AudioRendererBlock();

// connect blocks
pipeline.Connect(audioSource.Output, audioRenderer.Input);

// start pipeline
await pipeline.StartAsync();
```

#### Capture audio from speakers (loopback)

Currently, loopback audio capture is supported only on Windows. Use the `LoopbackAudioCaptureDeviceSourceSettings` class to create the source settings for loopback audio capture.

WASAPI2 is used as the default API for loopback audio capture. You can specify the API to use during device enumeration.

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create audio source block
var deviceItem = (await DeviceEnumerator.Shared.AudioOutputsAsync(AudioOutputDeviceAPI.WASAPI2))[0];
if (deviceItem == null)
{
    return;
}

var audioSourceSettings = new LoopbackAudioCaptureDeviceSourceSettings(deviceItem);
var audioSource = new SystemAudioSourceBlock(audioSourceSettings);

// create audio renderer block
var audioRenderer = new AudioRendererBlock();

// connect blocks
pipeline.Connect(audioSource.Output, audioRenderer.Input);

// start pipeline
await pipeline.StartAsync();
```

#### Sample applications

- [Audio Capture Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Audio%20Capture%20Demo)
- [Simple Capture Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Simple%20Capture%20Demo)

#### Remarks

You can specify an API to use during the device enumeration. Android and iOS platforms have only one API, while Windows and Linux have multiple APIs.

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Basler Source Block

The Basler source block supports Basler USB3 Vision and GigE cameras. The Pylon SDK or Runtime should be installed to use the camera source.

#### Block info

Name: BaslerSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed | 1 |

#### The sample pipeline

```
graph LR;
    BaslerSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// get Basler source info by enumerating sources
var sources = await DeviceEnumerator.Shared.BaslerSourcesAsync();
var sourceInfo = sources[0];

// create Basler source
var source = new BaslerSourceBlock(new BaslerSourceSettings(sourceInfo));

// create video renderer for VideoView
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// connect
pipeline.Connect(source.Output, videoRenderer.Input);

// start
await pipeline.StartAsync();
```

#### Sample applications

- [Basler Source Demo (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Basler%20Source%20Demo)

#### Platforms

Windows, Linux.

### Spinnaker/FLIR Source Block

The Spinnaker/FLIR source supports connection to FLIR cameras using Spinnaker SDK.

To use the `SpinnakerSourceBlock`, you first need to enumerate available Spinnaker cameras and then configure the source using `SpinnakerSourceSettings`.

#### Enumerate Devices & `SpinnakerCameraInfo`

Use `DeviceEnumerator.Shared.SpinnakerSourcesAsync()` to get a list of `SpinnakerCameraInfo` objects. Each `SpinnakerCameraInfo` provides details about a detected camera:

- `Name` (string): Unique identifier or name of the camera. Often a serial number or model-serial combination.
- `NetworkInterfaceName` (string): Name of the network interface if it's a GigE camera.
- `Vendor` (string): Camera vendor name.
- `Model` (string): Camera model name.
- `SerialNumber` (string): Camera's serial number.
- `FirmwareVersion` (string): Camera's firmware version.
- `SensorSize` (`Size`): Reports the sensor dimensions (Width, Height). You might need to call a method on `SpinnakerCameraInfo` like `ReadInfo()` (if available, or implied by enumeration) to populate this.
- `WidthMax` (int): Maximum sensor width.
- `HeightMax` (int): Maximum sensor height.

You select a `SpinnakerCameraInfo` object from the list to initialize `SpinnakerSourceSettings`.

#### Settings

The `SpinnakerSourceBlock` is configured using `SpinnakerSourceSettings`. Key properties:

- `Name` (string): The name of the camera (from `SpinnakerCameraInfo.Name`) to use.
- `Region` (`Rect`): Defines the Region of Interest (ROI) to capture from the camera sensor. Set X, Y, Width, Height.
- `FrameRate` (`VideoFrameRate`): The desired frame rate.
- `PixelFormat` (`SpinnakerPixelFormat` enum): The desired pixel format (e.g., `RGB`, `Mono8`, `BayerRG8`). Default `RGB`.
- `OffsetX` (int): X offset for the ROI on the sensor (default 0). Often implicitly part of `Region.X`.
- `OffsetY` (int): Y offset for the ROI on the sensor (default 0). Often implicitly part of `Region.Y`.
- `ExposureMinimum` (int): Minimum exposure time for auto-exposure algorithm (microseconds, e.g., 10-29999999). Default 0 (auto/camera default).
- `ExposureMaximum` (int): Maximum exposure time for auto-exposure algorithm (microseconds). Default 0 (auto/camera default).
- `ShutterType` (`SpinnakerSourceShutterType` enum): Type of shutter (e.g., `Rolling`, `Global`). Default `Rolling`.

Constructor: `SpinnakerSourceSettings(string name, Rect region, VideoFrameRate frameRate, SpinnakerPixelFormat pixelFormat = SpinnakerPixelFormat.RGB)`

#### Block info

Name: SpinnakerSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | various | one or more |

#### The sample pipeline

`SpinnakerSourceBlock:Output` → `VideoRendererBlock`

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var sources = await DeviceEnumerator.Shared.SpinnakerSourcesAsync();
var sourceSettings = new SpinnakerSourceSettings(sources[0].Name, new VisioForge.Core.Types.Rect(0, 0, 1280, 720), new VideoFrameRate(10));

var source = new SpinnakerSourceBlock(sourceSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(source.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Requirements

- Spinnaker SDK installed.

#### Platforms

Windows

### Allied Vision Source Block

The Allied Vision Source Block enables integration with Allied Vision cameras using the Vimba SDK. It allows capturing video streams from these industrial cameras.

#### Block info

Name: AlliedVisionSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    AlliedVisionSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Enumerate Allied Vision cameras
var alliedVisionCameras = await DeviceEnumerator.Shared.AlliedVisionSourcesAsync();
if (alliedVisionCameras.Count == 0)
{
    Console.WriteLine("No Allied Vision cameras found.");
    return;
}

var cameraInfo = alliedVisionCameras[0]; // Select the first camera

// Create Allied Vision source settings
// Width, height, x, y are optional and depend on whether you want to set a specific ROI
// If null, it might use default/full sensor resolution. Camera.ReadInfo() should be called.
cameraInfo.ReadInfo(); // Ensure camera info like Width/Height is read

var alliedVisionSettings = new AlliedVisionSourceSettings(
    cameraInfo,
    width: cameraInfo.Width, // Or a specific ROI width
    height: cameraInfo.Height // Or a specific ROI height
);

// Optionally configure other settings
alliedVisionSettings.ExposureAuto = VmbSrcExposureAutoModes.Continuous;
alliedVisionSettings.Gain = 10; // Example gain value

var alliedVisionSource = new AlliedVisionSourceBlock(alliedVisionSettings);

// Create video renderer
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1 is your display control

// Connect blocks
pipeline.Connect(alliedVisionSource.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Requirements

- Allied Vision Vimba SDK must be installed.

#### Sample applications

- Refer to samples demonstrating industrial camera integration if available.

#### Platforms

Windows, macOS, Linux.

### Blackmagic Decklink Source Block

For information about Decklink sources, see [Decklink](../Decklink/).

## File Source Blocks

### Universal Source Block

A universal source that decodes video and audio files/network streams and provides uncompressed data to the connected blocks.

Block supports MP4, WebM, AVI, TS, MKV, MP3, AAC, M4A, and many other formats. If FFMPEG redist is available, all decoders available in FFMPEG will also be supported.

#### Settings

The `UniversalSourceBlock` is configured through `UniversalSourceSettings`. It's recommended to create settings using the static factory method `await UniversalSourceSettings.CreateAsync(...)`.

Key properties and parameters for `UniversalSourceSettings`:

- **URI/Filename**:
- `UniversalSourceSettings.CreateAsync(string filename, bool renderVideo = true, bool renderAudio = true, bool renderSubtitle = false)`: Creates settings from a local file path.
- `UniversalSourceSettings.CreateAsync(System.Uri uri, bool renderVideo = true, bool renderAudio = true, bool renderSubtitle = false)`: Creates settings from a `System.Uri` (can be a file URI or network URI like HTTP, RTSP - though dedicated blocks are often preferred for network streams). For iOS, an `Foundation.NSUrl` is used.
- The `renderVideo`, `renderAudio`, `renderSubtitle` booleans control which streams are processed. The `CreateAsync` method may update these based on actual stream availability in the media file/stream if `ignoreMediaInfoReader` is `false` (default).
- `StartPosition` (`TimeSpan?`): Sets the starting position for playback.
- `StopPosition` (`TimeSpan?`): Sets the stopping position for playback.
- `VideoCustomFrameRate` (`VideoFrameRate?`): If set, video frames will be dropped or duplicated to match this custom frame rate.
- `UseAdvancedEngine` (bool): If `true` (default, except Android where it's `false`), uses an advanced engine with stream selection support.
- `DisableHWDecoders` (bool): If `true` (default `false`, except Android where it's `true`), hardware-accelerated decoders will be disabled, forcing software decoding.
- `MPEGTSProgramNumber` (int): For MPEG-TS streams, specifies the program number to select (default -1, meaning automatic selection or first program).
- `ReadInfoAsync()`: Asynchronously reads media file information (`MediaFileInfo`). This is called internally by `CreateAsync` unless `ignoreMediaInfoReader` is true.
- `GetInfo()`: Gets the cached `MediaFileInfo`.

The `UniversalSourceBlock` itself is then instantiated with these settings: `new UniversalSourceBlock(settings)`. The `Filename` property on `UniversalSourceBlock` instance (as seen in older examples) is a shortcut that internally creates basic `UniversalSourceSettings`. Using `UniversalSourceSettings.CreateAsync` provides more control.

#### Block info

Name: UniversalSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output audio | depends from decoder | one or more |
| Output video | depends from decoder | one or more |
| Output subtitle | depends from decoder | one or more |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoRendererBlock;
    UniversalSourceBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var sourceSettings = await UniversalSourceSettings.CreateAsync("test.mp4");
var fileSource = new UniversalSourceBlock(sourceSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(fileSource.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(fileSource.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Sample applications

- [Simple Player Demo (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Simple%20Player%20Demo%20WPF)

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Subtitle Source Block

The Subtitle Source Block loads subtitles from a file and outputs them as a subtitle stream, which can then be overlaid on video or rendered separately.

#### Block info

Name: `SubtitleSourceBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output subtitle | Subtitle data | 1 |

#### Settings

The `SubtitleSourceBlock` is configured using `SubtitleSourceSettings`. Key properties include:

- `Filename` (string): The path to the subtitle file (e.g., .srt, .ass).

#### The sample pipeline

```
graph LR;
    UniversalSourceBlock --> SubtitleOverlayBlock;
    SubtitleSourceBlock --> SubtitleOverlayBlock;
    SubtitleOverlayBlock --> VideoRendererBlock;
    UniversalSourceBlock --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create subtitle source settings
var subtitleSettings = new SubtitleSourceSettings("path/to/your/subtitles.srt");
var subtitleSource = new SubtitleSourceBlock(subtitleSettings);

// Example: Overlaying subtitles on a video from UniversalSourceBlock
var fileSource = await UniversalSourceSettings.CreateAsync("path/to/your/video.mp4");
var universalSource = new UniversalSourceBlock(fileSource);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
var audioRenderer = new AudioRendererBlock();

// This is a conceptual overlay. Actual implementation might need a specific subtitle overlay block.
// For simplicity, let's assume a downstream block can consume a subtitle stream,
// or you connect it to a block that renders subtitles on the video.
// Example with a hypothetical SubtitleOverlayBlock:
// var subtitleOverlay = new SubtitleOverlayBlock(); // Assuming such a block exists
// pipeline.Connect(universalSource.VideoOutput, subtitleOverlay.VideoInput);
// pipeline.Connect(subtitleSource.Output, subtitleOverlay.SubtitleInput);
// pipeline.Connect(subtitleOverlay.Output, videoRenderer.Input);
// pipeline.Connect(universalSource.AudioOutput, audioRenderer.Input);

// For a simple player without explicit overlay shown here:
pipeline.Connect(universalSource.VideoOutput, videoRenderer.Input);
pipeline.Connect(universalSource.AudioOutput, audioRenderer.Input);
// How subtitles from subtitleSource.Output are used would depend on the rest of the pipeline design.
// This block primarily provides the subtitle stream.

Console.WriteLine("Subtitle source created. Connect its output to a compatible block like a subtitle overlay or renderer.");

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android (Depends on subtitle parsing capabilities).

### Stream Source Block

The Stream Source Block allows reading media data from a `System.IO.Stream`. This is useful for playing media from memory, embedded resources, or custom stream providers without needing a temporary file. The format of the data within the stream must be parsable by the underlying media framework (GStreamer).

#### Block info

Name: `StreamSourceBlock`. (Pin information is dynamic, similar to `UniversalSourceBlock`, based on stream content. Typically, it would have an output that connects to a demuxer/decoder like `DecodeBinBlock`, or provide decoded audio/video pins if it includes demuxing/decoding capabilities.)

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output data | Varies (raw stream) | 1 |
| Output video | Depends on stream | 0 or 1 |
| Output audio | Depends on stream | 0 or 1+ |

#### Settings

The `StreamSourceBlock` is typically instantiated directly with a `System.IO.Stream`. The `StreamSourceSettings` class serves as a wrapper to provide this stream.

- `Stream` (`System.IO.Stream`): The input stream containing the media data. The stream must be readable and, if seeking is required by the pipeline, seekable.

#### The sample pipeline

If `StreamSourceBlock` outputs raw data that needs decoding:

```
graph LR;
    StreamSourceBlock -- Stream Data --> DecodeBinBlock;
    DecodeBinBlock -- Video Output --> VideoRendererBlock;
    DecodeBinBlock -- Audio Output --> AudioRendererBlock;
```

If `StreamSourceBlock` handles decoding internally (less common for a generic stream source):

```
graph LR;
    StreamSourceBlock -- Video Output --> VideoRendererBlock;
    StreamSourceBlock -- Audio Output --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Example: Load a video file into a MemoryStream
byte[] fileBytes = File.ReadAllBytes("path/to/your/video.mp4");
var memoryStream = new MemoryStream(fileBytes);

// StreamSourceSettings is a container for the stream.
var streamSettings = new StreamSourceSettings(memoryStream);
// The CreateBlock method of StreamSourceSettings would typically return new StreamSourceBlock(streamSettings.Stream)
var streamSource = streamSettings.CreateBlock() as StreamSourceBlock;
// Or, more directly: var streamSource = new StreamSourceBlock(memoryStream);

// Create video and audio renderers
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1
var audioRenderer = new AudioRendererBlock();

// Connect outputs. Commonly, a StreamSourceBlock provides raw data to a DecodeBinBlock.
var decodeBin = new DecodeBinBlock();
pipeline.Connect(streamSource.Output, decodeBin.Input); // Assuming a single 'Output' pin on StreamSourceBlock
pipeline.Connect(decodeBin.VideoOutput, videoRenderer.Input);
pipeline.Connect(decodeBin.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();

// Important: Ensure the stream remains open and valid for the duration of playback.
// Dispose of the stream when the pipeline is stopped or disposed.
// Consider this in relation to pipeline.DisposeAsync() or similar cleanup.
// memoryStream.Dispose(); // Typically after pipeline.StopAsync() and pipeline.DisposeAsync()
```

#### Remarks

The `StreamSourceBlock` itself will attempt to read from the provided stream. The success of playback depends on the format of the data in the stream and the availability of appropriate demuxers and decoders in the subsequent parts of the pipeline (often managed via `DecodeBinBlock`).

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Stream Source Block With Decoder

The `StreamSourceBlockWithDecoder` combines stream reading and automatic decoding into a single block. It accepts a `System.IO.Stream` or a file path and automatically demuxes and decodes the content — no additional `DecodeBinBlock` is required.

#### Block info

Name: StreamSourceBlockWithDecoder.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 0 or 1 |
| Output audio | Uncompressed audio | 0 or 1 |

#### Constructors

```
// From a .NET stream
StreamSourceBlockWithDecoder(Stream stream)

// From a file path
StreamSourceBlockWithDecoder(string filename)
```

The block internally connects a `StreamSourceBlock` to a `DecodeBinBlock`. The `VideoOutput` and `AudioOutput` pads are `null` if the source does not contain the respective media type.

#### The sample pipeline

```
graph LR;
    StreamSourceBlockWithDecoder -- Video --> VideoRendererBlock;
    StreamSourceBlockWithDecoder -- Audio --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// From a file path
var source = new StreamSourceBlockWithDecoder("C:/media/video.mp4");

// Or from a stream:
// var stream = File.OpenRead("C:/media/video.mp4");
// var source = new StreamSourceBlockWithDecoder(stream);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(source.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(source.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Image Sequence Source Block

The `ImageSequenceSourceBlock` generates a video stream from a sequence of still images stored in a folder. Configurable frame rate and live/seekable stream mode are supported.

#### Block info

Name: ImageSequenceSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### Settings

The block takes an `ImageSequenceSourceSettings` instance:

Constructor: `ImageSequenceSourceSettings(string folderPath, string filePattern = null)`

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `FolderPath` | `string` | required | Folder containing image files |
| `FilePattern` | `string` | auto-detected | Filename pattern (e.g., `image_%05d.jpg`); auto-detected if `null` |
| `StartIndex` | `int` | auto-detected | Starting index of the image sequence; auto-detected from the first file name |
| `FrameRate` | `VideoFrameRate` | `FPS_25` | Output frame rate |
| `IsLive` | `bool` | `false` | Treat the source as live (non-seekable) |
| `NumBuffers` | `int` | `-1` | Maximum frames to output (−1 = unlimited) |

Supported image formats: `.jpg`, `.jpeg`, `.png`, `.bmp`, `.gif`, `.tiff`, `.tif`.

#### The sample pipeline

```
graph LR;
    ImageSequenceSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new ImageSequenceSourceSettings("C:/images/sequence/")
{
    FrameRate = VideoFrameRate.FPS_25
};

var imageSource = new ImageSequenceSourceBlock(settings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(imageSource.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

`ImageSequenceSourceBlock.IsAvailable(settings)` returns `true` if the GStreamer image sequence element is available.

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Animated GIF Source Block

The `AnimatedGIFSourceBlock` generates a video stream from an animated GIF file. It supports configurable frame rate, looping, and live/seekable stream mode.

#### Block info

Name: AnimatedGIFSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### Settings

The block takes an `ImageVideoSourceSettings` instance:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Filename` | `string` | required | Path to the animated GIF file |
| `IsLive` | `bool` | `false` | Treat the source as live (non-seekable) |
| `NumBuffers` | `int` | `-1` | Maximum frames to output (−1 = unlimited) |
| `AnimationInfiniteLoop` | `bool` | `true` | Loop the animation indefinitely |
| `FrameRate` | `VideoFrameRate` | `FPS_10` | Output frame rate |

#### The sample pipeline

```
graph LR;
    AnimatedGIFSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new ImageVideoSourceSettings("C:/media/animation.gif")
{
    AnimationInfiniteLoop = true,
    FrameRate = VideoFrameRate.FPS_25
};

var gifSource = new AnimatedGIFSourceBlock(settings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(gifSource.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

`AnimatedGIFSourceBlock.IsAvailable()` returns `true` if the GStreamer animated GIF element is available.

#### Platforms

Windows, macOS, Linux, iOS, Android.

### CDG Source Block

The CDG Source Block is designed to play CD+G (Compact Disc + Graphics) files, commonly used for karaoke. It decodes both the audio track and the low-resolution graphics stream.

#### Block info

Name: CDGSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output audio | Uncompressed audio | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    CDGSourceBlock -- Audio --> AudioRendererBlock;
    CDGSourceBlock -- Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create CDG source settings
var cdgSettings = new CDGSourceSettings(
    "path/to/your/file.cdg",  // Path to the CDG graphics file
    "path/to/your/file.mp3"   // Path to the corresponding audio file (MP3, WAV, etc.)
);
// If audioFilename is null or empty, audio will be ignored.

var cdgSource = new CDGSourceBlock(cdgSettings);

// Create video renderer
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1 is your display control
pipeline.Connect(cdgSource.VideoOutput, videoRenderer.Input);

// Create audio renderer (if audio is to be played)
if (!string.IsNullOrEmpty(cdgSettings.AudioFilename) && cdgSource.AudioOutput != null)
{
    var audioRenderer = new AudioRendererBlock();
    pipeline.Connect(cdgSource.AudioOutput, audioRenderer.Input);
}

// Start pipeline
await pipeline.StartAsync();
```

#### Remarks

Requires both a `.cdg` file for graphics and a separate audio file (e.g., MP3, WAV) for the music.

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Network Source Blocks

### VNC Source Block

The VNC Source Block allows capturing video from a VNC (Virtual Network Computing) or RFB (Remote Framebuffer) server. This is useful for streaming the desktop of a remote machine.

#### Block info

Name: `VNCSourceBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### Settings

The `VNCSourceBlock` is configured using `VNCSourceSettings`. Key properties include:

- `Host` (string): The hostname or IP address of the VNC server.
- `Port` (int): The port number of the VNC server.
- `Password` (string): The password for VNC server authentication, if required.
- `Uri` (string): Alternatively, a full RFB URI (e.g., "rfb://host:port").
- `Width` (int): Desired output width. The block may connect to a VNC server that provides specific dimensions.
- `Height` (int): Desired output height.
- `Shared` (bool): Whether to share the desktop with other clients (default `true`).
- `ViewOnly` (bool): If `true`, no input (mouse/keyboard) is sent to the VNC server (default `false`).
- `Incremental` (bool): Whether to use incremental updates (default `true`).
- `UseCopyrect` (bool): Whether to use copyrect encoding (default `false`).
- `RFBVersion` (string): RFB protocol version (default "3.3").
- `OffsetX` (int): X offset for screen scraping.
- `OffsetY` (int): Y offset for screen scraping.

#### The sample pipeline

```
graph LR;
    VNCSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Configure VNC source settings
var vncSettings = new VNCSourceSettings
{
    Host = "your-vnc-server-ip", // or use Uri
    Port = 5900, // Standard VNC port
    Password = "your-password", // if any
    // Width = 1920, // Optional: desired width
    // Height = 1080, // Optional: desired height
};

var vncSource = new VNCSourceBlock(vncSettings);

// Create video renderer
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1 is your display control

// Connect blocks
pipeline.Connect(vncSource.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux (Depends on underlying GStreamer VNC plugin availability).

### RTSP Source Block

The RTSP source supports connection to IP cameras and other devices supporting the RTSP protocol.

Supported video codecs: H264, HEVC, MJPEG. Supported audio codecs: AAC, MP3, PCM, G726, G711, and some others if FFMPEG redist is installed.

#### Block info

Name: RTSPSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output audio | depends from decoder | one or more |
| Output video | depends from decoder | one or more |
| Output subtitle | depends from decoder | one or more |

#### Settings

The `RTSPSourceBlock` is configured using `RTSPSourceSettings`. Key properties include:

- `Uri`: The RTSP URL of the stream.
- `Login`: Username for RTSP authentication, if required.
- `Password`: Password for RTSP authentication, if required.
- `AudioEnabled`: A boolean indicating whether to attempt to process the audio stream.
- `Latency`: Specifies the buffering duration for the incoming stream (default is 500ms). `LowLatencyMode` uses 150ms, or the explicit `Latency` if you set it to 150ms or less.
- `AllowedProtocols`: Defines the transport protocols to be used for receiving the stream. It's a flags enum `RTSPSourceProtocol` with values:
- `UDP`: Stream data over UDP.
- `UDP_Multicast`: Stream data over UDP multicast.
- `TCP` (Recommended): Stream data over TCP.
- `HTTP`: Stream data tunneled over HTTP.
- `EnableTLS`: Encrypt TCP and HTTP with TLS (use `rtsps://` or `httpsps://` in URI).
- `DoRTCP`: Enables RTCP (RTP Control Protocol) for stream statistics and control. Default is `true`. Many cameras use RTCP receiver reports to tell that a client is still watching and drop the session without them, so disable this only for an old server that cannot handle RTCP.
- `ForceCustomKeepAlive`: When `true`, turns off the built-in RTSP keep-alive and sends GET\_PARAMETER every 30 seconds instead. Default is `false`. Use it if a camera drops the session under the default keep-alive.
- `RTPBlockSize`: Specifies the size of RTP blocks.
- `UDPBufferSize`: Buffer size for UDP transport.
- `CustomVideoDecoder`: Allows specifying a custom GStreamer video decoder element name if the default is not suitable.
- `UseGPUDecoder`: If set to `true`, the SDK will attempt to use a hardware-accelerated GPU decoder if available.
- `CompatibilityMode`: If `true`, the SDK will not try to read camera information before attempting to play, which can be useful for problematic streams.
- `EnableRAWVideoAudioEvents`: If `true`, enables events for raw (undecoded) video and audio sample data.

It's recommended to initialize `RTSPSourceSettings` using the static factory method `RTSPSourceSettings.CreateAsync(Uri uri, string login, string password, bool audioEnabled, bool readInfo = true)`. This method can also handle ONVIF discovery if the URI points to an ONVIF device service. Setting `readInfo` to `false` enables `CompatibilityMode`.

#### The sample pipeline

```
graph LR;
    RTSPSourceBlock-->VideoRendererBlock;
    RTSPSourceBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// It's recommended to use CreateAsync to initialize settings
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://login:pwd@192.168.1.64:554/Streaming/Channels/101?transportmode=unicast&profile=Profile_1"),
    "login",
    "pwd",
    audioEnabled: true);

// Optionally, configure more settings
// rtspSettings.Latency = TimeSpan.FromMilliseconds(500);
// rtspSettings.AllowedProtocols = RTSPSourceProtocol.TCP; // Prefer TCP

var rtspSource = new RTSPSourceBlock(rtspSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(rtspSource.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(rtspSource.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Sample applications

- [RTSP Preview Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/RTSP%20Preview%20Demo)
- [RTSP MultiViewSync Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/RTSP%20MultiViewSync%20Demo)

#### Platforms

Windows, macOS, Linux, iOS, Android.

### RTSP RAW Source Block

The `RTSPRAWSourceBlock` connects to an RTSP stream and delivers the **encoded** (undecoded) video and audio data directly. Unlike `RTSPSourceBlock`, no decoding pipeline is created, resulting in lower CPU overhead. Use this block when you need to record, re-stream, or process the raw compressed bitstream.

#### Block info

Name: RTSPRAWSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Encoded video (e.g. H.264) | 1 |
| Output audio | Encoded audio (e.g. AAC) | 1 |

#### Settings

Use the factory method `RTSPRAWSourceSettings.CreateAsync(uri, login, password, audioEnabled)` to create settings. Key properties:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Uri` | `Uri` | — | RTSP stream URL |
| `AllowedProtocols` | `RTSPSourceProtocol` | All | Transport protocols (TCP, UDP, UDP\_Multicast, HTTP) |
| `Latency` | `int` | — | Buffering in milliseconds |
| `Login` | `string` | — | Authentication username |
| `Password` | `string` | — | Authentication password |
| `AudioEnabled` | `bool` | `true` | Enable audio output pad |
| `WaitForKeyframe` | `bool` | `true` | Wait for IDR frame before forwarding video |
| `SyncAudioWithKeyframe` | `bool` | `true` | Synchronize audio delivery to first keyframe |
| `DoRTCP` | `bool` | — | Enable RTCP control protocol |
| `ForceCustomKeepAlive` | `bool` | `false` | Send GET\_PARAMETER every 30 s instead of the default keep-alive |
| `UDPBufferSize` | `int` | — | UDP receive buffer size |

#### The sample pipeline

```
graph LR;
    RTSPRAWSourceBlock-->MP4SinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = await RTSPRAWSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.64:554/stream"),
    login: "admin",
    password: "password",
    audioEnabled: true);

var rtspRawSource = new RTSPRAWSourceBlock(settings);

// VideoOutput carries encoded video (e.g. H.264)
// AudioOutput carries encoded audio (e.g. AAC)
var mp4Sink = new MP4SinkBlock(new MP4SinkSettings("output.mp4"));
pipeline.Connect(rtspRawSource.VideoOutput, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(rtspRawSource.AudioOutput, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
```

#### Availability

`RTSPRAWSourceBlock.IsAvailable()` returns `true` if the required GStreamer RTSP elements are available.

#### Platforms

Windows, macOS, Linux.

### RTMP Source Block

The RTMP source block connects to RTMP streams published by media servers (Nginx-RTMP, Wowza, OBS, FFmpeg, etc.). It outputs compressed video and audio pads for use with decoder or recording blocks.

Supported video codecs: H.264, H.265, VP8. Supported audio codecs: AAC, MP3.

#### Block info

Name: RTMPSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Compressed video | 1 |
| Output audio | Compressed audio | 1 |

#### Settings

`RTMPSourceBlock` is configured using `RTMPSourceSettings`. Use the static factory method to initialize settings with stream information read from the server:

```
var rtmpSettings = await RTMPSourceSettings.CreateAsync(
    new Uri("rtmp://example.com/live/stream"),
    audioEnabled: true);
```

Set `readInfo: false` (which enables `CompatibilityMode`) for streams where pre-read fails:

```
var rtmpSettings = await RTMPSourceSettings.CreateAsync(
    new Uri("rtmp://example.com/live/stream"),
    audioEnabled: true,
    readInfo: false);
```

Key properties:

- `Uri`: RTMP stream URI.
- `AudioEnabled`: Whether to create an audio output pad (default `true`).
- `CompatibilityMode`: Skip stream-info reading; useful for problematic streams.
- `UseGPUDecoder`: Attempt hardware-accelerated decoding.
- `ExtraConnectArgs`: Additional RTMP connection query parameters.

#### The sample pipeline

```
graph LR;
    RTMPSourceBlock-->VideoRendererBlock;
    RTMPSourceBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var rtmpSettings = await RTMPSourceSettings.CreateAsync(
    new Uri("rtmp://example.com/live/stream"),
    audioEnabled: true);

var rtmpSource = new RTMPSourceBlock(rtmpSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(rtmpSource.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(rtmpSource.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux.

### HTTP Source Block

The HTTP source block allows data to be retrieved using HTTP/HTTPS protocols. It can be used to read data from MJPEG IP cameras, MP4 network files, or other sources.

#### Block info

Name: HTTPSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output | Data | 1 |

#### The sample pipeline

The sample pipeline reads data from an MJPEG camera and displays it using VideoView.

```
graph LR;
    HTTPSourceBlock-->JPEGDecoderBlock;
    JPEGDecoderBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new HTTPSourceSettings(new Uri("http://mjpegcamera:8080"))
{
    UserID = "username",
    UserPassword = "password"
};

var source = new HTTPSourceBlock(settings);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
var jpegDecoder = new JPEGDecoderBlock();

pipeline.Connect(source.Output, jpegDecoder.Input);
pipeline.Connect(jpegDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux.

### HTTP MJPEG Source Block

The HTTP MJPEG Source Block is specifically designed to connect to and decode MJPEG (Motion JPEG) video streams over HTTP/HTTPS. This is common for many IP cameras.

#### Block info

Name: HTTPMJPEGSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    HTTPMJPEGSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create settings for the HTTP MJPEG source
var mjpegSettings = await HTTPMJPEGSourceSettings.CreateAsync(
    new Uri("http://your-mjpeg-camera-url/stream"), // Replace with your camera's MJPEG stream URL
    "username", // Optional: username for camera authentication
    "password"  // Optional: password for camera authentication
);

if (mjpegSettings == null)
{
    Console.WriteLine("Failed to initialize HTTP MJPEG settings.");
    return;
}

mjpegSettings.CustomVideoFrameRate = new VideoFrameRate(25); // Optional: Set if camera doesn't report frame rate
mjpegSettings.Latency = TimeSpan.FromMilliseconds(200); // Optional: Adjust latency

var httpMjpegSource = new HTTPMJPEGSourceBlock(mjpegSettings);

// Create video renderer
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1 is your display control

// Connect blocks
pipeline.Connect(httpMjpegSource.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Sample applications

- Similar to HTTP MJPEG Source Demo mentioned under the generic HTTP Source Block.

#### Platforms

Windows, macOS, Linux.

### NDI Source Block

The NDI source block supports connection to NDI software sources and devices supporting the NDI protocol.

#### Block info

Name: NDISourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output audio | Uncompressed | 1 |
| Output video | Uncompressed | 1 |

#### The sample pipeline

```
graph LR;
    NDISourceBlock-->VideoRendererBlock;
    NDISourceBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// get NDI source info by enumerating sources
var ndiSources = await DeviceEnumerator.Shared.NDISourcesAsync();
var ndiSourceInfo = ndiSources[0];

// CreateAsync takes (ContextX context, NDISourceInfo info) and must be awaited.
var ndiSettings = await NDISourceSettings.CreateAsync(pipeline.GetContext(), ndiSourceInfo);

var ndiSource = new NDISourceBlock(ndiSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(ndiSource.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(ndiSource.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Sample applications

- [NDI Source Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/NDI%20Source%20Demo)

#### Platforms

Windows, macOS, Linux.

### NDI Source X Block

The `NDISourceXBlock` is an extended NDI source that captures video and audio from NDI network sources. It uses the same `NDISourceSettings` as `NDISourceBlock` but uses an alternative GStreamer-based NDI element (`ndisrcx`).

#### Block info

Name: NDISourceXBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |
| Output audio | Uncompressed audio | 1 |

#### Settings

The block accepts `NDISourceSettings`. Use the static async factory to create it:

```
var ndiSettings = await NDISourceSettings.CreateAsync(context, ndiSourceInfo);
```

Key properties of `NDISourceSettings`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `SourceName` | `string` | `""` | Name of the NDI source |
| `URL` | `string` | `""` | Source URL |
| `ReceiverName` | `string` | `"VF NDI Receiver"` | Receiver application name |
| `Bandwidth` | `int` | `100` | −10 metadata only, 10 audio only, 100 full quality |
| `ColorFormat` | `NDIRecvColorFormat` | `UyvyBgra` | Pixel format for received video |
| `Timeout` | `TimeSpan` | 5 s | Timeout for detecting disconnection |
| `ConnectTimeout` | `TimeSpan` | 10 s | Timeout for initial connection |
| `TimestampMode` | `NDITimestampMode` | `Auto` | Timestamp synchronization mode |

#### The sample pipeline

```
graph LR;
    NDISourceXBlock -- Video --> VideoRendererBlock;
    NDISourceXBlock -- Audio --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var ndiSources = await DeviceEnumerator.Shared.NDISourcesAsync();
var ndiSourceInfo = ndiSources[0];

// CreateAsync takes (ContextX context, NDISourceInfo info).
var ndiSettings = await NDISourceSettings.CreateAsync(pipeline.GetContext(), ndiSourceInfo);

var ndiSource = new NDISourceXBlock(ndiSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(ndiSource.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(ndiSource.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows.

### GenICam Source Block

The GenICam source supports connection to GigE, and the USB3 Vision camera supports the GenICam protocol.

#### Block info

Name: GenICamSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | various | one or more |

#### The sample pipeline

```
graph LR;
    GenICamSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var sourceSettings = new GenICamSourceSettings(cbCamera.Text, new VisioForge.Core.Types.Rect(0, 0, 512, 512), 15, GenICamPixelFormat.Mono8);
var source = new GenICamSourceBlock(sourceSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(source.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Sample applications

- [GenICam Source Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/GenICam%20Source%20Demo)

Read more about the [GenICam Source](../../videocapture/video-sources/usb3v-gige-genicam/).

#### Platforms

Windows, macOS, Linux

### SRT Source Block (with decoding)

The `Secure Reliable Transport (SRT)` is an open-source video streaming protocol designed for secure and low-latency delivery over unpredictable networks, like the public internet. Developed by Haivision, SRT optimizes streaming performance by dynamically adapting to varying bandwidths and minimizing the effects of packet loss. It incorporates AES encryption for secure content transmission. Primarily used in broadcasting and online streaming, SRT is crucial for delivering high-quality video feeds in real-time applications, enhancing viewer experiences even in challenging network conditions. It supports point-to-point and multicast streaming, making it versatile for diverse setups.

The SRT source block provides decoded video and audio streams from an SRT source.

#### Block info

Name: SRTSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed | 0+ |
| Output audio | Uncompressed | 0+ |

#### Settings

The `SRTSourceBlock` is configured using `SRTSourceSettings`. This class provides comprehensive options for SRT connections:

- `Uri` (string): The SRT URI (e.g., "srt://127.0.0.1:8888" or "srt://example.com:9000?mode=listener"). Default is "srt://127.0.0.1:8888".
- `Mode` (`SRTConnectionMode` enum): Specifies the SRT connection mode. Default is `Caller`. See `SRTConnectionMode` enum details below.
- `Passphrase` (string): The password for encrypted transmission.
- `PbKeyLen` (`SRTKeyLength` enum): The crypto key length for AES encryption. Default is `NoKey`. See `SRTKeyLength` enum details below.
- `Latency` (`TimeSpan`): The maximum accepted transmission latency (receiver side for caller/listener, or for both in rendezvous). Default is 125 milliseconds.
- `StreamId` (string): The stream ID for SRT access control.
- `LocalAddress` (string): The local address to bind to when in `Listener` or `Rendezvous` mode. Default `null` (any).
- `LocalPort` (uint): The local port to bind to when in `Listener` or `Rendezvous` mode. Default 7001.
- `Authentication` (bool): Whether to authenticate the connection. Default `true`.
- `AutoReconnect` (bool): Whether the source should attempt to reconnect if the connection fails. Default `true`.
- `KeepListening` (bool): If `false` (default), the element will signal end-of-stream when the remote client disconnects (in listener mode). If `true`, it keeps waiting for reconnection.
- `PollTimeout` (`TimeSpan`): Polling timeout used when an SRT poll is started. Default 1000 milliseconds.
- `WaitForConnection` (bool): If `true` (default), blocks the stream until a client connects (in listener mode).

The `SRTSourceSettings` can be initialized using `await SRTSourceSettings.CreateAsync(string uri, bool ignoreMediaInfoReader = false)`. Setting `ignoreMediaInfoReader` to `true` can be useful if media info reading fails for a live stream.

##### `SRTConnectionMode` Enum

Defines the operational mode for an SRT connection:

- `None` (0): No connection mode specified (should not typically be used directly).
- `Caller` (1): The source initiates the connection to a listener.
- `Listener` (2): The source waits for an incoming connection from a caller.
- `Rendezvous` (3): Both ends initiate connection to each other simultaneously, useful for traversing firewalls.

##### `SRTKeyLength` Enum

Defines the key length for SRT's AES encryption:

- `NoKey` (0) / `Length0` (0): No encryption is used.
- `Length16` (16): 16-byte (128-bit) AES encryption key.
- `Length24` (24): 24-byte (192-bit) AES encryption key.
- `Length32` (32): 32-byte (256-bit) AES encryption key.

#### The sample pipeline

```
graph LR;
    SRTSourceBlock-->VideoRendererBlock;
    SRTSourceBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// SRTSourceSettings has only a private constructor; use the async factory.
var srtSettings = await SRTSourceSettings.CreateAsync(new Uri(edURL.Text));
var source = new SRTSourceBlock(srtSettings);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
var audioRenderer = new AudioRendererBlock();

pipeline.Connect(source.VideoOutput, videoRenderer.Input);
pipeline.Connect(source.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Sample applications

- [SRT Source Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/SRT%20Source%20Demo)

#### Platforms

Windows, macOS, Linux, iOS, Android.

### SRT RAW Source Block

`The Secure Reliable Transport (SRT)` is a streaming protocol that optimizes video data delivery over unpredictable networks, like the Internet. It is open-source and designed to handle high-performance video and audio streaming. SRT provides security through end-to-end encryption, reliability by recovering lost packets, and low latency, which is suitable for live broadcasts. It adapts to varying network conditions by dynamically managing bandwidth, ensuring high-quality streams even under suboptimal conditions. Widely used in broadcasting and streaming applications, SRT supports interoperability and is ideal for remote production and content distribution.

The SRT source supports connection to SRT sources and provides a data stream. You can connect this block to `DecodeBinBlock` to decode the stream.

#### Block info

Name: SRTRAWSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output data | Any | one |

#### Settings

The `SRTRAWSourceBlock` is configured using `SRTSourceSettings`. Refer to the detailed description of `SRTSourceSettings` and its related enums (`SRTConnectionMode`, `SRTKeyLength`) under the `SRT Source Block (with decoding)` section for all available properties and their explanations.

#### The sample pipeline

```
graph LR;
    SRTRAWSourceBlock-->DecodeBinBlock;
    DecodeBinBlock-->VideoRendererBlock;
    DecodeBinBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// SRTSourceSettings has only a private constructor; use the async factory.
var srtSettings = await SRTSourceSettings.CreateAsync(new Uri(edURL.Text));
var source = new SRTRAWSourceBlock(srtSettings);
var decodeBin = new DecodeBinBlock();
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
var audioRenderer = new AudioRendererBlock();

pipeline.Connect(source.Output, decodeBin.Input);
pipeline.Connect(decodeBin.VideoOutput, videoRenderer.Input);
pipeline.Connect(decodeBin.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

## Other Source Blocks

### Screen Source Block

Screen source supports recording video from the screen. You can select the display (if more than one), the part of the screen to be recorded, and optional mouse cursor recording.

#### Settings

The `ScreenSourceBlock` uses platform-specific settings classes. The choice of settings class determines the underlying screen capture technology. The `ScreenCaptureSourceType` enum indicates the available technologies:

##### Windows

- `ScreenCaptureDX9SourceSettings` - Use `DirectX 9` for screen recording. (`ScreenCaptureSourceType.DX9`)
- `ScreenCaptureD3D11SourceSettings` - Use `Direct3D 11` Desktop Duplication for screen recording. Allows specific window capture. (`ScreenCaptureSourceType.D3D11DesktopDuplication`)
- `ScreenCaptureGDISourceSettings` - Use `GDI` for screen recording. (`ScreenCaptureSourceType.GDI`)

##### macOS

`ScreenCaptureMacOSSourceSettings` - Use `AVFoundation` for screen recording. (`ScreenCaptureSourceType.AVFoundation`)

##### Linux

`ScreenCaptureXDisplaySourceSettings` - Use `X11` (XDisplay) for screen recording. (`ScreenCaptureSourceType.XDisplay`)

##### iOS

`IOSScreenSourceSettings` - Use `AVFoundation` for current window/app recording. (`ScreenCaptureSourceType.IOSScreen`)

#### Block info

Name: ScreenSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    ScreenSourceBlock-->H264EncoderBlock;
    H264EncoderBlock-->MP4SinkBlock;
```

#### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create source settings
var screenSourceSettings = new ScreenCaptureDX9SourceSettings() { FrameRate = 15 };

// create source block
var screenSourceBlock = new ScreenSourceBlock(screenSourceSettings);

// create video encoder block and connect it to the source block
var h264EncoderBlock = new H264EncoderBlock(new OpenH264EncoderSettings());
pipeline.Connect(screenSourceBlock.Output, h264EncoderBlock.Input);

// create MP4 sink block and connect it to the encoder block
var mp4SinkBlock = new MP4SinkBlock(new MP4SinkSettings(@"output.mp4"));
pipeline.Connect(h264EncoderBlock.Output, mp4SinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

// run pipeline
await pipeline.StartAsync();
```

#### [Windows] Window capture

You can capture a specific window by using the `ScreenCaptureD3D11SourceSettings` class.

```
// create Direct3D11 source
var source = new ScreenCaptureD3D11SourceSettings();

// set frame rate
source.FrameRate = new VideoFrameRate(30);

// get handle of the window
var wih = new System.Windows.Interop.WindowInteropHelper(this);
source.WindowHandle = wih.Handle;

// create source block using the D3D11 settings built above
var screenSourceBlock = new ScreenSourceBlock(source);

// other code is the same as above
```

#### Sample applications

- [Screen Capture Demo (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Screen%20Capture)
- [Screen Capture Demo (MAUI)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/MAUI/ScreenCaptureMB)
- [Screen Capture Demo (iOS)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/iOS/ScreenCapture)

#### Platforms

Windows, macOS, Linux, iOS.

### Fallback Switch Source Block

The `FallbackSwitchSourceBlock` wraps a primary video source and automatically switches to fallback content when the main source fails or becomes unavailable — ideal for reliable live streaming pipelines.

#### Block info

Name: FallbackSwitchSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |
| Output audio | Uncompressed audio | 1 |

#### Supported main source types

The first constructor argument is `IVideoSourceSettings`. Supported implementations:

- `RTSPSourceSettings` — RTSP stream
- `SRTSourceSettings` — SRT stream
- `NDISourceSettings` — NDI source
- `RTMPSourceSettings` — RTMP stream
- `HTTPSourceSettings` — HTTP stream

#### Settings

**`FallbackSwitchSettings`**

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Enabled` | `bool` | `false` | Enable fallback switching |
| `Fallback` | `FallbackSwitchSettingsBase` | `null` | Fallback content configuration |
| `EnableVideo` | `bool` | `true` | Apply fallback to video |
| `EnableAudio` | `bool` | `true` | Apply fallback to audio |
| `MinLatencyMs` | `int` | `0` | Minimum latency before switching |
| `FallbackVideoCaps` | `string` | `null` | Video caps override (e.g., `"video/x-raw,width=1920,height=1080"`) |
| `FallbackAudioCaps` | `string` | `null` | Audio caps override |

**`FallbackSwitchSettingsBase`** properties (shared by all fallback types):

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `TimeoutMs` | `int` | `5000` | Milliseconds before switching to fallback |
| `RestartTimeoutMs` | `int` | `5000` | Milliseconds before retrying the main source |
| `RetryTimeoutMs` | `int` | `60000` | Milliseconds before stopping retries |
| `ImmediateFallback` | `bool` | `false` | Switch to fallback immediately on error |
| `RestartOnEos` | `bool` | `false` | Restart main source on end-of-stream |
| `ManualUnblock` | `bool` | `false` | Require manual `Unblock()` call to resume main source |

**Fallback content types** (set `Fallback` to one of):

- `StaticTextFallbackSettings` — text overlay with configurable font, color, and position
- `StaticImageFallbackSettings` — displays a static image (file path, scale, aspect ratio options)
- `MediaBlockFallbackSettings` — plays a fallback URI or custom GStreamer pipeline

**Diagnostic methods:**

- `GetStatus()` — returns current fallback/main source state as a string
- `GetStatistics()` — returns a dictionary of retry count and buffering statistics
- `Unblock()` — manually unblocks when `ManualUnblock` is enabled

#### The sample pipeline

```
graph LR;
    FallbackSwitchSourceBlock -- Video --> VideoRendererBlock;
    FallbackSwitchSourceBlock -- Audio --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// RTSPSourceSettings has a private constructor — build it via the CreateAsync factory.
var mainSettings = await RTSPSourceSettings.CreateAsync(
    uri: new Uri("rtsp://camera.example.com/stream"),
    login: null,
    password: null,
    audioEnabled: true);

var fallbackSettings = new FallbackSwitchSettings
{
    Enabled = true,
    Fallback = new StaticTextFallbackSettings
    {
        Text = "Stream unavailable",
        BackgroundColor = SKColors.Black,
        TextColor = SKColors.White
    }
};

var source = new FallbackSwitchSourceBlock(mainSettings, fallbackSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(source.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(source.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Virtual Video Source Block

VirtualVideoSourceBlock is used to produce test video data in a wide variety of video formats. The type of test data is controlled by the settings.

#### Settings

The `VirtualVideoSourceBlock` is configured using `VirtualVideoSourceSettings`. Key properties:

- `Pattern` (`VirtualVideoSourcePattern` enum): Specifies the type of test pattern to generate. See `VirtualVideoSourcePattern` enum below for available patterns. Default is `SMPTE`.
- `Width` (int): Width of the output video (default 1280).
- `Height` (int): Height of the output video (default 720).
- `FrameRate` (`VideoFrameRate`): Frame rate of the output video (default 30fps).
- `Format` (`VideoFormatX` enum): Pixel format of the video (default `RGB`).
- `ForegroundColor` (`SKColor`): For patterns that use a foreground color (e.g., `SolidColor`), this property defines it (default `SKColors.White`).

Constructors:

- `VirtualVideoSourceSettings()`: Default constructor.
- `VirtualVideoSourceSettings(int width, int height, VideoFrameRate frameRate)`: Initializes with specified dimensions and frame rate.

##### `VirtualVideoSourcePattern` Enum

Defines the test pattern generated by `VirtualVideoSourceBlock`:

- `SMPTE` (0): SMPTE 100% color bars.
- `Snow` (1): Random (television snow).
- `Black` (2): 100% Black.
- `White` (3): 100% White.
- `Red` (4), `Green` (5), `Blue` (6): Solid colors.
- `Checkers1` (7) to `Checkers8` (10): Checkerboard patterns with 1, 2, 4, or 8 pixel squares.
- `Circular` (11): Circular pattern.
- `Blink` (12): Blinking pattern.
- `SMPTE75` (13): SMPTE 75% color bars.
- `ZonePlate` (14): Zone plate.
- `Gamut` (15): Gamut checkers.
- `ChromaZonePlate` (16): Chroma zone plate.
- `SolidColor` (17): A solid color, defined by `ForegroundColor`.
- `Ball` (18): Moving ball.
- `SMPTE100` (19): Alias for SMPTE 100% color bars.
- `Bar` (20): Bar pattern.
- `Pinwheel` (21): Pinwheel pattern.
- `Spokes` (22): Spokes pattern.
- `Gradient` (23): Gradient pattern.
- `Colors` (24): Various colors pattern.
- `SMPTERP219` (25): SMPTE test pattern, RP 219 conformant.

#### Block info

Name: VirtualVideoSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    VirtualVideoSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var audioSourceBlock = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());
var videoSourceBlock = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoSourceBlock.Output, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(audioSourceBlock.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Virtual Audio Source Block

VirtualAudioSourceBlock is used to produce test audio data in a wide variety of audio formats. The type of test data is controlled by the settings.

#### Settings

The `VirtualAudioSourceBlock` is configured using `VirtualAudioSourceSettings`. Key properties:

- `Wave` (`VirtualAudioSourceSettingsWave` enum): Specifies the type of audio waveform to generate. See `VirtualAudioSourceSettingsWave` enum below. Default `Sine`.
- `Format` (`AudioFormatX` enum): Audio sample format (default `S16LE`).
- `SampleRate` (int): Sample rate in Hz (default 48000).
- `Channels` (int): Number of audio channels (default 2).
- `Volume` (double): Volume of the test signal (0.0 to 1.0, default 0.8).
- `Frequency` (double): Frequency of the test signal in Hz (e.g., for Sine wave, default 440).
- `IsLive` (bool): Indicates if the source is live (default `true`).
- `ApplyTickRamp` (bool): Apply ramp to tick samples (default `false`).
- `CanActivatePull` (bool): Can activate in pull mode (default `false`).
- `CanActivatePush` (bool): Can activate in push mode (default `true`).
- `MarkerTickPeriod` (uint): Make every Nth tick a marker tick (for `Ticks` wave, 0 = no marker, default 0).
- `MarkerTickVolume` (double): Volume of marker ticks (default 1.0).
- `SamplesPerBuffer` (int): Number of samples in each outgoing buffer (default 1024).
- `SinePeriodsPerTick` (uint): Number of sine wave periods in one tick (for `Ticks` wave, default 10).
- `TickInterval` (`TimeSpan`): Distance between start of current and start of next tick (default 1 second).
- `TimestampOffset` (`TimeSpan`): An offset added to timestamps (default `TimeSpan.Zero`).

Constructor:

- `VirtualAudioSourceSettings(VirtualAudioSourceSettingsWave wave = VirtualAudioSourceSettingsWave.Ticks, int sampleRate = 48000, int channels = 2, AudioFormatX format = AudioFormatX.S16LE)`

##### `VirtualAudioSourceSettingsWave` Enum

Defines the waveform for `VirtualAudioSourceBlock`:

- `Sine` (0): Sine wave.
- `Square` (1): Square wave.
- `Saw` (2): Sawtooth wave.
- `Triangle` (3): Triangle wave.
- `Silence` (4): Silence.
- `WhiteNoise` (5): White uniform noise.
- `PinkNoise` (6): Pink noise.
- `SineTable` (7): Sine table.
- `Ticks` (8): Periodic Ticks.
- `GaussianNoise` (9): White Gaussian noise.
- `RedNoise` (10): Red (Brownian) noise.
- `BlueNoise` (11): Blue noise.
- `VioletNoise` (12): Violet noise.

#### Block info

Name: VirtualAudioSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output audio | uncompressed audio | 1 |

#### The sample pipeline

```
graph LR;
    VirtualAudioSourceBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var audioSourceBlock = new VirtualAudioSourceBlock(new VirtualAudioSourceSettings());
var videoSourceBlock = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoSourceBlock.Output, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(audioSourceBlock.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Demuxer Source Block

The Demuxer Source Block is used to demultiplex local media files into their constituent elementary streams (video, audio, subtitles). It allows for selective rendering of these streams.

#### Block info

Name: DemuxerSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Depends on file | 0 or 1 |
| Output audio | Depends on file | 0 or 1+ |
| Output subtitle | Depends on file | 0 or 1+ |

#### The sample pipeline

```
graph LR;
    DemuxerSourceBlock -- Video Stream --> VideoRendererBlock;
    DemuxerSourceBlock -- Audio Stream --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create settings, ensure to await CreateAsync
var demuxerSettings = await DemuxerSourceSettings.CreateAsync(
    "path/to/your/video.mp4",
    renderVideo: true,
    renderAudio: true,
    renderSubtitle: false);

if (demuxerSettings == null)
{
    Console.WriteLine("Failed to initialize demuxer settings. Ensure the file exists and is readable.");
    return;
}

var demuxerSource = new DemuxerSourceBlock(demuxerSettings);

// Setup video rendering if video is available and rendered
if (demuxerSettings.RenderVideo && demuxerSource.VideoOutput != null)
{
    var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1 is your display control
    pipeline.Connect(demuxerSource.VideoOutput, videoRenderer.Input);
}

// Setup audio rendering if audio is available and rendered
if (demuxerSettings.RenderAudio && demuxerSource.AudioOutput != null)
{
    var audioRenderer = new AudioRendererBlock();
    pipeline.Connect(demuxerSource.AudioOutput, audioRenderer.Input);
}

// Start pipeline
await pipeline.StartAsync();
```

#### Sample applications

- No specific sample application link, but can be used in player-like scenarios.

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Image Video Source Block

The Image Video Source Block generates a video stream from a static image file (e.g., JPG, PNG). It repeatedly outputs the image as video frames according to the specified frame rate.

#### Block info

Name: ImageVideoSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    ImageVideoSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create image video source settings
var imageSourceSettings = new ImageVideoSourceSettings("path/to/your/image.jpg"); // Replace with your image path
imageSourceSettings.FrameRate = new VideoFrameRate(10); // Output 10 frames per second
imageSourceSettings.IsLive = true; // Treat as a live source (optional)
// imageSourceSettings.NumBuffers = 100; // Optional: output only 100 frames then stop

var imageSource = new ImageVideoSourceBlock(imageSourceSettings);

// Create video renderer
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1 is your display control

// Connect blocks
pipeline.Connect(imageSource.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Remarks

This block uses SkiaSharp for image decoding, so ensure necessary dependencies are met if not using a standard VisioForge package that includes it.

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Text Overlay Source Block

The `TextOverlaySourceBlock` generates a video stream displaying configurable text on a solid background. It uses GStreamer's `videotestsrc` and `textoverlay` elements internally. This block is useful as a placeholder or fallback source — for example, showing "No Signal" when a primary camera is unavailable.

#### Block info

Name: TextOverlaySourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### Settings

The block is configured via `StaticTextFallbackSettings`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Text` | `string` | `"Source Unavailable"` | Text to display |
| `FontFamily` | `string` | `"Arial"` | Font family name |
| `FontSize` | `float` | `24` | Font size in points |
| `FontStyle` | `FontStyle` | `Normal` | Font style (Normal, Bold, Italic, etc.) |
| `TextColor` | `SKColor` | White | Text color |
| `BackgroundColor` | `SKColor` | Black | Background fill color |
| `Position` | `SKPoint` | `(0.5, 0.5)` | Text anchor position as proportion (0–1) |
| `CenterAlign` | `bool` | `true` | Center-align the text |

#### The sample pipeline

```
graph LR;
    TextOverlaySourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new StaticTextFallbackSettings
{
    Text = "No Signal",
    FontSize = 36,
    TextColor = SKColors.White,
    BackgroundColor = SKColors.Black
};

var textSource = new TextOverlaySourceBlock(settings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(textSource.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Video Mixer Source Block

The `VideoMixerSourceBlock` composites multiple video sources into a single output stream. Each input is placed at a configurable rectangle on the output canvas. During playback the block supports live repositioning, opacity fading, and chroma key removal per input.

The mixer backend is controlled by `VideoMixerType`: CPU (default), OpenGL, or Direct3D 11.

#### Block info

Name: VideoMixerSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### Settings (`VideoMixerSourceSettings`)

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Width` | `int` | `1920` | Output canvas width in pixels |
| `Height` | `int` | `1080` | Output canvas height in pixels |
| `FrameRate` | `VideoFrameRate` | `FPS_30` | Output frame rate |
| `MixerType` | `VideoMixerType` | `CPU` | Rendering backend (CPU, OpenGL, D3D11) |

Use `settings.Add(source, rect)` or `settings.Add(source, left, top, width, height)` to register each input source and its bounding rectangle on the canvas.

#### Runtime control

The block implements `IVideoMixerControl` for live updates:

- `Input_Move(id, rect, duration, startAlpha, endAlpha)` — animate position and opacity
- `Input_Update(stream)` — update stream properties
- `Input_UpdateChromaKeySettings(id, settings)` — change chroma key
- `StartFadeIn(id, duration)` / `StartFadeOut(id, duration)` — fade controls
- `Input_List()` — enumerate all input streams

#### The sample pipeline

```
graph LR;
    Source1-->VideoMixerSourceBlock;
    Source2-->VideoMixerSourceBlock;
    VideoMixerSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new VideoMixerSourceSettings(1920, 1080, VideoFrameRate.FPS_30);

// Add a file source on the left half. Add takes source SETTINGS, not blocks - the mixer
// creates the source block for each entry itself.
// Rect is (left, top, right, bottom), so the right half ends at 1920, not at its width.
settings.Add(await UniversalSourceSettings.CreateAsync("source1.mp4"), new Rect(0, 0, 960, 1080));

// Add a webcam on the right half
settings.Add(videoSourceSettings, new Rect(960, 0, 1920, 1080));

var mixer = new VideoMixerSourceBlock(pipeline, settings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(mixer.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

`VideoMixerSourceBlock.IsAvailable()` returns `true` if the required GStreamer compositor elements are available.

#### Platforms

Windows, macOS, Linux, iOS, Android.

### WebView2 Source Block

The `WebView2SourceBlock` renders a Microsoft Edge WebView2 browser surface as a live video source. It is useful for capturing web pages, HTML overlays, dashboards, or interactive content as a video stream. Windows-only — it requires the Microsoft Edge WebView2 runtime and the GStreamer `webview2` plugin.

#### Block info

Name: WebView2SourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### Settings (WebView2SourceSettings)

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Location` | `string` | `"about:blank"` | URL to display. |
| `JavaScript` | `string` | `null` | JavaScript to run when navigation completes. |
| `Adapter` | `int` | `-1` | DXGI adapter index (`-1` for any device). |
| `ProcessingDeadline` | `ulong` | `20000000` | Maximum processing time for a buffer, in nanoseconds. |
| `UserDataFolder` | `string` | `null` | Absolute path to the WebView2 user data folder. |

#### The sample pipeline

```
graph LR;
    WebView2SourceBlock-->VideoRendererBlock;
```

#### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// create source settings (pass the URL via the constructor)
var settings = new WebView2SourceSettings("https://www.visioforge.com/");

// create source block
var webViewSource = new WebView2SourceBlock(settings);

// create video renderer block and connect it to the source block
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(webViewSource.Output, videoRenderer.Input);

// run pipeline
await pipeline.StartAsync();
```

#### Availability

`WebView2SourceBlock.IsAvailable()` returns `true` if the GStreamer `webview2` plugin is installed.

#### Platforms

Windows.

## Push Source Blocks

Push Source blocks allow you to feed media data (video, audio, JPEG images, or generic data) directly into the Media Blocks pipeline from your application code. This is useful when your media originates from a custom source, such as a proprietary capture device, a network stream not supported by built-in blocks, or procedurally generated content.

The behavior of push sources is generally controlled by common settings available through the `IPushSourceSettings` interface, implemented by specific push source settings classes:

- `IsLive` (bool): Indicates if the source is live. Defaults vary by type (e.g., `true` for audio/video).
- `DoTimestamp` (bool): If `true`, the block will attempt to generate timestamps for the pushed data.
- `StreamType` (`PushSourceStreamType` enum: `Stream` or `SeekableStream`): Defines the stream characteristics.
- `PushFormat` (`PushSourceFormat` enum: `Bytes`, `Time`, `Default`, `Automatic`): Controls how data is pushed (e.g., based on byte count or time).
- `BlockPushData` (bool): If `true`, the push operation will block until the data is consumed by the pipeline.

The specific type of push source is determined by the `PushSourceType` enum: `Video`, `Audio`, `Data`, `JPEG`.

### Push Video Source Block

Allows pushing raw video frames into the pipeline.

#### Block info

Name: PushVideoSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### Settings

Configured using `PushVideoSourceSettings`:

- `Width` (int): Width of the video frames.
- `Height` (int): Height of the video frames.
- `FrameRate` (`VideoFrameRate`): Frame rate of the video.
- `Format` (`VideoFormatX` enum): Pixel format of the video frames (e.g., `RGB`, `NV12`, `I420`).
- Inherits common push settings like `IsLive` (defaults to `true`), `DoTimestamp`, `StreamType`, `PushFormat`, `BlockPushData`.

Constructor: `PushVideoSourceSettings(int width, int height, VideoFrameRate frameRate, VideoFormatX format = VideoFormatX.RGB)`

#### The sample pipeline

```
graph LR;
    PushVideoSourceBlock-->VideoEncoderBlock-->MP4SinkBlock;
    PushVideoSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Configure push video source
var videoPushSettings = new PushVideoSourceSettings(
    width: 640,
    height: 480,
    frameRate: new VideoFrameRate(30),
    format: VideoFormatX.RGB);
// videoPushSettings.IsLive = true; // Default

var videoPushSource = new PushVideoSourceBlock(videoPushSettings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoPushSource.Output, videoRenderer.Input);

await pipeline.StartAsync();

// Push frames from your application:
// var frame = new VideoFrameX(...);
// videoPushSource.PushFrame(frame);
// videoPushSource.ClearQueue(); // Clear buffered frames if needed
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Push Audio Source Block

Allows pushing raw audio samples into the pipeline.

#### Block info

Name: PushAudioSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output audio | Uncompressed audio | 1 |

#### Settings

Configured using `PushAudioSourceSettings`:

- `SampleRate` (int): Sample rate of the audio (e.g., 44100, 48000).
- `Channels` (int): Number of audio channels (e.g., 1 for mono, 2 for stereo).
- `Format` (`AudioFormatX` enum): Format of the audio samples (e.g., `S16LE` for 16-bit signed little-endian PCM).
- Inherits common push settings like `IsLive` (defaults to `true`), `DoTimestamp`, `StreamType`, `PushFormat`, `BlockPushData`.

Constructor: `PushAudioSourceSettings(bool isLive = true, int sampleRate = 48000, int channels = 2, AudioFormatX format = AudioFormatX.S16LE)`

#### The sample pipeline

```
graph LR;
    PushAudioSourceBlock-->AudioEncoderBlock-->MP4SinkBlock;
    PushAudioSourceBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Configure push audio source
var audioPushSettings = new PushAudioSourceSettings(
    isLive: true,
    sampleRate: 44100,
    channels: 2,
    format: AudioFormatX.S16LE);

var audioPushSource = new PushAudioSourceBlock(audioPushSettings);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(audioPushSource.Output, audioRenderer.Input);

await pipeline.StartAsync();

// Push audio data from your application:
// var frame = new AudioFrame(...);
// audioPushSource.PushData(frame);
// Or raw bytes: audioPushSource.PushData(audioData, audioData.Length);
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Push Data Source Block

Allows pushing generic byte data into the pipeline. The interpretation of this data depends on the `Caps` (capabilities) specified.

#### Block info

Name: `PushSourceBlock` (configured for data).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output data | Custom | 1 |

#### Settings

Configured using `PushDataSourceSettings`:

- `Caps` (`Gst.Caps`): GStreamer capabilities string describing the data format (e.g., "video/x-h264, stream-format=byte-stream"). This is crucial for downstream blocks to understand the data.
- `PadMediaType` (`MediaBlockPadMediaType` enum): Specifies the type of the output pad (e.g., `Video`, `Audio`, `Data`, `Auto`).
- Inherits common push settings like `IsLive`, `DoTimestamp`, `StreamType`, `PushFormat`, `BlockPushData`.

#### The sample pipeline

```
graph LR;
    PushDataSourceBlock-->ParserOrDecoder-->Renderer;
```

Example: Pushing H.264 Annex B byte stream

```
graph LR;
    PushDataSourceBlock-->H264ParseBlock-->H264DecoderBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Configure push data source for H.264 byte stream
var dataPushSettings = new PushDataSourceSettings();
dataPushSettings.Caps = new Gst.Caps("video/x-h264, stream-format=(string)byte-stream");
dataPushSettings.PadMediaType = MediaBlockPadMediaType.Video;
// dataPushSettings.IsLive = true; // Set if live

var dataPushSource = new PushSourceBlock(dataPushSettings);

// Example: Decode and render H.264 stream
var h264Parser = new H264ParseBlock();
var h264Decoder = new H264DecoderBlock(); // H.264 decoder (auto-selects a concrete IH264DecoderSettings)
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(dataPushSource.Output, h264Parser.Input);
pipeline.Connect(h264Parser.Output, h264Decoder.Input);
pipeline.Connect(h264Decoder.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();

// In a separate thread or task, push H.264 NALUs:
// byte[] naluData = ... ; // Your H.264 NALU data
// dataPushSource.PushFrame(naluData);
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### Push JPEG Source Block

Allows pushing individual JPEG images, which are then output as a video stream.

#### Block info

Name: `PushSourceBlock` (configured for JPEG).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### Settings

Configured using `PushJPEGSourceSettings`:

- `Width` (int): Width of the decoded JPEG images.
- `Height` (int): Height of the decoded JPEG images.
- `FrameRate` (`VideoFrameRate`): The frame rate at which the JPEG images will be presented as a video stream.
- Inherits common push settings like `IsLive` (defaults to `true`), `DoTimestamp`, `StreamType`, `PushFormat`, `BlockPushData`.

Constructor: `PushJPEGSourceSettings(int width, int height, VideoFrameRate frameRate)`

#### The sample pipeline

```
graph LR;
    PushJPEGSourceBlock-->VideoRendererBlock;
    PushJPEGSourceBlock-->VideoEncoderBlock-->MP4SinkBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Configure push JPEG source
var jpegPushSettings = new PushJPEGSourceSettings(
    width: 1280,
    height: 720,
    frameRate: new VideoFrameRate(10)); // Present JPEGs as a 10 FPS video

var jpegPushSource = new PushSourceBlock(jpegPushSettings);

// Example: Render the video stream from JPEGs
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(jpegPushSource.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();

// In a separate thread or task, push JPEG image data:
// byte[] jpegImageData = File.ReadAllBytes("image.jpg");
// jpegPushSource.PushFrame(jpegImageData);
// Call PushFrame for each new JPEG image.
```

#### Platforms

Windows, macOS, Linux, iOS, Android.

### H264 Push Source Block

The H264 Push Source Block allows pushing raw H.264 encoded data directly into a Media Blocks pipeline for decoding and rendering. It wraps a GStreamer `appsrc` element configured for H.264 byte-stream input.

This block is designed for scenarios where you receive raw H.264 encoded data from an external source (such as an RTSP callback, a custom network transport, or a file reader) and need to decode and display it. It automatically handles:

- **AVC-to-byte-stream conversion**: RTSP and many other sources deliver H.264 in AVC format (4-byte length-prefixed NAL units). The block automatically converts this to Annex B byte-stream format (start codes) expected by GStreamer's H.264 parser.
- **PTS rebasing**: Presentation timestamps from external sources (e.g., RTSP cameras) are on the source's time base, which may be far from zero. The block rebases all timestamps relative to the first frame so the pipeline clock starts near zero, preventing display delays.

#### Block info

Name: H264PushSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | H.264 encoded (byte-stream) | 1 |

#### Properties

- `DoTimestamp` (bool): When `true`, the appsrc auto-generates timestamps using the pipeline clock (lowest latency, but breaks A/V sync). When `false` (default), the PTS provided to `PushData()` is used after rebasing. Must be set before pipeline start.

#### Methods

- `PushData(byte[] data, int length, TimeSpan timestamp)`: Push H.264 encoded data with a presentation timestamp. Handles AVC-to-byte-stream conversion and PTS rebasing automatically. Returns `FlowReturn` status.
- `PushData(byte[] data, int length)`: Push H.264 data without a timestamp (uses `TimeSpan.Zero`).
- `SendEOS()`: Signal end of stream to the pipeline.

#### The sample pipeline

The typical pipeline connects H264PushSourceBlock through a parser and decoder to a video renderer:

```
graph LR;
    H264PushSourceBlock-->H264ParseBlock;
    H264ParseBlock-->H264DecoderBlock;
    H264DecoderBlock-->VideoRendererBlock;
```

#### Two-pipeline architecture with RTSP callback

A common use case is the two-pipeline pattern: one pipeline captures raw H.264 from an RTSP camera, and a second pipeline decodes and displays it. This gives you access to the raw encoded bytes between capture and decode.

```
graph LR;
    subgraph "Pipeline 1 - Grabber"
        RTSPRAWSourceBlock-->BufferSinkBlock;
    end
    subgraph "Pipeline 2 - Player"
        H264PushSourceBlock-->H264ParseBlock;
        H264ParseBlock-->H264DecoderBlock;
        H264DecoderBlock-->VideoRendererBlock;
    end
    BufferSinkBlock-.PushData callback.->H264PushSourceBlock;
```

#### Sample code

```
// === Pipeline 2: Player (decode and render) ===
var playerPipeline = new MediaBlocksPipeline();

// Create H264 push source - this is where raw H.264 data will be injected
var h264Source = new H264PushSourceBlock();

// Create parser, decoder, and renderer
var h264Parser = new H264ParseBlock();
var h264Decoder = new H264DecoderBlock(new FFMPEGH264DecoderSettings());
var videoRenderer = new VideoRendererBlock(playerPipeline, VideoView1);

// Connect: push source -> parser -> decoder -> renderer
playerPipeline.Connect(h264Source.Output, h264Parser.Input);
playerPipeline.Connect(h264Parser.Output, h264Decoder.Input);
playerPipeline.Connect(h264Decoder.Output, videoRenderer.Input);

// Preload the player pipeline (creates elements but stays in PAUSED state)
await playerPipeline.StartAsync(onlyPreload: true);

// === Pipeline 1: Grabber (RTSP capture) ===
var grabberPipeline = new MediaBlocksPipeline();

var rtspSettings = await RTSPRAWSourceSettings.CreateAsync(
    new Uri("rtsp://admin:password@192.168.1.64:554/stream"),
    "admin", "password");
rtspSettings.Latency = 50;

var rtspSource = new RTSPRAWSourceBlock(rtspSettings);
var bufferSink = new BufferSinkBlock();

// Wire up the callback to push raw H.264 data into the player pipeline
bufferSink.OnDataFrameBuffer += (sender, args) =>
{
    // Copy raw H.264 data from unmanaged memory
    var data = new byte[args.Size];
    System.Runtime.InteropServices.Marshal.Copy(args.Data, data, 0, args.Size);

    // Push into the player pipeline (AVC-to-byte-stream conversion is automatic)
    h264Source.PushData(data, args.Size, args.Timestamp);
};

grabberPipeline.Connect(rtspSource.Output, bufferSink.Input);

// Start grabber (begins RTSP connection and H.264 frame delivery)
await grabberPipeline.StartAsync();

// Wait for initial data to arrive, then resume the player
await Task.Delay(1000);
await playerPipeline.ResumeAsync();
```

#### Pipeline startup sequence

The startup order is critical for live streaming with two pipelines:

1. **Create and connect** the player pipeline blocks.
2. **Preload** the player pipeline (`StartAsync(onlyPreload: true)`) -- transitions to PAUSED, creates GStreamer elements and links pads.
3. **Create and start** the grabber pipeline -- RTSP connection is established, H.264 frames arrive via the callback.
4. **Push data** into the paused player pipeline -- `h264parse` accumulates SPS/PPS parameter sets.
5. **Resume** the player pipeline (`ResumeAsync()`) -- transitions to PLAYING, decoder starts producing frames.

#### AVC vs byte-stream format

RTSP sources typically deliver H.264 in AVC format where each NAL unit is prefixed with a 4-byte big-endian length:

```
AVC:         [00 00 00 17][NAL data...][00 00 1C CC][NAL data...]
              length=23                 length=7372
```

GStreamer's `h264parse` expects Annex B byte-stream format with start codes:

```
Byte-stream: [00 00 00 01][NAL data...][00 00 00 01][NAL data...]
              start code               start code
```

The `PushData()` method converts AVC to byte-stream automatically and in-place (both use 4-byte prefixes, so no buffer reallocation is needed). Data already in byte-stream format is detected and passed through unchanged.

#### Sample applications

- [RTSP RAW Camera H264 Callback Demo (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/RTSP%20RAW%20Camera%20H264%20Callback%20Demo)

#### Platforms

Windows, macOS, Linux.

## Apple Platform Source Blocks

### iOS Video Source Block

iOSVideoSourceBlock provides video capture from the device camera on iOS platforms. It is available only on iOS (not macOS Catalyst).

#### Block info

Name: IOSVideoSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### Enumerate available devices

Use `DeviceEnumerator.Shared.VideoSourcesAsync()` to get a list of available video devices on iOS. Each device is represented by a `VideoCaptureDeviceInfo` object.

#### The sample pipeline

```
graph LR;
    IOSVideoSourceBlock-->VideoRendererBlock;
```

#### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// select the first available video device
var device = (await DeviceEnumerator.Shared.VideoSourcesAsync())[0];
VideoCaptureDeviceSourceSettings videoSourceSettings = null;
if (device != null)
{
    var formatItem = device.VideoFormats[0];
    if (formatItem != null)
    {
        videoSourceSettings = new VideoCaptureDeviceSourceSettings(device)
        {
            Format = formatItem.ToFormat()
        };
        videoSourceSettings.Format.FrameRate = formatItem.FrameRateList[0];
    }
}

// create iOS video source block
var videoSource = new IOSVideoSourceBlock(videoSourceSettings);

// create video renderer block
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// connect blocks
pipeline.Connect(videoSource.Output, videoRenderer.Input);

// start pipeline
await pipeline.StartAsync();
```

#### Platforms

iOS (not available on macOS Catalyst)

---

### macOS Audio Source Block

SystemAudioSourceBlock, configured with `OSXAudioSourceSettings`, provides audio capture from input devices on macOS platforms.

#### Block info

Name: SystemAudioSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output audio | Uncompressed audio | 1 |

#### Enumerate available devices

Use `DeviceEnumerator.Shared.AudioSourcesAsync()` to get a list of available audio devices on macOS. Each device is represented by an `AudioCaptureDeviceInfo` object.

#### The sample pipeline

```
graph LR;
    SystemAudioSourceBlock-->AudioRendererBlock;
```

#### Sample code

```
// create pipeline
var pipeline = new MediaBlocksPipeline();

// select the first available audio device
var devices = await DeviceEnumerator.Shared.AudioSourcesAsync();
var device = devices.Length > 0 ? devices[0] : null;
OSXAudioSourceSettings audioSourceSettings = null;
if (device != null)
{
    // the device constructor records the stable CoreAudio unique-id and the enumerated format
    audioSourceSettings = new OSXAudioSourceSettings(device);
}

// create macOS audio source block
var audioSource = new SystemAudioSourceBlock(audioSourceSettings);

// create audio renderer block
var audioRenderer = new AudioRendererBlock();

// connect blocks
pipeline.Connect(audioSource.Output, audioRenderer.Input);

// start pipeline
await pipeline.StartAsync();
```

#### Platforms

macOS (not available on iOS)

---

### Blu-Ray Source Block

The `BluRaySourceBlock` reads video, audio, and optional subtitle streams from a Blu-Ray disc or Blu-Ray disc image folder using GStreamer's `bluray` element.

#### Block info

Name: BluRaySourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 0 or 1 |
| Output audio | Uncompressed audio | 0 or 1 |
| Output subtitle | Subtitle | 0 or 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Location` | `string` | required | Path to Blu-Ray device or disc image folder |
| `Title` | `int` | `-1` | Title to play (−1 = main/longest title) |
| `RenderVideo` | `bool` | `true` | Enable video output pad |
| `RenderAudio` | `bool` | `true` | Enable audio output pad |
| `RenderSubtitle` | `bool` | `false` | Enable subtitle output pad |
| `AudioStream` | `int` | `-1` | Audio stream index (−1 = default) |
| `SubtitleStream` | `int` | `-1` | Subtitle stream index (−1 = default) |

#### The sample pipeline

```
graph LR;
    BluRaySourceBlock -- Video --> VideoRendererBlock;
    BluRaySourceBlock -- Audio --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new BluRaySourceSettings("/dev/sr0")
{
    Title = -1,
    RenderVideo = true,
    RenderAudio = true
};

var source = new BluRaySourceBlock(settings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(source.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(source.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = BluRaySourceBlock.IsAvailable();
```

#### Platforms

Windows, macOS, Linux.

---

### DVB Source Block

The `DVBSourceBlock` captures a live digital television stream from a DVB adapter (DVB-T, DVB-C, DVB-S, DVB-S2, or ISDB-T). The block tunes to the specified channel and outputs a raw MPEG-TS stream.

#### Block info

Name: DVBSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | MPEG-TS stream | 1 |

#### Settings

`DVBSourceSettings` contains extensive tuning parameters. Core properties:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `AdapterID` | `int` | `0` | DVB adapter device index |
| `FrontendID` | `int` | `0` | Frontend device index |
| `DeliverySystem` | `DVBDeliverySystem` | Undefined | DVB-T / DVB-C / DVB-S / DVB-S2 / ISDB-T |
| `Frequency` | `uint` | `0` | Center frequency in Hz (or kHz for satellite) |
| `Pids` | `string` | `"8192"` | PID filter list (8192 = full transport stream) |
| `Modulation` | `DVBModulation` | QAM\_16 | Modulation scheme |
| `SymbolRate` | `uint` | `0` | Symbol rate in kBd (satellite) |
| `BandwidthHZ` | `uint` | `0` | Channel bandwidth in Hz (DVB-T) |

Additional properties cover guard interval, transmission mode, hierarchy, code rates, LNB configuration, DiSEqC, ISDB-T layer parameters, and tuning timeouts.

Events fired during tuning: `TuningStart`, `TuningDone`, `TuningFail`.

#### The sample pipeline

```
graph LR;
    DVBSourceBlock-->DecodeBinBlock;
    DecodeBinBlock -- Video --> VideoRendererBlock;
    DecodeBinBlock -- Audio --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new DVBSourceSettings
{
    AdapterID = 0,
    DeliverySystem = DVBDeliverySystem.DVBT,
    Frequency = 506000000,
    BandwidthHZ = 8000000
};

var dvb = new DVBSourceBlock(settings);
dvb.TuningDone += (s, e) => Console.WriteLine("Tuning complete");

// Decode the MPEG-TS stream
var decoder = new DecodeBinBlock();
pipeline.Connect(dvb.VideoOutput, decoder.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(decoder.VideoOutput, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = DVBSourceBlock.IsAvailable();
```

#### Platforms

Windows, Linux.

---

### PulseAudio Source Block

The `PulseAudioSourceBlock` captures audio from a PulseAudio device on Linux. It implements `IAudioVolumeMute` for real-time volume and mute control.

#### Block info

Name: PulseAudioSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output audio | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Device` | `AudioCaptureDeviceInfo` | — | Capture device (from device enumerator) |
| `Format` | `AudioCaptureDeviceFormat` | — | Audio format (sample rate, channels, bit depth) |
| `DeviceName` | `string` | `null` | PulseAudio device name (null = system default) |
| `ClientName` | `string` | `"VisioForge"` | Name shown in audio control applications |
| `ProvideClock` | `bool` | `true` | Provide clock for the pipeline |

#### The sample pipeline

```
graph LR;
    PulseAudioSourceBlock-->AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Enumerate PulseAudio devices
var devices = await DeviceEnumerator.Shared.AudioSourcesAsync();
var device = devices[0];
var format = device.Formats[0];

var settings = new PulseAudioSourceSettings(device, format);
var audioSource = new PulseAudioSourceBlock(settings);

// Optional: control volume at runtime
audioSource.SetVolume(0.8);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(audioSource.Output, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = PulseAudioSourceBlock.IsAvailable();
```

#### Platforms

Linux.

---

### Raspberry Pi Source Block

The `RaspberryPiSourceBlock` captures video from the Raspberry Pi Camera Module using the `rpicamsrc` GStreamer element. It outputs H.264-encoded video and supports camera controls including rotation, flip, and image adjustments.

#### Block info

Name: RaspberryPiSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | H.264 video | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `CameraNumber` | `int` | `0` | Camera index for multi-camera setups |
| `Width` | `uint` | `1920` | Capture width in pixels |
| `Height` | `uint` | `1080` | Capture height in pixels |
| `FrameRate` | `VideoFrameRate` | FPS\_30 | Capture frame rate |
| `Bitrate` | `uint` | `17000000` | H.264 bitrate in bps |
| `Rotation` | `int` | `0` | Rotation in degrees: 0, 90, 180, 270 |
| `HorizontalFlip` | `bool` | `false` | Flip image horizontally |
| `VerticalFlip` | `bool` | `false` | Flip image vertically |
| `Brightness` | `int` | `50` | Brightness: 0–100 |
| `Contrast` | `int` | `0` | Contrast: −100 to 100 |
| `Saturation` | `int` | `0` | Saturation: −100 to 100 |
| `ISO` | `uint` | `0` | ISO sensitivity (0 = auto) |
| `ExposureMode` | `string` | `"auto"` | Exposure mode (auto, night, sports, etc.) |
| `AWBMode` | `string` | `"auto"` | Auto white balance mode |

#### The sample pipeline

```
graph LR;
    RaspberryPiSourceBlock-->H264DecoderBlock;
    H264DecoderBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new RaspberryPiSourceSettings
{
    Width = 1920,
    Height = 1080,
    FrameRate = VideoFrameRate.FPS_30,
    Rotation = 0,
    Bitrate = 17000000
};

var camera = new RaspberryPiSourceBlock(settings);

// Decode H.264 output before rendering
var decoder = new H264DecoderBlock();
pipeline.Connect(camera.Output, decoder.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = RaspberryPiSourceBlock.IsAvailable();
```

#### Platforms

Linux (Raspberry Pi).

---

### GStreamer PlayBin Source Block

The `PlayBinSourceBlock` plays back media using GStreamer's built-in `playbin` element. It accepts the same `UniversalSourceSettings` as `UniversalSourceBlock` but delegates the entire decoding pipeline to GStreamer's high-level playback engine.

#### Block info

Name: PlayBinSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 0 or 1 |
| Output audio | Uncompressed audio | 0 or 1 |
| Output subtitle | Subtitle | 0 or 1 |

#### Settings

Uses `UniversalSourceSettings`. Key properties:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `URI` | `Uri` | required | Media source URI |
| `RenderVideo` | `bool` | `true` | Enable video output pad |
| `RenderAudio` | `bool` | `true` | Enable audio output pad |
| `RenderSubtitle` | `bool` | `false` | Enable subtitle output pad |
| `StartPosition` | `TimeSpan?` | `null` | Playback start position |
| `StopPosition` | `TimeSpan?` | `null` | Playback stop position |
| `VideoCustomFrameRate` | `VideoFrameRate?` | `null` | Override output frame rate |

#### The sample pipeline

```
graph LR;
    PlayBinSourceBlock -- Video --> VideoRendererBlock;
    PlayBinSourceBlock -- Audio --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = await UniversalSourceSettings.CreateAsync(new Uri("file:///video.mp4"));
var source = new PlayBinSourceBlock(settings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(source.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(source.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, Android, iOS.

---

### Basic File Source Block

The `BasicFileSourceBlock` reads raw binary data from a file and exposes it as a single output pad. An optional type-find stage can detect the stream format automatically so it can be connected to a demuxer or decoder.

#### Block info

Name: BasicFileSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output | Auto (raw data) | 1 |

#### Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `filename` | `string` | — | Path to the source file |
| `addTypeFind` | `bool` | `false` | Add a type-find element for automatic format detection |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock-->DecodeBinBlock;
    DecodeBinBlock -- Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Read file with automatic type detection
var fileSource = new BasicFileSourceBlock("video.ts", addTypeFind: true);

var decoder = new DecodeBinBlock();
pipeline.Connect(fileSource.Output, decoder.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(decoder.VideoOutput, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = BasicFileSourceBlock.IsAvailable();
```

#### Platforms

Windows, macOS, Linux, Android, iOS.

---

### Custom Mixer Source Block

The `CustomMixerSourceBlock` is a push-based source that accepts externally provided video and audio frames via managed queues, exposing them as live output pads. It is designed for custom mixing and compositing pipelines where frames originate from application code.

#### Block info

Name: CustomMixerSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |
| Output audio | Uncompressed audio | 1 |

#### Settings

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Width` | `int` | `1920` | Video width in pixels |
| `Height` | `int` | `1080` | Video height in pixels |
| `VideoFormat` | `VideoFormatX` | BGRA | Video pixel format |
| `FrameRate` | `VideoFrameRate` | 30 fps | Output frame rate |
| `AudioFormat` | `AudioFormatX` | S16LE | Audio sample format |
| `AudioSampleRate` | `int` | `48000` | Audio sample rate in Hz |
| `AudioChannels` | `int` | `2` | Number of audio channels |
| `IsLive` | `bool` | `true` | Mark source as live |
| `DoTimestamp` | `bool` | `true` | Automatically timestamp pushed buffers |
| `EnableThreadedPush` | `bool` | `true` | Push frames from a dedicated thread |
| `ManagedQueueMaxBuffers` | `int` | `4` | Maximum queued frames before dropping |

#### Events

- `QueueDropped` — fired when the managed queue drops a buffer due to backpressure.

#### The sample pipeline

```
graph LR;
    CustomMixerSourceBlock -- Video --> VideoRendererBlock;
    CustomMixerSourceBlock -- Audio --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new CustomMixerSourceSettings
{
    Width = 1280,
    Height = 720,
    FrameRate = VideoFrameRate.FPS_30,
    AudioSampleRate = 48000,
    AudioChannels = 2
};

var mixerSource = new CustomMixerSourceBlock(settings);
mixerSource.QueueDropped += (s, e) => Console.WriteLine("Buffer dropped");

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(mixerSource.VideoOutput, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = CustomMixerSourceBlock.IsAvailable();
```

#### Platforms

Windows, macOS, Linux, Android, iOS.

---

### Image Video Source Cairo Block

The `ImageVideoSourceCairoBlock` renders a static or animated image (including animated GIFs) as a continuous video stream using the Cairo 2D graphics library. Unlike the standard image source, the output frame size is specified explicitly via a `Size` constructor parameter.

#### Block info

Name: ImageVideoSourceCairoBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### Constructor parameters

| Parameter | Type | Description |
| --- | --- | --- |
| `pipeline` | `MediaBlocksPipeline` | Owning pipeline |
| `settings` | `ImageVideoSourceSettings` | Image source settings |
| `videoSize` | `Size` | Output frame dimensions in pixels |

#### Settings (ImageVideoSourceSettings)

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Filename` | `string` | required | Path to the image file |
| `FrameRate` | `VideoFrameRate` | 10 fps | Output frame rate |
| `IsLive` | `bool` | `false` | Mark source as live |
| `NumBuffers` | `int` | `-1` | Frames to output (−1 = unlimited) |
| `AnimationInfiniteLoop` | `bool` | `true` | Loop animated images infinitely |

#### The sample pipeline

```
graph LR;
    ImageVideoSourceCairoBlock-->VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new ImageVideoSourceSettings("image.png")
{
    FrameRate = VideoFrameRate.FPS_30,
    IsLive = true
};

var imageSource = new ImageVideoSourceCairoBlock(pipeline, settings, new Size(1920, 1080));

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(imageSource.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux.

---

### Universal Source Block Mini

The `UniversalSourceBlockMini` is a lightweight variant of `UniversalSourceBlock` using the same `UniversalSourceSettings`. It uses a simplified internal pipeline suited for low-resource environments or scenarios where the full decoding engine overhead is undesirable.

#### Block info

Name: UniversalSourceBlockMini.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 0 or 1 |
| Output audio | Uncompressed audio | 0 or 1 |
| Output subtitle | Subtitle | 0 or 1 |

#### Settings

Uses `UniversalSourceSettings` — the same class as `UniversalSourceBlock`.

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `URI` | `Uri` | required | Media source URI |
| `RenderVideo` | `bool` | `true` | Enable video output |
| `RenderAudio` | `bool` | `true` | Enable audio output |
| `RenderSubtitle` | `bool` | `false` | Enable subtitle output |
| `StartPosition` | `TimeSpan?` | `null` | Playback start position |
| `StopPosition` | `TimeSpan?` | `null` | Playback stop position |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlockMini -- Video --> VideoRendererBlock;
    UniversalSourceBlockMini -- Audio --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = await UniversalSourceSettings.CreateAsync(new Uri("file:///video.mp4"));
var source = new UniversalSourceBlockMini(settings);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(source.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(source.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

```
bool available = UniversalSourceBlockMini.IsAvailable();
```

#### Platforms

Windows, macOS, Linux, Android, iOS.

---

### Universal Source Block V2

The `UniversalSourceBlockV2` is an advanced multi-stream media source that exposes separate output pad lists for video, audio, subtitle, and metadata streams. It is suited for complex media files with multiple tracks and scenarios requiring per-stream decoder control.

#### Block info

Name: UniversalSourceBlockV2.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 0…N |
| Output audio | Uncompressed audio | 0…N |
| Output subtitle | Subtitle | 0…N |
| Output metadata | Metadata | 0…N |

#### Settings (UniversalSourceSettingsV2)

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `URI` | `Uri` | required | Media source URI |
| `RenderVideo` | `bool` | `true` | Enable video output pads |
| `RenderAudio` | `bool` | `true` | Enable audio output pads |
| `RenderSubtitle` | `bool` | `false` | Enable subtitle output pads |
| `StartPosition` | `TimeSpan?` | `null` | Playback start position |
| `StopPosition` | `TimeSpan?` | `null` | Playback stop position |
| `VideoCustomFrameRate` | `VideoFrameRate?` | `null` | Override output frame rate |

#### The sample pipeline

```
graph LR;
    UniversalSourceBlockV2 -- Video --> VideoRendererBlock;
    UniversalSourceBlockV2 -- Audio --> AudioRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new UniversalSourceSettingsV2(new Uri("file:///multi_track.mkv"))
{
    RenderVideo = true,
    RenderAudio = true
};

var source = new UniversalSourceBlockV2(settings);

// Access first video and audio streams
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(source.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(source.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

#### Platforms

Windows, macOS, Linux, Android, iOS.

## Android Platform Source Blocks

### USB (UVC) Camera Source Block

AndroidUVCSourceBlock captures video from a USB (UVC) camera attached to an Android device over OTG - a webcam, a capture dongle, or a borescope. [System Video Source](#system-video-source) cannot reach such a camera: Android exposes USB cameras through Camera2 only on devices whose vendor ships the External Camera HAL, and many popular phones do not. This block reads frames through a bundled native libusb/libuvc bridge instead, so it works regardless of the vendor's HAL.

`AndroidUVCSourceSettings` can also be assigned to `VideoCaptureCoreX.Video_Source`, which gives the camera the engine's outputs, effects and snapshots without building a pipeline by hand. `AndroidUVCDevices.GetModes()` lists the resolutions, frame rates and formats a camera advertises in a format this block can stream.

For a full walkthrough with permissions, mode selection, and disconnect handling, see [USB camera capture on Android](../../general/guides/android-usb-camera/).

#### Block info

Name: AndroidUVCSourceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |

#### Settings

`AndroidUVCSourceSettings` selects the device and the requested format.

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Device` | `UsbDevice` | - | The USB camera to stream from. Required. |
| `Width` | `int` | 1280 | Requested frame width, in pixels. |
| `Height` | `int` | 720 | Requested frame height, in pixels. |
| `FrameRate` | `VideoFrameRate` | 30 | Requested frame rate. Fractional rates such as 29.97 are matched exactly. |
| `Format` | `AndroidUVCFrameFormat` | `Unknown` | Preferred frame format. `Unknown` lets the SDK choose, which favours MJPEG. Set it to stream an uncompressed mode the default would pass over. |

#### Requirements

- **Android 9 (API level 28) or newer.** Check at run time with `AndroidUVCDevices.IsSupportedPlatform()`.
- **`android.permission.CAMERA`, declared and granted at run time** - Android refuses to hand a USB video device to an app without it, even though the Camera2 API is never used.
- **Permission for the USB device itself**, obtained through `AndroidUVCDevices.RequestPermissionAsync`.
- `android.hardware.usb.host` declared in `AndroidManifest.xml`.

#### Enumerate available devices

Use `AndroidUVCDevices.FindCameras()` to list the attached USB cameras. It returns the `UsbDevice` objects that expose a UVC video interface; `AndroidUVCSourceBlock.GetDevices()` is an equivalent shortcut. `AndroidUVCDevices.IsCamera(UsbDevice)` tests a single device, and `AndroidUVCDevices.HasPermission(UsbDevice)` reports whether access was already granted.

#### The sample pipeline

```
graph LR;
    AndroidUVCSourceBlock-->VideoRendererBlock;
```

#### Sample code

These types are compiled only for the Android target framework, so in a multi-targeted project this code belongs in an Android-only file or inside `#if ANDROID`.

```
using VisioForge.Core.GStreamer.Android.UVC;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.Sources.AndroidUVC;

// list the attached USB cameras
var cameras = AndroidUVCDevices.FindCameras();
if (cameras.Count == 0)
{
    return;
}

var camera = cameras[0];

// ask the user for access to this device
if (!await AndroidUVCDevices.RequestPermissionAsync(camera))
{
    return;
}

// create pipeline
var pipeline = new MediaBlocksPipeline();

// the stream ends when the camera is unplugged
pipeline.OnStop += Pipeline_OnStop;

var settings = new AndroidUVCSourceSettings
{
    Device = camera,
    Width = 1280,
    Height = 720,
    FrameRate = new VideoFrameRate(30),
};

// create USB camera source block
var videoSource = new AndroidUVCSourceBlock(settings);

// create video renderer block
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1) { IsSync = false };

// connect blocks
pipeline.Connect(videoSource.Output, videoRenderer.Input);

// start pipeline
await pipeline.StartAsync();
```

#### Remarks

`AndroidUVCSourceBlock.IsAvailable()` reports whether USB capture is possible at all on the current device - the Android release is new enough, the elements every mode needs are present, and the native bridge loads. It does not probe `jpegdec`, which only an MJPEG mode needs, and it does not check whether a camera is attached; use `GetDevices()` for that.

The requested resolution and frame rate are matched against the modes the camera advertises rather than imposed on it. The nearest resolution by pixel count wins, MJPEG is preferred over uncompressed formats, and the nearest frame rate is chosen last. A mismatch is a warning, not an error. The SDK logs the mode it settled on as `USB camera ready: WxH@fps FORMAT`, so check that line in logcat if the exact format matters.

Over the High Speed USB link most phones provide, MJPEG is the only practical choice. A camera advertising 1080p30 in MJPEG typically manages about 5 fps uncompressed at the same resolution, and 4K modes are usually absent from the descriptors entirely.

Unplugging the camera ends the stream: the pipeline raises `OnStop` instead of stalling silently. The renderer keeps displaying the last frame it received, and a camera pulled out mid-frame delivers a damaged one, so clear or hide your preview when the stream ends.

Only one process can stream from a UVC camera at a time. If another application holds the device, `StartAsync` fails.

#### Platforms

Android.

---END OF PAGE---


## Special Media Blocks in C# .NET — Tee, Null, Custom
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Special/
**Description:** Use Tee splitters, Null renderers, and custom Super MediaBlock for advanced pipeline routing in VisioForge Media Blocks SDK for .NET.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming
**API:** MediaBlocksPipeline, VideoRendererBlock, UniversalSourceBlock, UniversalSourceSettings, MediaBlockPadMediaType

# Special blocks

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction

Special blocks are blocks that do not fit into any other category.

## MPEG-TS Analyzer

The `TSAnalyzerBlock` is a broadcast-grade MPEG-TS monitor: it reports the program line-up (PAT/PMT/PSI), per-PID and total bitrate, PCR timing, scrambling, DVB service information, codec details, and full ETSI TR 101 290 Priority 1/2/3 compliance — from a file or a live UDP/SRT feed, either as a terminal sink or as an inline passthrough.

For the complete reference — modes, settings, the report model, and code samples — see the dedicated [MPEG-TS Stream Analyzer Block](TSAnalyzerBlock/) page.

### Block info

Name: TSAnalyzerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | MPEG-TS byte stream | 1 |
| Output | MPEG-TS byte stream (passthrough) | 1 in `InputOutput` mode, 0 in `Input` mode |

### Platforms

Windows, macOS, Linux, iOS, Android.

## Null Renderer

The null renderer block sends the data to null. This block may be required if your block has outputs you do not want to use.

### Block info

Name: NullRendererBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any | 1 |

### The sample pipeline

The sample pipeline is shown below. It reads a file and sends the video data to the video samples grabber, where you can grab each video frame after decoding. The Null renderer block is used to end the pipeline.

```
graph LR;
    UniversalSourceBlock-->VideoSampleGrabberBlock;
    VideoSampleGrabberBlock-->NullRendererBlock;
```

### Sample code

```
private void Start()
{
  // create the pipeline
  var pipeline = new MediaBlocksPipeline();

  // create universal source block
  var filename = "test.mp4";
  var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

  // create video sample grabber block and add the event handler
  var sampleGrabber = new VideoSampleGrabberBlock();
  sampleGrabber.OnVideoFrameBuffer += sampleGrabber_OnVideoFrameBuffer;

  // create null renderer block (pad media type is required — match the upstream output)
  var nullRenderer = new NullRendererBlock(MediaBlockPadMediaType.Video);

  // connect blocks
  pipeline.Connect(fileSource.VideoOutput, sampleGrabber.Input);
  pipeline.Connect(sampleGrabber.Output, nullRenderer.Input);

  // start the pipeline
  await pipeline.StartAsync();
}

private void sampleGrabber_OnVideoFrameBuffer(object sender, VideoFrameXBufferEventArgs e)
{
    // received new video frame
}
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Tee

The tee block splits the video or audio data stream into multiple streams that completely copy the original stream.

### Block info

Name: TeeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any | 1 |
| Output | Same as input | 2 or more |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->TeeBlock;
    TeeBlock-->VideoRendererBlock;
    TeeBlock-->H264EncoderBlock;
    H264EncoderBlock-->MP4SinkBlock;
```

### Constructor

```
TeeBlock(int numOfOutputs, MediaBlockPadMediaType mediaType, TeeQueueSettings queueSettings = null)
```

Parameters:

- `numOfOutputs` - The initial number of output pads to create (must be at least 1).
- `mediaType` - The type of media this tee will handle (Video, Audio, or Auto).
- `queueSettings` - Optional queue settings for controlling buffering behavior. If null, uses low-latency defaults.

### Queue settings

The `TeeQueueSettings` class (namespace `VisioForge.Core.Types.X.Special`) controls the buffering behavior for each tee output. By default, TeeBlock uses low-latency settings (1 buffer per queue) instead of GStreamer defaults (200 buffers).

#### TeeQueueSettings properties

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| MaxSizeBuffers | uint | 1 | Maximum number of buffers in the queue. Set to 0 to disable. GStreamer default is 200. |
| MaxSizeBytes | uint | 0 | Maximum bytes in queue. Set to 0 to disable. GStreamer default is 10485760 (10 MB). |
| MaxSizeTime | ulong | 0 | Maximum time in nanoseconds. Set to 0 to disable. GStreamer default is 1000000000 (1 second). |
| MinThresholdBuffers | uint | 0 | Minimum buffer count before allowing reading. |
| MinThresholdBytes | uint | 0 | Minimum bytes before allowing reading. |
| MinThresholdTime | ulong | 0 | Minimum time in nanoseconds before allowing reading. |
| Leaky | TeeQueueLeaky | No | Where the queue leaks when full (No, Upstream, or Downstream). |
| FlushOnEos | bool | false | Discard all data when EOS is received. |
| Silent | bool | true | Suppress queue signals for better performance. |

#### TeeQueueLeaky enum

| Value | Description |
| --- | --- |
| No | No leaking - queue will block when full. |
| Upstream | Leak on upstream side (drop incoming buffers when full). |
| Downstream | Leak on downstream side (drop old buffers when full). |

#### Factory methods

- `TeeQueueSettings.LowLatency()` - Creates settings optimized for minimal latency (1 buffer, no byte/time limits). This is the default behavior.
- `TeeQueueSettings.GStreamerDefaults()` - Creates settings matching GStreamer defaults (200 buffers, 10 MB, 1 second).

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoTee = new TeeBlock(2, MediaBlockPadMediaType.Video);
var h264Encoder = new H264EncoderBlock(new OpenH264EncoderSettings());
var mp4Muxer = new MP4SinkBlock(new MP4SinkSettings(@"output.mp4"));
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(fileSource.VideoOutput, videoTee.Input);
pipeline.Connect(videoTee.Outputs[0], videoRenderer.Input);
pipeline.Connect(videoTee.Outputs[1], h264Encoder.Input);
pipeline.Connect(h264Encoder.Output, mp4Muxer.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Using custom queue settings

```
// Use GStreamer default buffering (higher latency, more buffering)
var gstreamerSettings = TeeQueueSettings.GStreamerDefaults();
var videoTee = new TeeBlock(2, MediaBlockPadMediaType.Video, gstreamerSettings);

// Or create custom settings
var customSettings = new TeeQueueSettings
{
    MaxSizeBuffers = 50,
    MaxSizeBytes = 5242880, // 5 MB
    MaxSizeTime = 500000000, // 0.5 seconds
    Leaky = TeeQueueLeaky.Downstream // Drop old buffers when full
};
var audioTee = new TeeBlock(3, MediaBlockPadMediaType.Audio, customSettings);
```

#### Sample applications

- [Simple Capture Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Simple%20Capture%20Demo)

### Platforms

Windows, macOS, Linux, iOS, Android.

## Super MediaBlock

The Super MediaBlock allows you to combine multiple blocks into a single block.

### Block info

Name: SuperMediaBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any | 1 |
| Output | Any | 1 |

### The sample pipeline

```
graph LR;
    VirtualVideoSourceBlock-->SuperMediaBlock;
    SuperMediaBlock-->NullRendererBlock;
```

Inside the SuperMediaBlock:

```
graph LR;
    FishEyeBlock-->ColorEffectsBlock;
```

Final pipeline:

```
graph LR;
    VirtualVideoSourceBlock-->FishEyeBlock;
    subgraph SuperMediaBlock
    FishEyeBlock-->ColorEffectsBlock;
    end
    ColorEffectsBlock-->NullRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var videoViewBlock = new VideoRendererBlock(pipeline, VideoView1);

var videoSource = new VirtualVideoSourceBlock(new VirtualVideoSourceSettings());

var colorEffectsBlock = new ColorEffectsBlock(VisioForge.Core.Types.X.VideoEffects.ColorEffectsPreset.Sepia);
var fishEyeBlock = new FishEyeBlock();

var superBlock = new SuperMediaBlock();
superBlock.Blocks.Add(fishEyeBlock);
superBlock.Blocks.Add(colorEffectsBlock);
superBlock.Configure(pipeline);

pipeline.Connect(videoSource.Output, superBlock.Input);
pipeline.Connect(superBlock.Output, videoViewBlock.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Encryptor Block

The Encryptor block encrypts a media stream using AES encryption in real-time. It can be used to protect video, audio, or any other data stream before writing to storage or sending over the network.

### Block info

Name: EncryptorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any | 1 |
| Output | Any | 1 |

### The sample pipeline

```
graph LR;
    BasicFileSourceBlock-->EncryptorBlock;
    EncryptorBlock-->FileSinkBlock;
```

### Constructor

```
EncryptorBlock(EncryptorDecryptorSettings settings)
```

Parameters:

- `settings` - The AES encryption configuration, including key, initialization vector, and cipher type.

### Availability

Call `EncryptorBlock.IsAvailable()` to verify AES encryption support before creating an instance.

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new EncryptorDecryptorSettings(
    key: "1f9423681beb9a79215820f6bda73d0f",
    iv: "e9aa8e834d8d70b7e0d254ff670dd718");

var fileSource = new BasicFileSourceBlock("input.mp4");
var encryptor = new EncryptorBlock(settings);
var fileSink = new FileSinkBlock("encrypted.bin", false);

pipeline.Connect(fileSource.Output, encryptor.Input);
pipeline.Connect(encryptor.Output, fileSink.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## Decryptor Block

The Decryptor block decrypts an AES-encrypted media stream in real-time, restoring the original data. The key and IV must match those used during encryption. For a complete encrypted file playback solution, consider using [Decryptor Player Block](#decryptor-player-block) instead.

### Block info

Name: DecryptorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any | 1 |
| Output | Any | 1 |

### The sample pipeline

```
graph LR;
    BasicFileSourceBlock-->DecryptorBlock;
    DecryptorBlock-->QueueBlock;
    QueueBlock-->DecodeBinBlock;
    DecodeBinBlock-->VideoRendererBlock;
```

### Constructor

```
DecryptorBlock(EncryptorDecryptorSettings settings)
```

Parameters:

- `settings` - The AES decryption configuration. Key and IV must match the encryption settings.

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var settings = new EncryptorDecryptorSettings(
    key: "1f9423681beb9a79215820f6bda73d0f",
    iv: "e9aa8e834d8d70b7e0d254ff670dd718");

var fileSource = new BasicFileSourceBlock("encrypted.bin");
var decryptor = new DecryptorBlock(settings);
var queue = new QueueBlock();
var decodeBin = new DecodeBinBlock();

pipeline.Connect(fileSource.Output, decryptor.Input);
pipeline.Connect(decryptor.Output, queue.Input);
pipeline.Connect(queue.Output, decodeBin.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(decodeBin.VideoOutput, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## Decryptor Player Block

The Decryptor Player block is a composite source block that combines file reading, AES decryption, queuing, and decoding into a single easy-to-use block. It has no external input pad — it reads and decrypts the file internally. Connect its output pads directly to renderers or further processing blocks.

Internal pipeline: `BasicFileSourceBlock → DecryptorBlock → QueueBlock → DecodeBinBlock`

### Block info

Name: DecryptorPlayerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Output video | Uncompressed video | 1 |
| Output audio | Uncompressed audio | 1 |
| Output subtitle | Subtitle data | 1 (optional) |

### The sample pipeline

```
graph LR;
    DecryptorPlayerBlock-->VideoRendererBlock;
    DecryptorPlayerBlock-->AudioRendererBlock;
```

### Constructor

```
DecryptorPlayerBlock(MediaBlocksPipeline pipeline, string filename, string key, string iv,
    bool renderVideo = true, bool renderAudio = true, bool renderSubtitle = false)
```

Parameters:

- `pipeline` - The parent pipeline instance.
- `filename` - Path to the AES-encrypted media file.
- `key` - Encryption key as a hexadecimal string (32 chars for AES-128, 64 for AES-256).
- `iv` - Initialization vector as a hexadecimal string (always 32 hex characters / 16 bytes).
- `renderVideo` - Whether to expose the video output pad. Default: `true`.
- `renderAudio` - Whether to expose the audio output pad. Default: `true`.
- `renderSubtitle` - Whether to expose the subtitle output pad. Default: `false`.

### Output pads

- `VideoOutput` - Decoded video frames (available when `renderVideo` is `true`).
- `AudioOutput` - Decoded audio samples (available when `renderAudio` is `true`).
- `SubtitleOutput` - Decoded subtitle data (available when `renderSubtitle` is `true`).

### Availability

Call `DecryptorPlayerBlock.IsAvailable()` to verify decryption support before creating an instance.

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var decryptorPlayer = new DecryptorPlayerBlock(
    pipeline,
    filename: "encrypted.bin",
    key: "1f9423681beb9a79215820f6bda73d0f",
    iv: "e9aa8e834d8d70b7e0d254ff670dd718");

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
var audioRenderer = new AudioRendererBlock();

pipeline.Connect(decryptorPlayer.VideoOutput, videoRenderer.Input);
pipeline.Connect(decryptorPlayer.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## SRTP Encryptor Block

The SRTP Encryptor block encrypts RTP media streams using SRTP (Secure Real-time Transport Protocol) as defined in RFC 3711. It provides confidentiality, message authentication, and replay protection for real-time media streams such as video conferencing or live broadcasts.

### Block info

Name: SRTPEncryptorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | RTP | 1 |
| Output | SRTP | 1 |

### The sample pipeline

```
graph LR;
    RTPSourceBlock-->SRTPEncryptorBlock;
    SRTPEncryptorBlock-->RTPSinkBlock;
```

### Constructor

```
SRTPEncryptorBlock(SRTPSettings settings)
```

Parameters:

- `settings` - SRTP encryption configuration including master key, cipher suite, and authentication method.

### Availability

Call `SRTPEncryptorBlock.IsAvailable()` to verify SRTP support before creating an instance.

### Sample code

```
var settings = new SRTPSettings("000102030405060708090A0B0C0D0E0F")
{
    Cipher = SRTPCipher.AES_128_ICM,
    Auth = SRTPAuth.HMAC_SHA1_80
};

var encryptor = new SRTPEncryptorBlock(settings);
```

### Platforms

Windows, macOS, Linux.

## SRTP Decryptor Block

The SRTP Decryptor block decrypts incoming SRTP-encrypted RTP streams back to plaintext RTP. The settings must match those used by the encryptor. It also verifies message authentication tags and provides replay attack protection.

### Block info

Name: SRTPDecryptorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | SRTP | 1 |
| Output | RTP | 1 |

### The sample pipeline

```
graph LR;
    NetworkSourceBlock-->SRTPDecryptorBlock;
    SRTPDecryptorBlock-->RTPDecoderBlock;
```

### Constructor

```
SRTPDecryptorBlock(SRTPSettings settings)
```

Parameters:

- `settings` - SRTP decryption configuration. Must match the encryption settings used on the sender side.

### Availability

Call `SRTPDecryptorBlock.IsAvailable()` to verify SRTP support before creating an instance.

### Sample code

```
var settings = new SRTPSettings("000102030405060708090A0B0C0D0E0F");
var decryptor = new SRTPDecryptorBlock(settings);
```

### Platforms

Windows, macOS, Linux.

## SRTPSettings

The `SRTPSettings` class provides configuration for SRTP encryption and decryption operations. (Source: `VisioForge.Core/Types/X/Special/SRTPSettings.cs`)

### Properties

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| Key | string | — | Master key as a hex string. 32 hex chars (16 bytes) for AES-128-ICM; 64 hex chars (32 bytes) for AES-256-ICM. |
| Cipher | SRTPCipher | AES\_128\_ICM | Encryption algorithm. |
| Auth | SRTPAuth | HMAC\_SHA1\_80 | Authentication method. |
| SSRC | uint | 0 | RTP Synchronization Source identifier. Use 0 to match any SSRC. |

### Constructors

- `SRTPSettings()` - Creates settings with AES-128-ICM cipher and HMAC-SHA1-80 authentication.
- `SRTPSettings(string key)` - Creates settings with the specified master key and defaults.

### Platforms

Windows, macOS, Linux.

## SRTPCipher

The `SRTPCipher` enum defines the encryption algorithms available for SRTP. (Source: `VisioForge.Core/Types/X/Special/SRTPSettings.cs`)

### Enum Values

- `NULL` - No encryption. Provides authentication only.
- `AES_128_ICM` - AES-128 in Integer Counter Mode. Most common choice; requires a 16-byte (32 hex char) key.
- `AES_256_ICM` - AES-256 in Integer Counter Mode. Maximum security; requires a 32-byte (64 hex char) key.

### Platforms

Windows, macOS, Linux.

## SRTPAuth

The `SRTPAuth` enum defines the message authentication methods available for SRTP. (Source: `VisioForge.Core/Types/X/Special/SRTPSettings.cs`)

### Enum Values

- `NULL` - No authentication. Not recommended for production use.
- `HMAC_SHA1_80` - HMAC-SHA1 with an 80-bit authentication tag. Recommended for most applications.
- `HMAC_SHA1_32` - HMAC-SHA1 with a 32-bit authentication tag. Lower bandwidth overhead for constrained networks.

### Platforms

Windows, macOS, Linux.

## AESCipher

The `AESCipher` enum defines the types of AES ciphers that can be used. (Source: `VisioForge.Core/Types/X/Special/AESCipher.cs`)

### Enum Values

- `AES_128`: AES 128-bit cipher key using CBC method.
- `AES_256`: AES 256-bit cipher key using CBC method.

### Platforms

Windows, macOS, Linux, iOS, Android.

## EncryptorDecryptorSettings

The `EncryptorDecryptorSettings` class holds settings for encryption and decryption operations. (Source: `VisioForge.Core/Types/X/Special/EncryptorDecryptorSettings.cs`)

### Properties

- `Cipher` (`AESCipher`): Gets or sets the AES cipher type. Defaults to `AES_128`.
- `Key` (`string`): Gets or sets the encryption key.
- `IV` (`string`): Gets or sets the initialization vector (16 bytes as hex).
- `SerializeIV` (`bool`): Gets or sets a value indicating whether to serialize the IV.

### Constructor

- `EncryptorDecryptorSettings(string key, string iv)`: Initializes a new instance with the given key and initialization vector.

### Platforms

Windows, macOS, Linux, iOS, Android.

## CustomMediaBlockPad

The `CustomMediaBlockPad` class defines information for a pad within a `CustomMediaBlock`. (Source: `VisioForge.Core/Types/X/Special/CustomMediaBlockPad.cs`)

### Properties

- `Direction` (`MediaBlockPadDirection`): Gets or sets the pad direction (input/output).
- `MediaType` (`MediaBlockPadMediaType`): Gets or sets the media type of the pad (e.g., Audio, Video).
- `CustomCaps` (`Gst.Caps`): Gets or sets custom GStreamer capabilities for an output pad.

### Constructor

- `CustomMediaBlockPad(MediaBlockPadDirection direction, MediaBlockPadMediaType mediaType)`: Initializes a new instance with the specified direction and media type.

### Platforms

Windows, macOS, Linux, iOS, Android.

## CustomMediaBlockSettings

The `CustomMediaBlockSettings` class provides settings for configuring a custom media block, potentially wrapping GStreamer elements. (Source: `VisioForge.Core/Types/X/Special/CustomMediaBlockSettings.cs`)

### Properties

- `ElementName` (`string`): Gets the name of the GStreamer element or Media Blocks SDK element. To create a custom GStreamer Bin, include square brackets, e.g., `"[ videotestsrc ! videoconvert ]"`.
- `UsePadAddedEvent` (`bool`): Gets or sets a value indicating whether to use the `pad-added` event for dynamically created GStreamer pads.
- `ElementParams` (`Dictionary<string, object>`): Gets the parameters for the element.
- `Pads` (`List<CustomMediaBlockPad>`): Gets the list of `CustomMediaBlockPad` definitions for the block.
- `ListProperties` (`bool`): Gets or sets a value indicating whether to list element properties to the Debug window after creation. Defaults to `false`.

### Constructor

- `CustomMediaBlockSettings(string elementName)`: Initializes a new instance with the specified element name.

### Platforms

Windows, macOS, Linux, iOS, Android.

## InputSelectorSyncMode

The `InputSelectorSyncMode` enum defines how an input-selector (used by `SourceSwitchSettings`) synchronizes buffers when in `sync-streams` mode. (Source: `VisioForge.Core/Types/X/Special/SourceSwitchSettings.cs`)

### Enum Values

- `ActiveSegment` (0): Sync using the current active segment.
- `Clock` (1): Sync using the clock.

### Platforms

Windows, macOS, Linux, iOS, Android.

## SourceSwitchSettings

The `SourceSwitchSettings` class configures a block that can switch between multiple input sources. (Source: `VisioForge.Core/Types/X/Special/SourceSwitchSettings.cs`)

The summary "Represents the currently active sink pad" from the code comment might be slightly misleading or incomplete for the class name `SourceSwitchSettings`. The properties suggest it's for configuring a source switcher.

### Properties

- `PadsCount` (`int`): Gets or sets the number of input pads. Defaults to `2`.
- `DefaultActivePad` (`int`): Gets or sets the initially active sink pad.
- `CacheBuffers` (`bool`): Gets or sets whether the active pad caches buffers to avoid missing frames when reactivated. Defaults to `false`.
- `DropBackwards` (`bool`): Gets or sets whether to drop buffers that go backwards relative to the last output buffer pre-switch. Defaults to `false`.
- `SyncMode` (`InputSelectorSyncMode`): Gets or sets how the input-selector syncs buffers in `sync-streams` mode. Defaults to `InputSelectorSyncMode.ActiveSegment`.
- `SyncStreams` (`bool`): Gets or sets if all inactive streams will be synced to the running time of the active stream or to the current clock. Defaults to `true`.
- `CustomName` (`string`): Gets or sets a custom name for logging purposes. Defaults to `"SourceSwitch"`.

### Constructor

- `SourceSwitchSettings(int padsCount = 2)`: Initializes a new instance, optionally specifying the number of pads.

### Platforms

Windows, macOS, Linux, iOS, Android.

## Queue Block

The Queue block provides buffering between pipeline elements to smooth out processing variations and enable asynchronous data flow.

### Block info

Name: QueueBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | any | 1 |
| Output | any | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var queue = new QueueBlock();
pipeline.Connect(fileSource.VideoOutput, queue.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(queue.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## MultiQueue Block

The MultiQueue block provides synchronized buffering for multiple streams, essential for maintaining A/V sync in complex pipelines.

### Block info

Name: MultiQueueBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | any | multiple |
| Output | any | multiple |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

// MultiQueueBlock ctor pre-allocates paired input/output pads (default 2).
var multiqueue = new MultiQueueBlock(inputOutputCount: 2);

pipeline.Connect(fileSource.VideoOutput, multiqueue.Inputs[0]);
pipeline.Connect(fileSource.AudioOutput, multiqueue.Inputs[1]);

// Connect outputs to encoders/renderers
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Source Switch

The SourceSwitch block allows dynamic switching between multiple input sources without interrupting the pipeline.

### Block info

Name: SourceSwitchBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | any | multiple |
| Output | any | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source1 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video1.mp4"));
var source2 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video2.mp4"));

// SourceSwitchSettings(padsCount) pre-allocates input pads.
var switchSettings = new SourceSwitchSettings(2) { DefaultActivePad = 0 };
var sourceSwitch = new SourceSwitchBlock(switchSettings);

// Wire sources to the pre-allocated input pads
pipeline.Connect(source1.VideoOutput, sourceSwitch.Inputs[0]);
pipeline.Connect(source2.VideoOutput, sourceSwitch.Inputs[1]);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(sourceSwitch.Output, videoRenderer.Input);

await pipeline.StartAsync();

// Switch to second source
sourceSwitch.Switch(1);
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Universal Decoder

The UniversalDecoder block automatically detects and decodes various compressed audio and video formats.

### Block info

Name: UniversalDecoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | compressed media | 1 |
| Output | uncompressed media | multiple |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var decoder = new UniversalDecoderBlock();
pipeline.Connect(fileSource.VideoOutput, decoder.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(decoder.VideoOutput, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Universal Demux Decoder

The UniversalDemuxDecoder block combines demuxing and decoding in a single block for simplified pipeline construction.

### Block info

Name: UniversalDemuxDecoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | container format | 1 |
| Output video | uncompressed video | 1 |
| Output audio | uncompressed audio | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var demuxDecoder = new UniversalDemuxDecoderBlock(
    await UniversalSourceSettings.CreateAsync("test.mp4"));

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(demuxDecoder.VideoOutput, videoRenderer.Input);

var audioRenderer = new AudioRendererBlock();
pipeline.Connect(demuxDecoder.AudioOutput, audioRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Barcode Detector

The BarcodeDetector block detects and decodes various barcode formats (QR codes, DataMatrix, Code128, EAN-13, and more) in real-time video streams.

For a complete guide with cross-platform examples, see the [Barcode & QR Code Scanner Guide](../Guides/barcode-qr-reader-guide/).

### Block info

Name: BarcodeDetectorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | uncompressed video | 1 |
| Output | uncompressed video | 1 (InputOutput mode) or 0 (InputOnly mode) |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var videoSource = new SystemVideoSourceBlock(videoSettings);

var barcodeDetector = new BarcodeDetectorBlock(BarcodeDetectorMode.InputOutput);
barcodeDetector.OnBarcodeDetected += (sender, args) =>
{
    Console.WriteLine($"Barcode detected: {args.BarcodeType} - {args.Value}");
};
pipeline.Connect(videoSource.Output, barcodeDetector.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(barcodeDetector.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## DataMatrix Decoder

The DataMatrixDecoder block detects and decodes DataMatrix 2D barcodes in video streams.

### Block info

Name: DataMatrixDecoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | uncompressed video | 1 |
| Output | uncompressed video | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var videoSource = new SystemVideoSourceBlock(videoSettings);

var dataMatrixDecoder = new DataMatrixDecoderBlock();
dataMatrixDecoder.OnDataMatrixDetected += (sender, args) =>
{
    Console.WriteLine($"DataMatrix detected: {args.Data}");
};
pipeline.Connect(videoSource.Output, dataMatrixDecoder.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(dataMatrixDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Frame Doubler

The FrameDoubler block duplicates video frames to increase the effective frame rate.

### Block info

Name: FrameDoublerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | uncompressed video | 1 |
| Output | uncompressed video | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var frameDoubler = new FrameDoublerBlock();
pipeline.Connect(fileSource.VideoOutput, frameDoubler.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(frameDoubler.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Decode Bin

The DecodeBin block automatically selects and manages appropriate decoders for media streams.

### Block info

Name: DecodeBinBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | compressed media | 1 |
| Output | uncompressed media | dynamic |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var decodeBin = new DecodeBinBlock();
pipeline.Connect(fileSource.VideoOutput, decodeBin.Input);

// DecodeBin will create output pads dynamically as streams are discovered
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Parse Bin

The ParseBin block automatically parses media streams and exposes elementary streams.

### Block info

Name: ParseBinBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | compressed media | 1 |
| Output | parsed streams | dynamic |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var parseBin = new ParseBinBlock();
pipeline.Connect(fileSource.VideoOutput, parseBin.Input);

// ParseBin will create output pads for each discovered stream
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Custom Transform

The CustomTransform block allows integration of custom transformation logic into the pipeline.

### Block info

Name: CustomTransformBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | any | 1 |
| Output | any | 1 |

### Sample code

Wrap any GStreamer element (or bin) in a Media Blocks pipeline via `CustomMediaBlock` + `CustomMediaBlockSettings`. `ElementName` is set through the constructor; element-specific parameters go in the `ElementParams` dictionary.

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

// Wrap the GStreamer "videoscale" element.
var customSettings = new CustomMediaBlockSettings("videoscale");
customSettings.ElementParams.Add("method", 0);
var customBlock = new CustomMediaBlock(customSettings);

pipeline.Connect(fileSource.VideoOutput, customBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(customBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

> **Note:** `CustomTransformBlock` is a different, lower-level block designed for pushing samples programmatically from C# code (via `PushSample`/`PushBuffer`) — it does not wrap GStreamer elements by name.

### Platforms

Windows, macOS, Linux, iOS, Android.

## Data Sample Grabber

The DataSampleGrabber block intercepts and provides access to data buffers flowing through the pipeline.

### Block info

Name: DataSampleGrabberBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | any | 1 |
| Output | any | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var dataSG = new DataSampleGrabberBlock();
dataSG.OnDataFrame += (sender, args) =>
{
    // Real event type: EventHandler<DataFrameEventArgs> with a DataFrame on .Frame
    var dataFrame = args.Frame;
};
pipeline.Connect(fileSource.VideoOutput, dataSG.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(dataSG.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Data Processor

The DataProcessor block provides custom data processing capabilities for non-standard data formats.

### Block info

Name: DataProcessorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | any | 1 |
| Output | any | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var dataSource = new CustomDataSource();

var dataProcessor = new DataProcessorBlock();
pipeline.Connect(dataSource.Output, dataProcessor.Input);

// Process and forward data
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Custom Colorspace

The `CustomColorspaceXBlock` converts raw video from RGB to YV12 (YUV 4:2:0 planar) using a built-in C# GStreamer plugin. The conversion applies ITU-R BT.601 coefficients with 2×2 block averaging for chroma subsampling.

Optional `Width`, `Height`, and `FrameRate` properties constrain caps negotiation; leave them unset for auto-negotiation. Width and height values must be even numbers.

`CustomColorspaceXBlock.IsAvailable()` always returns `true` — the plugin is implemented in managed code and requires no external GStreamer dependency.

### Block info

Name: CustomColorspaceXBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | video/x-raw (RGB) | 1 |
| Output | video/x-raw (YV12) | 1 |

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var colorspace = new CustomColorspaceXBlock(width: 1280, height: 720);
pipeline.Connect(fileSource.VideoOutput, colorspace.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(colorspace.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Live Sync

The `LiveSyncBlock` wraps the GStreamer `livesync` element to keep a live pipeline in real time. It drops frames that arrive late and duplicates the last frame when the source stalls, maintaining smooth real-time output without pipeline stalls. Both audio and video streams are supported.

Use this block in live streaming or capture pipelines to absorb timing jitter from network or hardware sources.

### Block info

Name: LiveSyncBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Any | 1 |
| Output | Any | 1 |

### Availability

`LiveSyncBlock.IsAvailable()` returns `true` if the GStreamer `livesync` element is present.

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var rtmpSettings = await RTMPSourceSettings.CreateAsync(new Uri("rtmp://example.com/live/stream"));
var rtmpSource = new RTMPSourceBlock(rtmpSettings);

var liveSync = new LiveSyncBlock();
pipeline.Connect(rtmpSource.VideoOutput, liveSync.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(liveSync.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## Custom Media Block

The `CustomMediaBlock` is a flexible bridge between the MediaBlocks abstraction layer and raw GStreamer elements. It can wrap any GStreamer element by factory name or wrap a bin pipeline description, making it useful for integrating third-party plugins, experimental elements, or functionality not yet covered by a dedicated MediaBlocks class.

The associated settings and pad types (`CustomMediaBlockSettings`, `CustomMediaBlockPad`) are documented in the [CustomMediaBlockSettings](#custommediablocksettings) and [CustomMediaBlockPad](#custommediablockpad) sections above.

### Block info

Name: CustomMediaBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Defined by settings | 0…N |
| Output | Defined by settings | 0…N |

### Key features

- Wrap any GStreamer element by name (e.g., `"videoscale"`) or as a bin description (e.g., `"[ videoscale ! videoconvert ]"`).
- Set element properties via `ElementParams` dictionary before the pipeline starts.
- Receive the raw `Gst.Element` via the `OnElementAdded` event for additional configuration.
- Use `UsePadAddedEvent = true` for elements with dynamic pads (e.g., demuxers).
- Apply optional caps filters on output pads via `CustomMediaBlockPad.CustomCaps`.

### Events

- `OnElementAdded` — fired immediately after the GStreamer element is created and added to the pipeline, allowing direct property or signal configuration on the raw element.

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->CustomMediaBlock;
    CustomMediaBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

// Wrap GStreamer videoscale element with a property
var settings = new CustomMediaBlockSettings("videoscale")
{
    ListProperties = false
};
settings.ElementParams["method"] = 0; // nearest-neighbour
settings.Pads.Add(new CustomMediaBlockPad(MediaBlockPadDirection.In, MediaBlockPadMediaType.Video));
settings.Pads.Add(new CustomMediaBlockPad(MediaBlockPadDirection.Out, MediaBlockPadMediaType.Video));

var customBlock = new CustomMediaBlock(settings);
customBlock.OnElementAdded += (sender, element) =>
{
    // Additional element configuration after creation
};

pipeline.Connect(fileSource.VideoOutput, customBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(customBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Bin description example

```
// Wrap a multi-element GStreamer pipeline as a single block
var settings = new CustomMediaBlockSettings("[ videoscale ! videoconvert ]");
settings.Pads.Add(new CustomMediaBlockPad(MediaBlockPadDirection.In, MediaBlockPadMediaType.Video));
settings.Pads.Add(new CustomMediaBlockPad(MediaBlockPadDirection.Out, MediaBlockPadMediaType.Video));

var customBlock = new CustomMediaBlock(settings);
```

### Platforms

Windows, macOS, Linux, iOS, Android.

---

## Universal Transform Block

The `UniversalTransformBlock` is an abstract base class for implementing custom video frame transformations in managed C# code. It supports 1:N frame transformations: a single input frame can produce zero, one, or multiple output frames, enabling use cases such as frame dropping, duplication, splitting, or format conversion.

Subclass `UniversalTransformBlock`, provide GStreamer caps strings for input and output, and override `OnTransformFrame` to implement the transformation logic.

### Block info

Name: (user-defined subclass).

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | Uncompressed video | 1 |
| Output video | Uncompressed video | 1 |

### Constructor (protected)

```
protected UniversalTransformBlock(string inputCaps, string outputCaps)
```

Parameters:

- `inputCaps` — GStreamer caps string describing the accepted input format (e.g., `"video/x-raw,format=RGB,width=1920,height=1080,framerate=30/1"`).
- `outputCaps` — GStreamer caps string describing the produced output format.

### Abstract method to override

```
protected abstract List<Gst.Buffer> OnTransformFrame(
    Gst.Buffer inputBuffer,
    Gst.Caps inputCaps,
    Gst.Caps outputCaps);
```

Return value semantics:

- **Empty list** — drop the frame (no output produced).
- **One buffer** — standard 1:1 transform.
- **Multiple buffers** — 1:N transform (e.g., frame duplication or splitting).

### Helper methods

- `CreateBuffer(byte[] data, ulong pts, ulong dts, ulong duration)` — creates a `Gst.Buffer` from a managed byte array.
- `GetVideoInfo(Caps caps, out string format, out int width, out int height, out int frameRateNum, out int frameRateDen)` — parses video format, dimensions, and frame rate from a caps object.

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->CustomTransformBlock;
    CustomTransformBlock-->VideoRendererBlock;
```

### Sample code

```
// Define a custom transform: invert every frame (RGB → RGB)
public class InvertTransformBlock : UniversalTransformBlock
{
    public InvertTransformBlock()
        : base(
            inputCaps:  "video/x-raw,format=RGB",
            outputCaps: "video/x-raw,format=RGB")
    {
    }

    protected override List<Gst.Buffer> OnTransformFrame(
        Gst.Buffer inputBuffer,
        Gst.Caps inputCaps,
        Gst.Caps outputCaps)
    {
        // Map input buffer, invert pixels, return new buffer
        using var map = inputBuffer.Map(Gst.MapFlags.Read);
        var data = map.Data.ToArray();
        for (int i = 0; i < data.Length; i++)
            data[i] = (byte)(255 - data[i]);

        var output = CreateBuffer(data, inputBuffer.Pts, inputBuffer.Dts, inputBuffer.Duration);
        return new List<Gst.Buffer> { output };
    }
}

// Use in a pipeline
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));
var transform = new InvertTransformBlock();

pipeline.Connect(fileSource.VideoOutput, transform.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(transform.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

---END OF PAGE---


## MPEG-TS Stream Analyzer Block for C# .NET Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/Special/TSAnalyzerBlock/
**Description:** Analyze MPEG-TS programs, per-PID bitrate, PCR timing and ETSI TR 101 290 compliance in C# with Media Blocks SDK .NET TSAnalyzerBlock — live and in-process.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, MPEG-TS, Streaming, Analysis, TR 101 290, C#
**API:** TSAnalyzerBlock, TSAnalyzerSettings, TSAnalyzerReport, UDPRAWMPEGTSSourceBlock

# MPEG-TS Stream Analyzer Block

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Overview

The `TSAnalyzerBlock` turns the [Media Blocks SDK .NET](https://www.visioforge.com/media-blocks-sdk-net) into a **broadcast-grade MPEG-TS monitor that runs inside your own .NET application** — no external tools, no spawning a CLI, no parsing text output. Point it at a file, a live UDP multicast feed, or an SRT stream and it continuously reports the program line-up, per-PID bitrate, PCR timing, scrambling, service information, and full **ETSI TR 101 290** Priority 1/2/3 compliance — as strongly-typed objects you can bind to a dashboard, log, or alert on.

It analyzes the raw transport stream packet-by-packet (PAT/PMT/PSI parsing, continuity counters, PCR clock recovery, PES timing, codec headers) and surfaces everything through a single `TSAnalyzerReport`. The block runs either as a terminal sink (`Input` mode) or as an inline passthrough (`InputOutput` mode) so you can analyze a stream **while you are still recording or relaying it**.

In short, the block measures:

- **Structure** — PAT/PMT/PSI, programs/services, PMT/PCR PIDs, stream types and codecs.
- **Bitrate** — per-PID and total bitrate (running average, instantaneous, and peak), plus null-padding and effective payload bitrate.
- **Timing** — PCR interval min/avg/max, discontinuities, jitter, repetition errors; PES PTS/DTS presence and audio/video sync offset.
- **Integrity** — continuity-counter errors, transport-error indicator, CRC-32 of PSI tables, and the full TR 101 290 P1/P2/P3 check list.
- **Service info** — SDT service name/provider/type, NIT network name, TDT/TOT stream UTC time, ISO 639 audio language, scrambling state, and (optionally) EIT/EPG events.
- **Codec details** — resolution, profile, level, chroma format, and aspect ratio for H.264, HEVC, and MPEG-2 video.

## How it works

In `Input` mode the block is the terminal of the pipeline — it consumes the transport stream and produces the report:

```
graph LR;
    Source["Source (file / UDP / SRT)"]-->TSAnalyzerBlock;
```

In `InputOutput` mode the untouched stream is forwarded to the output pad, so you can analyze and record/relay at the same time:

```
graph LR;
    Source["Source (file / UDP / SRT)"]-->TSAnalyzerBlock;
    TSAnalyzerBlock-->MPEGTSSinkBlock;
```

### Block info

Name: TSAnalyzerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | MPEG-TS byte stream | 1 |
| Output | MPEG-TS byte stream (passthrough) | 1 in `InputOutput` mode, 0 in `Input` mode |

## Modes

The constructor takes a `TSAnalyzerMode`:

| Mode | Description |
| --- | --- |
| `TSAnalyzerMode.Input` | Terminal analyzer. The block accepts the stream and exposes no output pad — use it when you only need the report. |
| `TSAnalyzerMode.InputOutput` | Passthrough analyzer. The stream is forwarded unchanged to the output pad while it is analyzed, so you can record or relay it in the same pipeline. |

```
TSAnalyzerBlock(TSAnalyzerMode mode = TSAnalyzerMode.Input, TSAnalyzerSettings settings = null)
```

## Quick start

```
using System;
using System.Linq;
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.Types.X;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.Special;

await VisioForgeX.InitSDKAsync();

var pipeline = new MediaBlocksPipeline();

// Live UDP multicast MPEG-TS feed (raw bytes, no demux)
var source = new UDPRAWMPEGTSSourceBlock(new UDPRAWMPEGTSSourceSettings("udp://239.0.0.1:1234"));

// Terminal analyzer with a 1-second snapshot cadence
var analyzer = new TSAnalyzerBlock(
    TSAnalyzerMode.Input,
    new TSAnalyzerSettings { StatisticsInterval = TimeSpan.FromSeconds(1) });

analyzer.OnAnalysisUpdated += (sender, e) =>
{
    TSAnalyzerReport report = e.Report;        // e.IsFinal == true on end-of-stream
    Console.WriteLine($"{report.TotalBitrateKbps:F0} kbps, programs: {report.Programs.Count}");

    if (report.Tr101290 != null && report.Tr101290.P1Count > 0)
    {
        Console.WriteLine($"TR 101 290 Priority 1 errors: {report.Tr101290.P1Count}");
    }
};

pipeline.Connect(source.Output, analyzer.Input);

await pipeline.StartAsync();
// ... run until end-of-stream or a user stop ...
await pipeline.StopAsync();

// You can also pull a snapshot on demand at any time:
TSAnalyzerReport final = analyzer.GetReport();
```

## Feeding the analyzer (file / UDP / SRT)

The analyzer accepts a raw MPEG-TS byte stream from any source block that produces one. The three common feeds:

```
// 1. Local file (.ts / .m2ts)
var fileSource = new BasicFileSourceBlock("stream.ts");
pipeline.Connect(fileSource.Output, analyzer.Input);

// 2. Live UDP (unicast or multicast) — raw MPEG-TS, no demux
var udpSource = new UDPRAWMPEGTSSourceBlock(new UDPRAWMPEGTSSourceSettings("udp://239.0.0.1:1234"));
pipeline.Connect(udpSource.Output, analyzer.Input);

// 3. Live SRT
var srtSettings = await SRTSourceSettings.CreateAsync(new Uri("srt://server:9000"), ignoreMediaInfoReader: true);
var srtSource = new SRTRAWSourceBlock(srtSettings);
pipeline.Connect(srtSource.Output, analyzer.Input);
```

### UDPRAWMPEGTSSourceBlock

`UDPRAWMPEGTSSourceBlock` receives a live UDP unicast or multicast transport stream and exposes the **untouched** MPEG-TS byte stream on its `Output` pad — without demuxing — which is exactly what the analyzer needs. It is configured through `UDPRAWMPEGTSSourceSettings`:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Uri` | `Uri` | — | Source URI, e.g. `udp://239.0.0.1:1234` (multicast) or `udp://0.0.0.0:1234` (all interfaces). |
| `AutoJoinMulticast` | `bool` | `true` | Automatically join/leave the multicast group for multicast addresses. |
| `MulticastInterface` | `string` | `null` | Network interface(s) to join the multicast group on (e.g. `"eth0"` or `"eth0,eth1"`). |
| `BufferSize` | `int` | `524288` | Kernel receive buffer size in bytes; `0` uses the OS default. |
| `PacketSize` | `int` | `188` | Advertised TS packet size: `188` (standard) or `192` (M2TS-style with a 4-byte timecode prefix). |

```
var settings = new UDPRAWMPEGTSSourceSettings("udp://239.0.0.1:1234")
{
    AutoJoinMulticast = true,
    PacketSize = 188
};

var source = new UDPRAWMPEGTSSourceBlock(settings);
```

> **Related block.** If you want the stream **demuxed** into separate encoded video/audio pads (for recording or remuxing without re-encoding) rather than the raw byte stream, use `UDPRAWSourceBlock` instead. See the [UDP MPEG-TS Recording guide](../../Guides/udp-mpegts-record-without-reencoding/).

## Settings

`TSAnalyzerSettings` controls the snapshot cadence and which analysis stages are enabled. Heavier stages can be turned off when you do not need them.

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `StatisticsInterval` | `TimeSpan` | `1 second` | How often a snapshot is produced and `OnAnalysisUpdated` is raised. |
| `TrackPCR` | `bool` | `true` | Track PCR timing (interval statistics and discontinuities). |
| `ValidateContinuity` | `bool` | `true` | Validate continuity-counter errors per PID. |
| `CalculateBitrate` | `bool` | `true` | Calculate per-PID and total bitrate. |
| `PacketSize` | `TSPacketSizeMode` | `Auto` | TS packet size handling — `Auto`, `Size188`, or `Size192`. |
| `ParseServiceInfo` | `bool` | `true` | Parse DVB service information (SDT, NIT, TDT/TOT) for service and network names. |
| `ParseEPG` | `bool` | `false` | Parse EIT for EPG events. Opt-in — it is the heaviest stage. |
| `TrackScrambling` | `bool` | `true` | Track scrambling via the `transport_scrambling_control` bits. |
| `ValidateTR101290` | `bool` | `true` | Evaluate the ETSI TR 101 290 Priority 1/2/3 checks. |
| `TrackPtsDts` | `bool` | `true` | Track PES PTS/DTS presence and audio/video sync. |
| `ParseCodecDetails` | `bool` | `true` | Parse codec details (resolution/profile/level) from SPS/sequence headers. |

`TSPacketSizeMode` values: `Auto` (detect 188 or 192 from the sync-byte spacing), `Size188` (standard MPEG-TS), `Size192` (M2TS / Blu-ray with a 4-byte timestamp prefix).

## The report model

Every snapshot is a `TSAnalyzerReport`. Top-level fields summarize the whole stream; nested collections describe programs, PIDs, and timing.

| Property | Type | Description |
| --- | --- | --- |
| `PacketSize` | `int` | Detected TS packet size (188 or 192). |
| `TotalBitrateKbps` | `double` | Total stream bitrate (running average since analysis start). |
| `TotalPackets` | `long` | Total TS packets analyzed. |
| `HasPAT` | `bool` | Whether a PAT (PID 0) was seen. |
| `TransportErrors` | `long` | Packets with the transport-error indicator set. |
| `Programs` | `List<TSProgramInfo>` | Programs/services discovered from PAT + PMT. |
| `Pids` | `List<TSPidInfo>` | Per-PID statistics. |
| `Pcr` | `List<TSPcrStats>` | PCR timing statistics (one entry per PCR PID). |
| `NullPacketCount` | `long` | Null-padding (PID 0x1FFF) packet count. |
| `NullBitrateKbps` | `double` | Bitrate consumed by null padding. |
| `EffectiveBitrateKbps` | `double` | Effective payload bitrate (total minus null padding). |
| `SyncByteErrors` | `long` | Sync-byte errors (0x47 not at the expected position). |
| `SyncLossEvents` | `long` | Sync-loss events (parser re-sync occurrences). |
| `NetworkName` | `string` | Network name from the NIT network descriptor, or `null`. |
| `StreamTimeUtc` | `DateTime?` | UTC stream time from TDT/TOT, or `null`. |
| `AvSyncMs` | `double?` | Audio/video sync offset in ms (video PTS minus audio PTS), or `null`. |
| `Tr101290` | `TSTR101290Report` | The TR 101 290 measurement report, or `null` if validation is disabled. |
| `Events` | `List<TSEpgEvent>` | EPG events from EIT (when `ParseEPG` is enabled). |

### Programs and elementary streams

`TSProgramInfo` (per program/service):

| Property | Type | Description |
| --- | --- | --- |
| `ProgramNumber` | `int` | Program number (service ID). |
| `PmtPid` | `int` | PID of the PMT for this program. |
| `PcrPid` | `int` | PID carrying the PCR for this program. |
| `Streams` | `List<TSElementaryStreamInfo>` | Elementary streams in this program. |
| `ServiceName` | `string` | Service name from the SDT, or `null`. |
| `ServiceProvider` | `string` | Service provider from the SDT, or `null`. |
| `ServiceType` | `int` | DVB `service_type` byte (e.g. `0x01` = digital television). |
| `IsScrambled` | `bool` | Whether the service is scrambled (SDT `free_CA_mode`). |

`TSElementaryStreamInfo` (per elementary stream):

| Property | Type | Description |
| --- | --- | --- |
| `Pid` | `int` | Elementary stream PID. |
| `StreamType` | `byte` | MPEG-TS `stream_type` byte. |
| `Codec` | `string` | Human-readable codec/content name. |
| `Kind` | `TSPidKind` | Classified media kind (Video, Audio, Private, …). |
| `Language` | `string` | ISO 639 language code from the PMT descriptor, or `null`. |
| `CodecDetails` | `TSCodecDetails` | Parsed codec details, or `null`. |

`TSCodecDetails`: `Width`, `Height`, `FrameRateNum`/`FrameRateDen`, `Profile`, `Level`, `ChromaFormat`, `AspectRatio`. Resolution is parsed for H.264, HEVC, and MPEG-2. Profile, level, and chroma format are parsed for H.264 and HEVC only. Frame rate and aspect ratio are read from the MPEG-1/2 sequence header (not yet from the H.264/HEVC VUI).

### Per-PID statistics

`TSPidInfo`:

| Property | Type | Description |
| --- | --- | --- |
| `Pid` | `int` | Packet identifier. |
| `Kind` | `TSPidKind` | Classified role of the PID. |
| `StreamType` | `byte` | `stream_type` byte (for elementary streams). |
| `Codec` | `string` | Human-readable codec/content name. |
| `BitrateKbps` | `double` | Average bitrate (running average). |
| `InstantBitrateKbps` | `double` | Most recent per-interval bitrate. |
| `PeakBitrateKbps` | `double` | Peak per-interval bitrate observed. |
| `PacketCount` | `long` | Total packets on this PID. |
| `ContinuityErrors` | `long` | Continuity-counter errors detected. |
| `IsPcrPid` | `bool` | Whether this PID carries the PCR. |
| `IsScrambled` | `bool` | Whether scrambled packets were observed. |
| `ScrambledPacketCount` | `long` | Packets with non-zero `transport_scrambling_control`. |
| `IsUnreferenced` | `bool` | PID not referenced by PAT/PMT/PSI and not null padding. |
| `HasPts` / `HasDts` | `bool` | Whether a PTS / DTS was seen in the PES payload. |

### PCR timing

`TSPcrStats`: `Pid`, `SampleCount`, `MinIntervalMs`, `AvgIntervalMs`, `MaxIntervalMs`, `Discontinuities`, `MaxJitterMs` (largest deviation from the running mean interval), and `RepetitionErrors` (intervals exceeding 40 ms per TR 101 290).

## ETSI TR 101 290

TR 101 290 is the DVB measurement standard for transport-stream monitoring. It groups errors into three priorities — **P1** (must be present to decode), **P2** (recommended for continuous monitoring), and **P3** (optional service/SI information). When `ValidateTR101290` is enabled, the analyzer fills `report.Tr101290`:

| Property | Type | Description |
| --- | --- | --- |
| `Checks` | `List<TSTR101290Check>` | Individual checks across all priority groups. |
| `P1Count` / `P2Count` / `P3Count` | `long` | Total error count per priority group. |
| `TotalCount` | `long` | Sum across all groups. |
| `AllOk` | `bool` | `true` when every check passed (`TotalCount == 0`). |

Each `TSTR101290Check` has `Name` (e.g. `PAT_error`, `CRC_error`), `Priority` (1/2/3), `Count`, and `Ok`. The checks evaluated include:

- **Priority 1:** TS\_sync\_loss, Sync\_byte\_error, PAT\_error, Continuity\_count\_error, PMT\_error, PID\_error.
- **Priority 2:** Transport\_error, CRC\_error, PCR\_error, PCR\_repetition\_error (>40 ms), PCR\_discontinuity\_indicator\_error, PCR\_accuracy\_error, PTS\_error (>700 ms), CAT\_error.
- **Priority 3:** NIT\_error, SI\_repetition\_error, Unreferenced\_PID, SDT\_error, EIT\_error, TDT\_error.

```
var tr = report.Tr101290;
if (tr != null && !tr.AllOk)
{
    foreach (var check in tr.Checks.Where(c => c.Count > 0))
    {
        Console.WriteLine($"P{check.Priority} {check.Name}: {check.Count}");
    }
}
```

> **Why this matters.** A stream can play in a media player and still be non-compliant — a PCR that repeats slower than 40 ms, a CC jump, a missing PMT. TR 101 290 is how broadcast operators quantify that. The `TSAnalyzerBlock` gives you the same structured P1/P2/P3 verdicts as a dedicated hardware analyzer, directly in managed code.

## Live updates vs on-demand snapshots

There are two ways to read the report:

- **`OnAnalysisUpdated`** — raised every `StatisticsInterval` with a fresh snapshot, and once more at end-of-stream with `IsFinal == true`. Periodic updates run on a background timer thread; the final report runs on the GStreamer thread. Marshal to the UI thread before touching UI elements.
- **`GetReport()`** — returns the current snapshot on demand (or `null` if the block has not been built). It does not perturb the periodic instant/peak bitrate accounting.

```
analyzer.OnAnalysisUpdated += (sender, e) =>
{
    // e.IsFinal distinguishes the periodic updates from the end-of-stream report.
    Dispatcher.BeginInvoke(() => UpdateUI(e.Report));   // WPF: marshal to UI thread
};
```

## Sample applications

- **WPF — TS Analyzer Demo:** a full UI with a per-PID grid, a TR 101 290 panel, and a summary line (service name, null/effective bitrate, network name, stream UTC, A/V sync). [Browse the source](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/TS%20Analyzer%20Demo).
- **Console — TS Analyzer CLI:** analyzes a file or a live `udp://` / `srt://` feed and prints the full report. [Browse the source](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/Console/TS%20Analyzer%20CLI).

## Availability

Call `TSAnalyzerBlock.IsAvailable()` to verify the analyzer is available in the current environment before creating an instance.

## Platforms

Windows, macOS, Linux, iOS, Android.

## See also

- [MPEG-TS Analysis in C#: VisioForge vs ffprobe](../../Guides/mpeg-ts-analysis-vs-ffprobe/) — how the block compares to ffprobe and professional broadcast analyzers.
- [Analyze and validate an MPEG-TS stream in C#](../../Guides/mpeg-ts-stream-validation-csharp/) — a step-by-step task guide.
- [UDP MPEG-TS Recording without re-encoding](../../Guides/udp-mpegts-record-without-reencoding/).

---END OF PAGE---


## Video Decoder Blocks in C# .NET - H.264, HEVC, AV1
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/VideoDecoders/
**Description:** Decode H.264, HEVC, VP9, AV1, and MJPEG video with hardware acceleration using VisioForge Media Blocks SDK. GPU-accelerated decoding for .NET.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming
**API:** UniversalDemuxBlock, VideoRendererBlock, BasicFileSourceBlock, MediaBlocksPipeline, MediaInfoReaderX, AMAH264DecoderSettings, AMAHEVCDecoderSettings, AMAAV1DecoderSettings

# Video Decoder Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Video Decoder blocks are essential components in a media pipeline, responsible for decompressing encoded video streams into raw video frames that can be further processed or rendered. VisioForge Media Blocks SDK .Net offers a variety of video decoder blocks supporting numerous codecs and hardware acceleration technologies.

## Available Video Decoder Blocks

### H264 Decoder Block

Decodes H.264 (AVC) video streams. This is one of the most widely used video compression standards. The block can utilize different underlying decoder implementations like FFMPEG, OpenH264, or hardware-accelerated decoders if available.

#### Block info

Name: `H264DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | H.264 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### Settings

The `H264DecoderBlock` is configured using settings that implement `IH264DecoderSettings`. Available settings classes include: - `FFMPEGH264DecoderSettings` - `OpenH264DecoderSettings` - `NVH264DecoderSettings` (for NVIDIA GPU acceleration) - `VAAPIH264DecoderSettings` (for VA-API acceleration on Linux) - `AMAH264DecoderSettings` (for AMD AMA / Alveo hardware acceleration on Linux — see [AMD AMA Blocks](../AMA/))

A constructor without parameters will attempt to select an available decoder automatically.

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- H.264 Video Stream --> H264DecoderBlock;
    H264DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create H264 Decoder block
var h264Decoder = new H264DecoderBlock();

// Example: Create a basic file source, demuxer, and renderer
var basicFileSource = new BasicFileSourceBlock("test_h264.mp4");

// Get media info using MediaInfoReaderX
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h264.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), h264Decoder.Input);
pipeline.Connect(h264Decoder.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Availability

You can check for specific decoder implementations using `H264DecoderBlock.IsAvailable(H264DecoderType decoderType)`. `H264DecoderType` includes `FFMPEG`, `OpenH264`, `GPU_Nvidia_H264`, `VAAPI_H264`, etc.

#### Platforms

Windows, macOS, Linux. (Hardware-specific decoders like NVH264Decoder require specific hardware and drivers).

### JPEG Decoder Block

Decodes JPEG (Motion JPEG) video streams or individual JPEG images into raw video frames.

#### Block info

Name: `JPEGDecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | JPEG encoded video/images | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    HTTPSourceBlock -- MJPEG Stream --> JPEGDecoderBlock;
    JPEGDecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create JPEG Decoder block
var jpegDecoder = new JPEGDecoderBlock();

// Example: Create an HTTP source for an MJPEG camera and a video renderer
var httpSettings = new HTTPSourceSettings(new Uri("http://your-mjpeg-camera/stream"));
var httpSource = new HTTPSourceBlock(httpSettings);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // Assuming VideoView1

// Connect blocks
pipeline.Connect(httpSource.Output, jpegDecoder.Input);
pipeline.Connect(jpegDecoder.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Availability

You can check if the underlying NVIDIA JPEG decoder (if applicable) is available using `NVJPEGDecoderBlock.IsAvailable()`. The generic JPEG decoder functionality is generally available.

#### Platforms

Windows, macOS, Linux. (NVIDIA specific implementation requires NVIDIA hardware).

### NVIDIA H.264 Decoder Block (NVH264DecoderBlock)

Provides hardware-accelerated decoding of H.264 (AVC) video streams using NVIDIA's NVDEC technology. This offers high performance and efficiency on systems with compatible NVIDIA GPUs.

#### Block info

Name: `NVH264DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | H.264 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- H.264 Video Stream --> NVH264DecoderBlock;
    NVH264DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create NVIDIA H.264 Decoder block
var nvH264Decoder = new NVH264DecoderBlock();

// Example: Create a basic file source, demuxer, and renderer
var basicFileSource = new BasicFileSourceBlock("test_h264.mp4");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h264.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connect blocks
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvH264Decoder.Input);
pipeline.Connect(nvH264Decoder.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Availability

Check availability using `NVH264DecoderBlock.IsAvailable()`. Requires an NVIDIA GPU that supports NVDEC and appropriate drivers.

#### Platforms

Windows, Linux (with NVIDIA drivers).

### NVIDIA H.265 Decoder Block (NVH265DecoderBlock)

Provides hardware-accelerated decoding of H.265 (HEVC) video streams using NVIDIA's NVDEC technology. H.265 offers better compression efficiency than H.264.

#### Block info

Name: `NVH265DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | H.265/HEVC encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- H.265 Video Stream --> NVH265DecoderBlock;
    NVH265DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create NVIDIA H.265 Decoder block
var nvH265Decoder = new NVH265DecoderBlock();

// Example: Create a basic file source, demuxer, and renderer
var basicFileSource = new BasicFileSourceBlock("test_h265.mp4");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h265.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connect blocks
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvH265Decoder.Input);
pipeline.Connect(nvH265Decoder.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Availability

Check availability using `NVH265DecoderBlock.IsAvailable()`. Requires an NVIDIA GPU that supports NVDEC for H.265 and appropriate drivers.

#### Platforms

Windows, Linux (with NVIDIA drivers).

### NVIDIA JPEG Decoder Block (NVJPEGDecoderBlock)

Provides hardware-accelerated decoding of JPEG images or Motion JPEG (MJPEG) streams using NVIDIA's NVJPEG library. This is particularly useful for high-resolution or high-framerate MJPEG streams. (Note: The sample pipeline for JPEG with BasicFileSourceBlock might be less common than HTTPSource for MJPEG. The example below is adapted but consider typical use cases.)

#### Block info

Name: `NVJPEGDecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | JPEG encoded video/images | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw MJPEG Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- JPEG Video Stream --> NVJPEGDecoderBlock;
    NVJPEGDecoderBlock -- Decoded Video --> VideoRendererBlock;
```

For live MJPEG streams, `HTTPSourceBlock --> NVJPEGDecoderBlock` is more typical.

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create NVIDIA JPEG Decoder block
var nvJpegDecoder = new NVJPEGDecoderBlock();

// Example: Create a basic file source for an MJPEG file, demuxer, and renderer
// Ensure "test.mjpg" contains a Motion JPEG stream.
var basicFileSource = new BasicFileSourceBlock("test.mjpg");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test.mjpg");
var mediaInfo = reader.Info;
if (mediaInfo == null || mediaInfo.VideoStreams.Count == 0 || !mediaInfo.VideoStreams[0].Codec.Contains("jpeg"))
{
    Console.WriteLine("Failed to get MJPEG media info or not an MJPEG file.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connect blocks
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvJpegDecoder.Input);
pipeline.Connect(nvJpegDecoder.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Availability

Check availability using `NVJPEGDecoderBlock.IsAvailable()`. Requires an NVIDIA GPU and appropriate drivers.

#### Platforms

Windows, Linux (with NVIDIA drivers).

### NVIDIA MPEG-1 Decoder Block (NVMPEG1DecoderBlock)

Provides hardware-accelerated decoding of MPEG-1 video streams using NVIDIA's NVDEC technology.

#### Block info

Name: `NVMPEG1DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | MPEG-1 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- MPEG-1 Video Stream --> NVMPEG1DecoderBlock;
    NVMPEG1DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create NVIDIA MPEG-1 Decoder block
var nvMpeg1Decoder = new NVMPEG1DecoderBlock();

// Example: Create a basic file source, demuxer, and renderer
var basicFileSource = new BasicFileSourceBlock("test_mpeg1.mpg");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_mpeg1.mpg");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connect blocks
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvMpeg1Decoder.Input);
pipeline.Connect(nvMpeg1Decoder.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Availability

Check availability using `NVMPEG1DecoderBlock.IsAvailable()`. Requires an NVIDIA GPU that supports NVDEC for MPEG-1 and appropriate drivers.

#### Platforms

Windows, Linux (with NVIDIA drivers).

### NVIDIA MPEG-2 Decoder Block (NVMPEG2DecoderBlock)

Provides hardware-accelerated decoding of MPEG-2 video streams using NVIDIA's NVDEC technology. Commonly used for DVD video and some digital television broadcasts.

#### Block info

Name: `NVMPEG2DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | MPEG-2 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- MPEG-2 Video Stream --> NVMPEG2DecoderBlock;
    NVMPEG2DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create NVIDIA MPEG-2 Decoder block
var nvMpeg2Decoder = new NVMPEG2DecoderBlock();

// Example: Create a basic file source, demuxer, and renderer
var basicFileSource = new BasicFileSourceBlock("test_mpeg2.mpg");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_mpeg2.mpg");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connect blocks
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvMpeg2Decoder.Input);
pipeline.Connect(nvMpeg2Decoder.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Availability

Check availability using `NVMPEG2DecoderBlock.IsAvailable()`. Requires an NVIDIA GPU that supports NVDEC for MPEG-2 and appropriate drivers.

#### Platforms

Windows, Linux (with NVIDIA drivers).

### NVIDIA MPEG-4 Decoder Block (NVMPEG4DecoderBlock)

Provides hardware-accelerated decoding of MPEG-4 Part 2 video streams (often found in AVI files, e.g., DivX/Xvid) using NVIDIA's NVDEC technology. Note that this is different from MPEG-4 Part 10 (H.264/AVC).

#### Block info

Name: `NVMPEG4DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | MPEG-4 Part 2 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- MPEG-4 Video Stream --> NVMPEG4DecoderBlock;
    NVMPEG4DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create NVIDIA MPEG-4 Decoder block
var nvMpeg4Decoder = new NVMPEG4DecoderBlock();

// Example: Create a basic file source, demuxer, and renderer
var basicFileSource = new BasicFileSourceBlock("test_mpeg4.avi");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_mpeg4.avi");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connect blocks
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvMpeg4Decoder.Input);
pipeline.Connect(nvMpeg4Decoder.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Availability

Check availability using `NVMPEG4DecoderBlock.IsAvailable()`. Requires an NVIDIA GPU that supports NVDEC for MPEG-4 Part 2 and appropriate drivers.

#### Platforms

Windows, Linux (with NVIDIA drivers).

### NVIDIA VP8 Decoder Block (NVVP8DecoderBlock)

Provides hardware-accelerated decoding of VP8 video streams using NVIDIA's NVDEC technology. VP8 is an open video format, often used with WebM.

#### Block info

Name: `NVVP8DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | VP8 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- VP8 Video Stream --> NVVP8DecoderBlock;
    NVVP8DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create NVIDIA VP8 Decoder block
var nvVp8Decoder = new NVVP8DecoderBlock();

// Example: Create a basic file source, demuxer, and renderer
var basicFileSource = new BasicFileSourceBlock("test_vp8.webm");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp8.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connect blocks
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvVp8Decoder.Input);
pipeline.Connect(nvVp8Decoder.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Availability

Check availability using `NVVP8DecoderBlock.IsAvailable()`. Requires an NVIDIA GPU that supports NVDEC for VP8 and appropriate drivers.

#### Platforms

Windows, Linux (with NVIDIA drivers).

### NVIDIA VP9 Decoder Block (NVVP9DecoderBlock)

Provides hardware-accelerated decoding of VP9 video streams using NVIDIA's NVDEC technology. VP9 is an open and royalty-free video coding format developed by Google, often used for web streaming (e.g., YouTube).

#### Block info

Name: `NVVP9DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | VP9 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- VP9 Video Stream --> NVVP9DecoderBlock;
    NVVP9DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create NVIDIA VP9 Decoder block
var nvVp9Decoder = new NVVP9DecoderBlock();

// Example: Create a basic file source, demuxer, and renderer
var basicFileSource = new BasicFileSourceBlock("test_vp9.webm");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp9.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connect blocks
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvVp9Decoder.Input);
pipeline.Connect(nvVp9Decoder.Output, videoRenderer.Input);

// Start pipeline
await pipeline.StartAsync();
```

#### Availability

Check availability using `NVVP9DecoderBlock.IsAvailable()`. Requires an NVIDIA GPU that supports NVDEC for VP9 and appropriate drivers.

#### Platforms

Windows, Linux (with NVIDIA drivers).

### VAAPI H.264 Decoder Block (VAAPIH264DecoderBlock)

Provides hardware-accelerated decoding of H.264 (AVC) video streams using VA-API (Video Acceleration API). Available on Linux systems with compatible hardware and drivers.

#### Block info

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | H.264 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- H.264 Video Stream --> VAAPIH264DecoderBlock;
    VAAPIH264DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();
var vaapiH264Decoder = new VAAPIH264DecoderBlock();
var basicFileSource = new BasicFileSourceBlock("test_h264.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h264.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vaapiH264Decoder.Input);
pipeline.Connect(vaapiH264Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check with `VAAPIH264DecoderBlock.IsAvailable()`. Requires VA-API support and correct SDK redist.

#### Platforms

Linux (with VA-API drivers).

---

### VAAPI HEVC Decoder Block (VAAPIHEVCDecoderBlock)

Provides hardware-accelerated decoding of H.265/HEVC video streams using VA-API. Available on Linux systems with compatible hardware and drivers.

#### Block info

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | H.265/HEVC encoded | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- H.265 Video Stream --> VAAPIHEVCDecoderBlock;
    VAAPIHEVCDecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();
var vaapiHevcDecoder = new VAAPIHEVCDecoderBlock();
var basicFileSource = new BasicFileSourceBlock("test_hevc.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_hevc.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vaapiHevcDecoder.Input);
pipeline.Connect(vaapiHevcDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check with `VAAPIHEVCDecoderBlock.IsAvailable()`. Requires VA-API support and correct SDK redist.

#### Platforms

Linux (with VA-API drivers).

---

### VAAPI JPEG Decoder Block (VAAPIJPEGDecoderBlock)

Provides hardware-accelerated decoding of JPEG/MJPEG video streams using VA-API. Available on Linux systems with compatible hardware and drivers.

#### Block info

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | JPEG encoded video/images | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    HTTPSourceBlock -- MJPEG Stream --> VAAPIJPEGDecoderBlock;
    VAAPIJPEGDecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();
var vaapiJpegDecoder = new VAAPIJPEGDecoderBlock();
var httpSettings = new HTTPSourceSettings(new Uri("http://your-mjpeg-camera/stream"));
var httpSource = new HTTPSourceBlock(httpSettings);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(httpSource.Output, vaapiJpegDecoder.Input);
pipeline.Connect(vaapiJpegDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check with `VAAPIJPEGDecoderBlock.IsAvailable()`. Requires VA-API support and correct SDK redist.

#### Platforms

Linux (with VA-API drivers).

---

### VAAPI VC1 Decoder Block (VAAPIVC1DecoderBlock)

Provides hardware-accelerated decoding of VC-1 video streams using VA-API. Available on Linux systems with compatible hardware and drivers.

#### Block info

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | VC-1 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- VC-1 Video Stream --> VAAPIVC1DecoderBlock;
    VAAPIVC1DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();
var vaapiVc1Decoder = new VAAPIVC1DecoderBlock();
var basicFileSource = new BasicFileSourceBlock("test_vc1.wmv");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vc1.wmv");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vaapiVc1Decoder.Input);
pipeline.Connect(vaapiVc1Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check with `VAAPIVC1DecoderBlock.IsAvailable()`. Requires VA-API support and correct SDK redist.

#### Platforms

Linux (with VA-API drivers).

---

## Direct3D 11/DXVA Video Decoder Blocks

Direct3D 11/DXVA (D3D11) decoder blocks provide hardware-accelerated video decoding on Windows systems with compatible GPUs and drivers. These blocks are useful for high-performance video playback and processing pipelines on Windows.

### D3D11 AV1 Decoder Block

Decodes AV1 video streams using Direct3D 11/DXVA hardware acceleration.

#### Block info

Name: `D3D11AV1DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | AV1 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- AV1 Video Stream --> D3D11AV1DecoderBlock;
    D3D11AV1DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create D3D11 AV1 Decoder block
var d3d11Av1Decoder = new D3D11AV1DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_av1.mkv");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_av1.mkv");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11Av1Decoder.Input);
pipeline.Connect(d3d11Av1Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability using `D3D11AV1DecoderBlock.IsAvailable()`. Requires Windows with D3D11/DXVA support and correct SDK redist.

#### Platforms

Windows (D3D11/DXVA required).

---

### D3D11 H.264 Decoder Block

Decodes H.264 (AVC) video streams using Direct3D 11/DXVA hardware acceleration.

#### Block info

Name: `D3D11H264DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | H.264 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- H.264 Video Stream --> D3D11H264DecoderBlock;
    D3D11H264DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create D3D11 H.264 Decoder block
var d3d11H264Decoder = new D3D11H264DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_h264.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h264.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11H264Decoder.Input);
pipeline.Connect(d3d11H264Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability using `D3D11H264DecoderBlock.IsAvailable()`. Requires Windows with D3D11/DXVA support and correct SDK redist.

#### Platforms

Windows (D3D11/DXVA required).

---

### D3D11 H.265 Decoder Block

Decodes H.265 (HEVC) video streams using Direct3D 11/DXVA hardware acceleration.

#### Block info

Name: `D3D11H265DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | H.265/HEVC encoded | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- H.265 Video Stream --> D3D11H265DecoderBlock;
    D3D11H265DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create D3D11 H.265 Decoder block
var d3d11H265Decoder = new D3D11H265DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_h265.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h265.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11H265Decoder.Input);
pipeline.Connect(d3d11H265Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability using `D3D11H265DecoderBlock.IsAvailable()`. Requires Windows with D3D11/DXVA support and correct SDK redist.

#### Platforms

Windows (D3D11/DXVA required).

---

### D3D11 MPEG-2 Decoder Block

Decodes MPEG-2 video streams using Direct3D 11/DXVA hardware acceleration.

#### Block info

Name: `D3D11MPEG2DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | MPEG-2 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- MPEG-2 Video Stream --> D3D11MPEG2DecoderBlock;
    D3D11MPEG2DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create D3D11 MPEG-2 Decoder block
var d3d11Mpeg2Decoder = new D3D11MPEG2DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_mpeg2.mpg");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_mpeg2.mpg");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11Mpeg2Decoder.Input);
pipeline.Connect(d3d11Mpeg2Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability using `D3D11MPEG2DecoderBlock.IsAvailable()`. Requires Windows with D3D11/DXVA support and correct SDK redist.

#### Platforms

Windows (D3D11/DXVA required).

---

### D3D11 VP8 Decoder Block

Decodes VP8 video streams using Direct3D 11/DXVA hardware acceleration.

#### Block info

Name: `D3D11VP8DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | VP8 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- VP8 Video Stream --> D3D11VP8DecoderBlock;
    D3D11VP8DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create D3D11 VP8 Decoder block
var d3d11Vp8Decoder = new D3D11VP8DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp8.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp8.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11Vp8Decoder.Input);
pipeline.Connect(d3d11Vp8Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability using `D3D11VP8DecoderBlock.IsAvailable()`. Requires Windows with D3D11/DXVA support and correct SDK redist.

#### Platforms

Windows (D3D11/DXVA required).

---

### D3D11 VP9 Decoder Block

Decodes VP9 video streams using Direct3D 11/DXVA hardware acceleration.

#### Block info

Name: `D3D11VP9DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | VP9 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- VP9 Video Stream --> D3D11VP9DecoderBlock;
    D3D11VP9DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create D3D11 VP9 Decoder block
var d3d11Vp9Decoder = new D3D11VP9DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp9.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp9.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11Vp9Decoder.Input);
pipeline.Connect(d3d11Vp9Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability using `D3D11VP9DecoderBlock.IsAvailable()`. Requires Windows with D3D11/DXVA support and correct SDK redist.

#### Platforms

Windows (D3D11/DXVA required).

---

### HEVC Decoder Block

Decodes H.265/HEVC video streams using the best available decoder on the system. Supports software decoding via FFmpeg and hardware-accelerated decoding through NVIDIA NVDEC, Intel Quick Sync, AMD AMF, D3D11/DXVA (Windows), and VAAPI (Linux). When instantiated without arguments, the block automatically selects the fastest available decoder in order: NVIDIA NVDEC → Intel QSV → AMD AMF → D3D11 (Windows) → VAAPI (Linux) → FFmpeg.

#### Block info

Name: `HEVCDecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | HEVC encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### Settings

`HEVCDecoderBlock` can auto-select the best backend or use an explicit one. All configuration classes implement the `IHEVCDecoderSettings` interface.

```
// Auto-selection (recommended)
var hevcDecoder = new HEVCDecoderBlock();

// Explicit backend selection:
// FFmpeg (CPU, software)
var hevcDecoder = new HEVCDecoderBlock(new FFMPEGHEVCDecoderSettings());

// NVIDIA NVDEC (GPU)
var hevcDecoder = new HEVCDecoderBlock(new NVHEVCDecoderSettings());

// Intel Quick Sync
var hevcDecoder = new HEVCDecoderBlock(new QSVHEVCDecoderSettings());

// AMD AMF
var hevcDecoder = new HEVCDecoderBlock(new AMFHEVCDecoderSettings());

// D3D11/DXVA (Windows only)
var hevcDecoder = new HEVCDecoderBlock(new D3D11HEVCDecoderSettings());

// VAAPI (Linux only)
var hevcDecoder = new HEVCDecoderBlock(new VAAPIHEVCDecoderSettings());

// AMD AMA / Alveo hardware acceleration (Linux only) — see the AMD AMA Blocks page
var hevcDecoder = new HEVCDecoderBlock(new AMAHEVCDecoderSettings());
```

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- HEVC Video Stream --> HEVCDecoderBlock;
    HEVCDecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Auto-select best available HEVC decoder
var hevcDecoder = new HEVCDecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_hevc.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_hevc.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), hevcDecoder.Input);
pipeline.Connect(hevcDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability for a specific decoder type using `HEVCDecoderBlock.IsAvailable(HEVCDecoderType decoder)`. Ensure the appropriate SDK redistribution package is included in your project.

#### Platforms

Windows, macOS, Linux.

---

### AV1 Decoder Block

Decodes AV1 video streams using software or hardware decoding. Supports dav1d (fast software decoder), the AOM reference decoder (av1dec), and hardware-accelerated decoders via NVIDIA NVDEC, D3D11/DXVA (Windows), and VAAPI (Linux). AV1 offers superior compression efficiency compared to H.264 and VP9, with support for up to 8K resolution, 10-bit color, and HDR content.

#### Block info

Name: `AV1DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | AV1 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### Settings

The `AV1DecoderBlock` is configured using `AV1DecoderSettings`, which specifies the decoder type via the `AV1DecoderType` enum:

- `AV1DecoderType.Auto` — automatically selects the best available decoder (default)
- `AV1DecoderType.Dav1d` — dav1d software decoder (fast, recommended for CPU decoding)
- `AV1DecoderType.AOM` — AOM (Alliance for Open Media) reference decoder (software)
- `AV1DecoderType.NVIDIA` — NVIDIA NVDEC hardware decoding (RTX 30 series or newer)
- `AV1DecoderType.Intel_QSV` — Intel Quick Sync Video hardware decoding (Arc series or newer)
- `AV1DecoderType.D3D11` — D3D11/DXVA hardware decoding (Windows)
- `AV1DecoderType.VAAPI` — VAAPI hardware decoding (Linux)
- `AV1DecoderType.AMA_AV1` — AMD AMA (Alveo) hardware decoding (Linux); configure with `AMAAV1DecoderSettings`. See [AMD AMA Blocks](../AMA/)

A constructor without parameters automatically selects the best available decoder.

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- AV1 Video Stream --> AV1DecoderBlock;
    AV1DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Auto-select best available AV1 decoder
var av1Decoder = new AV1DecoderBlock();

// Or specify a decoder explicitly:
// var av1Decoder = new AV1DecoderBlock(new AV1DecoderSettings { DecoderType = AV1DecoderType.Dav1d });

var basicFileSource = new BasicFileSourceBlock("test_av1.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_av1.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), av1Decoder.Input);
pipeline.Connect(av1Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability for a specific decoder type using `AV1DecoderBlock.IsAvailable(AV1DecoderType decoderType)`. Pass `AV1DecoderType.Auto` to check whether any AV1 decoder is available. Ensure the appropriate SDK redistribution package is included in your project.

#### Platforms

Windows, macOS, Linux.

---

### NVAV1 Decoder Block

Decodes AV1 video streams using NVIDIA NVDEC hardware acceleration exclusively. Requires an NVIDIA GPU with AV1 NVDEC support (RTX 30xx series or newer). Capable of decoding 4K@120fps or 8K@60fps depending on GPU model, with support for HDR10 and HDR10+ content.

#### Block info

Name: `NVAV1DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | AV1 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- AV1 Video Stream --> NVAV1DecoderBlock;
    NVAV1DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create NVAV1 Decoder block (requires NVIDIA GPU with AV1 NVDEC support)
var nvav1Decoder = new NVAV1DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_av1.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_av1.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvav1Decoder.Input);
pipeline.Connect(nvav1Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability using `NVAV1DecoderBlock.IsAvailable()`. Requires an NVIDIA GPU with AV1 NVDEC support and the NVIDIA Video Codec SDK redistribution package.

#### Platforms

Windows, Linux (NVIDIA GPU with AV1 NVDEC support required).

---

### VP8 Decoder Block

Decodes VP8 video streams commonly used in WebM containers and WebRTC video communications. Supports software decoding via VPX and FFmpeg, and hardware-accelerated decoding through NVIDIA NVDEC, VAAPI (Linux), and D3D11/DXVA (Windows). When instantiated without arguments, the block automatically selects from available decoders in order: VPX → FFmpeg → NVIDIA NVDEC → VAAPI (Linux) → D3D11 (Windows).

#### Block info

Name: `VP8DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | VP8 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### Settings

`VP8DecoderBlock` can auto-select the best backend or use an explicit one. All configuration classes implement the `IVP8DecoderSettings` interface.

```
// Auto-selection (recommended)
var vp8Decoder = new VP8DecoderBlock();

// Explicit backend selection:
// VPX (software, broad compatibility)
var vp8Decoder = new VP8DecoderBlock(new VPXVP8DecoderSettings());

// FFmpeg (software)
var vp8Decoder = new VP8DecoderBlock(new FFMPEGVP8DecoderSettings());

// NVIDIA NVDEC (hardware)
var vp8Decoder = new VP8DecoderBlock(new NVVP8DecoderSettings());

// VAAPI (Linux only, hardware)
var vp8Decoder = new VP8DecoderBlock(new VAAPIVP8DecoderSettings());

// D3D11/DXVA (Windows only, hardware)
var vp8Decoder = new VP8DecoderBlock(new D3D11VP8DecoderSettings());
```

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- VP8 Video Stream --> VP8DecoderBlock;
    VP8DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Auto-select best available VP8 decoder
var vp8Decoder = new VP8DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp8.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp8.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vp8Decoder.Input);
pipeline.Connect(vp8Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability for a specific decoder type using `VP8DecoderBlock.IsAvailable(VP8DecoderType decoder)`. Ensure the appropriate SDK redistribution package is included in your project.

#### Platforms

Windows, macOS, Linux.

---

### VP9 Decoder Block

Decodes VP9 video streams used in YouTube 4K/8K content and WebM containers. Supports software decoding via VPX and FFmpeg, and hardware-accelerated decoding through NVIDIA NVDEC, VAAPI (Linux), and D3D11/DXVA (Windows). Supports 10-bit and 12-bit color depths. When instantiated without arguments, the block automatically selects from available decoders in order: VPX → FFmpeg → NVIDIA NVDEC → VAAPI (Linux) → D3D11 (Windows).

#### Block info

Name: `VP9DecoderBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | VP9 encoded video | 1 |
| Output video | Uncompressed video | 1 |

#### Settings

`VP9DecoderBlock` can auto-select the best backend or use an explicit one. All configuration classes implement the `IVP9DecoderSettings` interface.

```
// Auto-selection (recommended)
var vp9Decoder = new VP9DecoderBlock();

// Explicit backend selection:
// VPX (software, broad compatibility)
var vp9Decoder = new VP9DecoderBlock(new VPXVP9DecoderSettings());

// FFmpeg (software)
var vp9Decoder = new VP9DecoderBlock(new FFMPEGVP9DecoderSettings());

// NVIDIA NVDEC (hardware)
var vp9Decoder = new VP9DecoderBlock(new NVVP9DecoderSettings());

// VAAPI (Linux only, hardware)
var vp9Decoder = new VP9DecoderBlock(new VAAPIVP9DecoderSettings());

// D3D11/DXVA (Windows only, hardware)
var vp9Decoder = new VP9DecoderBlock(new D3D11VP9DecoderSettings());
```

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- VP9 Video Stream --> VP9DecoderBlock;
    VP9DecoderBlock -- Decoded Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Auto-select best available VP9 decoder
var vp9Decoder = new VP9DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp9.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp9.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vp9Decoder.Input);
pipeline.Connect(vp9Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability for a specific decoder type using `VP9DecoderBlock.IsAvailable(VP9DecoderType decoder)`. Ensure the appropriate SDK redistribution package is included in your project.

#### Platforms

Windows, macOS, Linux.

---

### VP8 Alpha Decode Bin Block

Decodes VP8 video streams that include an alpha transparency channel, producing RGBA or YUVA output suitable for compositing and overlay effects. Handles the demultiplexing and decoding of both color and alpha channels automatically. Intended for WebM or MKV files encoded with VP8 alpha support.

#### Block info

Name: `VP8AlphaDecodeBinBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | VP8 video with alpha channel | 1 |
| Output video | Uncompressed video (RGBA/YUVA) | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- VP8+Alpha Video Stream --> VP8AlphaDecodeBinBlock;
    VP8AlphaDecodeBinBlock -- RGBA Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var vp8AlphaDecoder = new VP8AlphaDecodeBinBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp8_alpha.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp8_alpha.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vp8AlphaDecoder.Input);
pipeline.Connect(vp8AlphaDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability using `VP8AlphaDecodeBinBlock.IsAvailable()`. Requires the GStreamer codecalpha plugin and the appropriate SDK redistribution package.

#### Platforms

Windows, macOS, Linux.

---

### VP9 Alpha Decode Bin Block

Decodes VP9 video streams that include an alpha transparency channel, producing RGBA or YUVA output. Supports up to 4K resolution. Handles the demultiplexing and decoding of both color and alpha channels automatically. Intended for WebM or MKV files encoded with VP9 alpha support.

#### Block info

Name: `VP9AlphaDecodeBinBlock`.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | VP9 video with alpha channel | 1 |
| Output video | Uncompressed video (RGBA/YUVA) | 1 |

#### The sample pipeline

```
graph LR;
    BasicFileSourceBlock -- Raw Data --> UniversalDemuxBlock;
    UniversalDemuxBlock -- VP9+Alpha Video Stream --> VP9AlphaDecodeBinBlock;
    VP9AlphaDecodeBinBlock -- RGBA Video --> VideoRendererBlock;
```

#### Sample code

```
var pipeline = new MediaBlocksPipeline();

var vp9AlphaDecoder = new VP9AlphaDecodeBinBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp9_alpha.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp9_alpha.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Failed to get media info.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vp9AlphaDecoder.Input);
pipeline.Connect(vp9AlphaDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

#### Availability

Check availability using `VP9AlphaDecodeBinBlock.IsAvailable()`. Requires the GStreamer codecalpha plugin and the appropriate SDK redistribution package.

#### Platforms

Windows, macOS, Linux.

---END OF PAGE---


## Video Encoder Blocks - H.264, HEVC, AV1, VP9 in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/VideoEncoders/
**Description:** Encode video to H.264, HEVC, AV1, and VP9 with GPU acceleration using VisioForge Media Blocks SDK. Configurable bitrate, quality, and codec settings.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming
**API:** UniversalSourceBlock, MediaBlocksPipeline, UniversalSourceSettings, MediaBlockPadMediaType, MP4SinkBlock, AMAH264EncoderSettings, AMAHEVCEncoderSettings, AMAAV1EncoderSettings

# Video encoding

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Video encoding is the process of converting raw video data into a compressed format. This process is essential for reducing the size of video files, making them easier to store and stream over the internet. VisioForge Media Blocks SDK provides a wide range of video encoders that support various formats and codecs.

For some video encoders, SDK can use GPU acceleration to speed up the encoding process. This feature is especially useful when working with high-resolution video files or when encoding multiple videos simultaneously.

NVidia, Intel, and AMD GPUs are supported for hardware acceleration.

## AV1 encoder

`AV1 (AOMedia Video 1)`: Developed by the Alliance for Open Media, AV1 is an open, royalty-free video coding format designed for video transmissions over the Internet. It is known for its high compression efficiency and better quality at lower bit rates compared to its predecessors, making it well-suited for high-resolution video streaming applications.

Use classes that implement the `IAV1EncoderSettings` interface to set the parameters.

#### CPU Encoders

##### AOMAV1EncoderSettings

AOM AV1 encoder settings. CPU encoder.

**Platforms:** Windows, Linux, macOS.

##### RAV1EEncoderSettings

RAV1E AV1 encoder settings. CPU encoder.

- **Key Properties**:
- `Bitrate` (integer): Target bitrate in kilobits per second.
- `LowLatency` (boolean): Enables or disables low latency mode. Default is `false`.
- `MaxKeyFrameInterval` (ulong): Maximum interval between keyframes. Default is `240`.
- `MinKeyFrameInterval` (ulong): Minimum interval between keyframes. Default is `12`.
- `MinQuantizer` (uint): Minimum quantizer value (range 0-255). Default is `0`.
- `Quantizer` (uint): Quantizer value (range 0-255). Default is `100`.
- `SpeedPreset` (int): Encoding speed preset (10 fastest, 0 slowest). Default is `10`.
- `Tiles` (uint): Tiles the frame is split into - this is what lets rav1e use more than one core. Default is `16`; `0` encodes the frame as a single tile.
- `Tune` (`RAV1EEncoderTune`): Tune setting for the encoder. Default is `RAV1EEncoderTune.Psychovisual`.

**Platforms:** Windows, Linux, macOS.

###### RAV1EEncoderTune Enum

Specifies the tuning option for the RAV1E encoder.

- `PSNR` (0): Tune for best PSNR (Peak Signal-to-Noise Ratio).
- `Psychovisual` (1): Tune for psychovisual quality.

#### GPU Encoders

##### AMFAV1EncoderSettings

AMD GPU AV1 video encoder.

**Platforms:** Windows, Linux, macOS.

##### AMAAV1EncoderSettings

AMD AMA (Alveo) hardware AV1 encoder for AMD Alveo media accelerators (e.g. MA35D). See [AMD AMA Blocks](../AMA/).

**Platforms:** Linux.

##### NVENCAV1EncoderSettings

Nvidia GPU AV1 video encoder.

**Platforms:** Windows, Linux, macOS.

##### QSVAV1EncoderSettings

Intel GPU AV1 video encoder.

**Platforms:** Windows, Linux, macOS.

*Note: Intel QSV encoders may also utilize common enumerations like `QSVCodingOption` (`On`, `Off`, `Unknown`) for configuring specific hardware features.*

### Block info

Name: AV1EncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | AV1 | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AV1EncoderBlock;
    AV1EncoderBlock-->MP4SinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoEncoderBlock = new AV1EncoderBlock(new QSVAV1EncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var mp4SinkBlock = new MP4SinkBlock(new MP4SinkSettings(@"output.mp4"));
pipeline.Connect(videoEncoderBlock.Output, mp4SinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## DV encoder

`DV (Digital Video)`: A format for storing digital video introduced in the 1990s, primarily used in consumer digital camcorders. DV employs intra-frame compression to deliver high-quality video on digital tapes, making it suitable for home videos as well as semi-professional productions.

### Block info

Name: DVEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | video/x-dv | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->DVEncoderBlock;
    DVEncoderBlock-->AVISinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoEncoderBlock = new DVEncoderBlock(new DVVideoEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var sinkBlock = new AVISinkBlock(new AVISinkSettings(@"output.avi"));
pipeline.Connect(videoEncoderBlock.Output, sinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Custom Video encoder

The CustomVideoEncoder block provides a flexible framework for integrating third-party or specialized video encoders that are not directly supported by the SDK. This enables integration of proprietary codecs, experimental encoders, or platform-specific encoding solutions.

### Block info

Name: CustomVideoEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Compressed video | 1 |

### Settings

#### CustomVideoEncoderSettings

```
public class CustomVideoEncoderSettings : IVideoEncoder
{
    // GStreamer encoder element name (e.g., "x264enc", "nvh264enc").
    // Set via the constructor; the setter is private.
    public string Name { get; private set; }

    // Dictionary of encoder-specific properties (private setter — populate via indexer / Add).
    public Dictionary<string, object> Properties { get; private set; }

    public CustomVideoEncoderSettings(string name);
}
```

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->CustomVideoEncoderBlock;
    CustomVideoEncoderBlock-->MP4SinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Configure custom encoder (example with x264enc — Name is set via the ctor; populate
// Properties dictionary via its indexer since the property has a private setter).
var customSettings = new CustomVideoEncoderSettings("x264enc");
customSettings.Properties["bitrate"] = 2000;
customSettings.Properties["speed-preset"] = "medium";
var customEncoder = new CustomVideoEncoderBlock(customSettings);
pipeline.Connect(fileSource.VideoOutput, customEncoder.Input);

var mp4Sink = new MP4SinkBlock(new MP4SinkSettings("output.mp4"));
pipeline.Connect(customEncoder.Output, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux (requires appropriate GStreamer plugins).

## GIF encoder

The GIF encoder block creates animated GIF images from video streams, suitable for web content, social media, and documentation.

### Block info

Name: GIFEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | GIF | 1 |

### Settings

#### GIFEncoderSettings

```
public class GIFEncoderSettings
{
    // Number of additional repetitions: -1 = loop forever, 0..n = finite repeats. Default 0.
    public uint Repeat { get; set; }

    // Encoding speed [1..30]. Higher = faster (lower quality). Default 10.
    public int Speed { get; set; }
}
```

> The output frame rate of a `GIFEncoderBlock` follows the upstream caps — set the desired frame rate on the source (or insert a rate filter / `VideoFrameRateBlock` upstream) rather than on `GIFEncoderSettings`.

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->GIFEncoderBlock;
    GIFEncoderBlock-->FileSink;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var gifSettings = new GIFEncoderSettings
{
    Repeat = 0,    // 0 = no extra loops; -1 = loop forever
    Speed  = 10    // [1..30] — higher = faster encoding (lower quality)
};
var gifEncoder = new GIFEncoderBlock(gifSettings, "output.gif");
pipeline.Connect(fileSource.VideoOutput, gifEncoder.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## H264 encoder

The H264 encoder block is used for encoding files in MP4, MKV, and some other formats, as well as for network streaming using RTSP and HLS.

Use classes that implement the IH264EncoderSettings interface to set the parameters.

### Settings

#### NVENCH264EncoderSettings

Nvidia GPUs H264 video encoder.

**Platforms:** Windows, Linux, macOS.

#### AMFH264EncoderSettings

AMD/ATI GPUs H264 video encoder.

**Platforms:** Windows, Linux, macOS.

#### AMAH264EncoderSettings

AMD AMA (Alveo) hardware H264 encoder for AMD Alveo media accelerators (e.g. MA35D). See [AMD AMA Blocks](../AMA/).

**Platforms:** Linux.

#### QSVH264EncoderSettings

Intel GPU H264 video encoder.

**Platforms:** Windows, Linux, macOS.

#### OpenH264EncoderSettings

Software CPU H264 encoder.

**Platforms:** Windows, macOS, Linux, iOS, Android.

#### CustomH264EncoderSettings

Allows using a custom GStreamer element for H264 encoding. You can specify the GStreamer element name and configure its properties.

**Platforms:** Windows, Linux, macOS.

### Block info

Name: H264EncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | H264 | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->H264EncoderBlock;
    H264EncoderBlock-->MP4SinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var h264EncoderBlock = new H264EncoderBlock(new NVENCH264EncoderSettings());
pipeline.Connect(fileSource.VideoOutput, h264EncoderBlock.Input);

var mp4SinkBlock = new MP4SinkBlock(new MP4SinkSettings(@"output.mp4"));
pipeline.Connect(h264EncoderBlock.Output, mp4SinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

#### Sample applications

- [Simple Capture Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Simple%20Capture%20Demo)
- [Screen Capture Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Screen%20Capture)

### Platforms

Windows, macOS, Linux, iOS, Android.

## HEVC/H265 encoder

HEVC encoder is used for encoding files in MP4, MKV, and some other formats, as well as for network streaming using RTSP and HLS.

Use classes that implement the IHEVCEncoderSettings interface to set the parameters.

### Settings

#### MFHEVCEncoderSettings

Microsoft Media Foundation HEVC encoder. CPU encoder.

**Platforms:** Windows.

#### NVENCHEVCEncoderSettings

Nvidia GPUs HEVC video encoder.

**Platforms:** Windows, Linux, macOS.

#### AMFHEVCEncoderSettings

AMD/ATI GPUs HEVC video encoder.

**Platforms:** Windows, Linux, macOS.

#### AMAHEVCEncoderSettings

AMD AMA (Alveo) hardware HEVC encoder for AMD Alveo media accelerators (e.g. MA35D). See [AMD AMA Blocks](../AMA/).

**Platforms:** Linux.

#### QSVHEVCEncoderSettings

Intel GPU HEVC video encoder.

**Platforms:** Windows, Linux, macOS.

#### CustomHEVCEncoderSettings

Allows using a custom GStreamer element for HEVC encoding. You can specify the GStreamer element name and configure its properties.

**Platforms:** Windows, Linux, macOS.

### Block info

Name: HEVCEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | HEVC | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->HEVCEncoderBlock;
    HEVCEncoderBlock-->MP4SinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var hevcEncoderBlock = new HEVCEncoderBlock(new NVENCHEVCEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, hevcEncoderBlock.Input);

var mp4SinkBlock = new MP4SinkBlock(new MP4SinkSettings(@"output.mp4"));
pipeline.Connect(hevcEncoderBlock.Output, mp4SinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## MJPEG encoder

`MJPEG (Motion JPEG)`: A video compression format where each frame of video is separately compressed into a JPEG image. This technique is straightforward and results in no interframe compression, making it ideal for situations where frame-specific editing or access is required, such as in surveillance and medical imaging. Use classes that implement the IH264EncoderSettings interface to set the parameters.

### Settings

#### MJPEGEncoderSettings

Default MJPEG encoder. CPU encoder.

- **Key Properties**:
- `Quality` (int): JPEG quality level (10-100). Default is `85`.
- **Encoder Type**: `MJPEGEncoderType.CPU`.

**Platforms:** Windows, Linux, macOS, iOS, Android.

#### QSVMJPEGEncoderSettings

Intel GPUs MJPEG encoder.

- **Key Properties**:
- `Quality` (uint): JPEG quality level (10-100). Default is `85`.
- **Encoder Type**: `MJPEGEncoderType.GPU_Intel_QSV_MJPEG`.

**Platforms:** Windows, Linux, macOS.

#### MJPEGEncoderType Enum

Specifies the type of MJPEG encoder.

- `CPU`: Default CPU-based encoder.
- `GPU_Intel_QSV_MJPEG`: Intel QuickSync GPU-based MJPEG encoder.

### Block info

Name: MJPEGEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | MJPEG | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MJPEGEncoderBlock;
    MJPEGEncoderBlock-->AVISinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoEncoderBlock = new MJPEGEncoderBlock(new MJPEGEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, videoEncoderBlock.Input);

var aviSinkBlock = new AVISinkBlock(new AVISinkSettings(@"output.avi"));
pipeline.Connect(videoEncoderBlock.Output, aviSinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Theora encoder

The [Theora](https://www.theora.org/) encoder is used to encode video files in WebM format.

### Settings

#### TheoraEncoderSettings

Provides settings for the Theora encoder.

- **Key Properties**:
- `Bitrate` (kbps)
- `CapOverflow`, `CapUnderflow` (bit reservoir capping)
- `DropFrames` (allow/disallow frame dropping)
- `KeyFrameAuto` (automatic keyframe detection)
- `KeyFrameForce` (interval to force keyframe every N frames)
- `KeyFrameFrequency` (keyframe frequency)
- `MultipassCacheFile` (string path for multipass cache)
- `MultipassMode` (using `TheoraMultipassMode` enum: `SinglePass`, `FirstPass`, `SecondPass`)
- `Quality` (integer value, typically 0-63 for libtheora, meaning can vary)
- `RateBuffer` (size of rate control buffer in units of frames, 0 = auto)
- `SpeedLevel` (amount of motion vector searching, 0-2 or higher depending on implementation)
- `VP3Compatible` (boolean to enable VP3 compatibility)
- **Availability**: Can be checked using `TheoraEncoderSettings.IsAvailable()`.

### Block info

Name: TheoraEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | video/x-theora | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->TheoraEncoderBlock;
    TheoraEncoderBlock-->WebMSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var theoraEncoderBlock = new TheoraEncoderBlock(new TheoraEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, theoraEncoderBlock.Input);

var webmSinkBlock = new WebMSinkBlock(new WebMSinkSettings(@"output.webm"));
pipeline.Connect(theoraEncoderBlock.Output, webmSinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## VPX encoder

VPX encoder block is used to encode files in WebM, MKV, or OGG files. VPX encoder is a set of video codecs for encoding in VP8 and VP9 formats.

The VPX encoder block utilizes settings classes that implement the `IVPXEncoderSettings` interface. Key settings classes include:

### Settings

The common base class for VP8 and VP9 CPU encoder settings is `VPXEncoderSettings`. It provides a wide range of shared properties for tuning the encoding process, such as:

- `ARNRMaxFrames`, `ARNRStrength`, `ARNRType` (AltRef noise reduction)
- `BufferInitialSize`, `BufferOptimalSize`, `BufferSize` (client buffer settings)
- `CPUUsed`, `CQLevel` (constrained quality)
- `Deadline` (encoding deadline per frame)
- `DropframeThreshold`
- `RateControl` (using `VPXRateControl` enum)
- `ErrorResilient` (using `VPXErrorResilientFlags` enum)
- `HorizontalScalingMode`, `VerticalScalingMode` (using `VPXScalingMode` enum)
- `KeyFrameMaxDistance`, `KeyFrameMode` (using `VPXKeyFrameMode` enum)
- `MinQuantizer`, `MaxQuantizer`
- `MultipassCacheFile`, `MultipassMode` (using `VPXMultipassMode` enum)
- `NoiseSensitivity`
- `TargetBitrate` (in Kbits/s)
- `NumOfThreads`
- `TokenPartitions` (using `VPXTokenPartitions` enum)
- `Tuning` (using `VPXTuning` enum)

#### VP8EncoderSettings

CPU encoder for VP8. Inherits from `VPXEncoderSettings`.

- **Key Properties**: Leverages properties from `VPXEncoderSettings` tailored for VP8.
- **Encoder Type**: `VPXEncoderType.VP8`.
- **Availability**: Can be checked using `VP8EncoderSettings.IsAvailable()`.

#### VP9EncoderSettings

CPU encoder for VP9. Inherits from `VPXEncoderSettings`.

- **Key Properties**: In addition to `VPXEncoderSettings` properties, includes VP9-specific settings:
- `AQMode` (Adaptive Quantization mode, using `VPXAdaptiveQuantizationMode` enum)
- `FrameParallelDecoding` (allow parallel processing)
- `RowMultithread` (multi-threaded row encoding)
- `TileColumns`, `TileRows` (log2 values)
- **Encoder Type**: `VPXEncoderType.VP9`.
- **Availability**: Can be checked using `VP9EncoderSettings.IsAvailable()`.

#### QSVVP9EncoderSettings

Intel QSV (GPU accelerated) encoder for VP9.

- **Key Properties**:
- `LowLatency`
- `TargetUsage` (1: Best quality, 4: Balanced, 7: Best speed)
- `Bitrate` (Kbit/sec)
- `GOPSize`
- `ICQQuality` (Intelligent Constant Quality)
- `MaxBitrate` (Kbit/sec)
- `QPI`, `QPP` (constant quantizer for I and P frames)
- `Profile` (0-3)
- `RateControl` (using `QSVVP9EncRateControl` enum)
- `RefFrames`
- **Encoder Type**: `VPXEncoderType.QSV_VP9`.
- **Availability**: Can be checked using `QSVVP9EncoderSettings.IsAvailable()`.

#### CustomVPXEncoderSettings

Allows using a custom GStreamer element for VPX encoding.

- **Key Properties**:
- `ElementName` (string to specify the GStreamer element name)
- `Properties` (Dictionary to configure the element)
- `VideoFormat` (required video format like `VideoFormatX.NV12`)
- **Encoder Type**: `VPXEncoderType.CustomEncoder`.

### VPX Enumerations

Several enumerations are available to configure VPX encoders:

- `VPXAdaptiveQuantizationMode`: Defines adaptive quantization modes (e.g., `Off`, `Variance`, `Complexity`, `CyclicRefresh`, `Equator360`, `Perceptual`, `PSNR`, `Lookahead`).
- `VPXErrorResilientFlags`: Flags for error resilience features (e.g., `None`, `Default`, `Partitions`).
- `VPXKeyFrameMode`: Defines keyframe placement strategies (e.g., `Auto`, `Disabled`).
- `VPXMultipassMode`: Modes for multipass encoding (e.g., `OnePass`, `FirstPass`, `LastPass`).
- `VPXRateControl`: Rate control modes (e.g., `VBR`, `CBR`, `CQ`).
- `VPXScalingMode`: Scaling modes (e.g., `Normal`, `_4_5`, `_3_5`, `_1_2`).
- `VPXTokenPartitions`: Number of token partitions (e.g., `One`, `Two`, `Four`, `Eight`).
- `VPXTuning`: Tuning options for the encoder (e.g., `PSNR`, `SSIM`).
- `VPXEncoderType`: Specifies the VPX encoder variant (e.g., `VP8`, `VP9`, `QSV_VP9`, `CustomEncoder`, and platform-specific ones like `OMXExynosVP8Encoder`).
- `QSVVP9EncRateControl`: Rate control modes specific to `QSVVP9EncoderSettings` (e.g., `CBR`, `VBR`, `CQP`, `ICQ`).

### Block info

Name: VPXEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | VP8/VP9 | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VPXEncoderBlock;
    VPXEncoderBlock-->WebMSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var vp8EncoderBlock = new VPXEncoderBlock(new VP8EncoderSettings());
pipeline.Connect(fileSource.VideoOutput, vp8EncoderBlock.Input);

var webmSinkBlock = new WebMSinkBlock(new WebMSinkSettings(@"output.webm"));
pipeline.Connect(vp8EncoderBlock.Output, webmSinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## MPEG2 encoder

`MPEG-2`: A widely used standard for video and audio compression, commonly found in DVDs, digital television broadcasts (like DVB and ATSC), and SVCDs. It offers good quality at relatively low bitrates for standard definition content.

### Block info

Name: MPEG2EncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | video/mpeg | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MPEG2EncoderBlock;
    MPEG2EncoderBlock-->MPEGTSSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var mpeg2EncoderBlock = new MPEG2EncoderBlock(new MPEG2VideoEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, mpeg2EncoderBlock.Input);

// Example: Using an MPEGTSSinkBlock for .ts files
var mpegtsSinkBlock = new MPEGTSSinkBlock(new MPEGTSSinkSettings(@"output.ts"));
pipeline.Connect(mpeg2EncoderBlock.Output, mpegtsSinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## MPEG4 encoder

`MPEG-4 Part 2 Visual` (often referred to simply as MPEG-4 video) is a video compression standard that is part of the MPEG-4 suite. It is used in various applications, including streaming video, video conferencing, and optical discs like DivX and Xvid.

### Block info

Name: MPEG4EncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | video/mpeg, mpegversion=4 | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MPEG4EncoderBlock;
    MPEG4EncoderBlock-->MP4SinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4"; // Input file
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var mpeg4EncoderBlock = new MPEG4EncoderBlock(new MPEG4VideoEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, mpeg4EncoderBlock.Input);

// Example: Using an MP4SinkBlock for .mp4 files
var mp4SinkBlock = new MP4SinkBlock(new MP4SinkSettings(@"output_mpeg4.mp4"));
pipeline.Connect(mpeg4EncoderBlock.Output, mp4SinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## PNG encoder

The PNG encoder block provides lossless image compression with high quality, suitable for archival, screenshots, and applications requiring perfect image quality with transparency support.

### Block info

Name: PNGEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | PNG | 1 |

### Settings

#### PNGEncoderSettings

```
public class PNGEncoderSettings
{
    // Compression level enum (None / Minimal / Low / Light / Medium / MediumHigh /
    // High / VeryHigh / Maximum). Default MediumHigh.
    public PNGEncoderCompressionLevel CompressionLevel { get; set; }

    // Pre-compression filter (None / Sub / Up / Average / Paeth / All). Default None.
    public PNGEncoderFilterType Filter { get; set; }

    // Whether to write info chunks. Default true.
    public bool WriteInfo { get; set; }
}
```

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->PNGEncoderBlock;
    PNGEncoderBlock-->FileSink;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4"; // Input file
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var pngSettings = new PNGEncoderSettings
{
    CompressionLevel = PNGEncoderCompressionLevel.MediumHigh, // balanced
    Filter           = PNGEncoderFilterType.None
};
var pngEncoder = new PNGEncoderBlock(pngSettings, "frame.png");
pipeline.Connect(fileSource.VideoOutput, pngEncoder.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Apple ProRes encoder

`Apple ProRes`: A high-quality, lossy video compression format developed by Apple Inc., widely used in professional video production and post-production workflows for its excellent balance of image quality and performance.

### Block info

Name: AppleProResEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | ProRes | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AppleProResEncoderBlock;
    AppleProResEncoderBlock-->MOVSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var proResEncoderBlock = new AppleProResEncoderBlock(new AppleProResEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, proResEncoderBlock.Input);

var movSinkBlock = new MOVSinkBlock(new MOVSinkSettings(@"output.mov"));
pipeline.Connect(proResEncoderBlock.Output, movSinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

macOS, iOS.

### Availability

You can check if the Apple ProRes encoder is available in your environment using:

```
bool available = AppleProResEncoderBlock.IsAvailable();
```

## WMV encoder

### Overview

WMV encoder block encodes video in WMV format.

### Block info

Name: WMVEncoderBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | video/x-wmv | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->WMVEncoderBlock;
    WMVEncoderBlock-->ASFSinkBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline(false);

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var wmvEncoderBlock = new WMVEncoderBlock(new WMVEncoderSettings());
pipeline.Connect(fileSource.VideoOutput, wmvEncoderBlock.Input);

var asfSinkBlock = new ASFSinkBlock(new ASFSinkSettings(@"output.wmv"));
pipeline.Connect(wmvEncoderBlock.Output, asfSinkBlock.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

---END OF PAGE---


## 50+ Video Processing and Effects Blocks for C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/VideoProcessing/
**Description:** Apply color adjustments, deinterlacing, overlays, geometric transforms, and real-time visual effects using VisioForge Media Blocks SDK pipelines.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS
**API:** VideoRendererBlock, UniversalSourceBlock, UniversalSourceSettings, MediaBlocksPipeline, VideoMixerBlock

# Video processing blocks

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Table of Contents

- [Aging](#aging)
- [Alpha Combine](#alpha-combine)
- [Auto Deinterlace](#auto-deinterlace)
- [Bayer to RGB](#bayer-to-rgb)
- [Chroma Key](#chroma-key)
- [Codec Alpha Demux](#codec-alpha-demux)
- [Color effects](#color-effects)
- [Deinterlace](#deinterlace)
- [Dice](#dice)
- [Edge](#edge)
- [Fish eye](#fish-eye)
- [Flip/Rotate](#fliprotate)
- [Gamma](#gamma)
- [Gaussian blur](#gaussian-blur)
- [Grayscale](#grayscale)
- [Image overlay](#image-overlay)
- [Image Overlay Cairo](#image-overlay-cairo)
- [Interlace](#interlace)
- [Key Frame Detector](#key-frame-detector)
- [LUT Processor](#lut-processor)
- [Mirror](#mirror)
- [Motion Detection](#motion-detection)
- [Moving Blur](#moving-blur)
- [Moving Echo](#moving-echo)
- [Moving Zoom Echo](#moving-zoom-echo)
- [Optical Animation BW](#optical-animation-bw)
- [Overlay Manager](#overlay-manager)
- [Perspective](#perspective)
- [Pinch](#pinch)
- [Pseudo 3D](#pseudo-3d)
- [QR Code Overlay](#qr-code-overlay)
- [Quark](#quark)
- [Resize](#resize)
- [Ripple](#ripple)
- [Rotate](#rotate)
- [Rounded Corners](#rounded-corners)
- [SMPTE](#smpte)
- [SMPTE Alpha](#smpte-alpha)
- [Squeezeback](#squeezeback)
- [Squeezeback V2](#squeezeback-v2)
- [SVG Overlay](#svg-overlay)
- [Simple Video Mark](#simple-video-mark)
- [Simple Video Mark Detect](#simple-video-mark-detect)
- [Smooth](#smooth)
- [Video sample grabber](#video-sample-grabber)
- [Sphere](#sphere)
- [Square](#square)
- [Pan Zoom](#pan-zoom)
- [Stretch](#stretch)
- [Text overlay](#text-overlay)
- [Tunnel](#tunnel)
- [Twirl](#twirl)
- [Video Aspect Ratio Crop](#video-aspect-ratio-crop)
- [Video balance](#video-balance)
- [Video Box](#video-box)
- [Video Converter](#video-converter)
- [Video Crop](#video-crop)
- [Video Effects](#video-effects)
- [Video mixer](#video-mixer)
- [Video Padding Changer](#video-padding-changer)
- [Video Rate](#video-rate)
- [Video Stabilization](#video-stabilization)
- [Warp](#warp)
- [Water ripple](#water-ripple)
- [D3D11 Video Converter](#d3d11-video-converter)
- [Video Effects (Windows)](#video-effects-windows)
- [D3D11 Video Compositor](#d3d11-video-compositor)
- [VR360 Processor](#vr360-processor)

## Aging

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Aging block simulates vintage film deterioration and weathering effects, applying realistic aging effects to video content including film scratches, dust particles, color degradation, sepia toning, and temporal fluctuations to create authentic vintage film appearance.

### Block info

Name: AgingBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AgingBlock;
    AgingBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var agingSettings = new AgingVideoEffect
{
    ColorAging   = true,   // yellowing / fading (bool, default true)
    Dusts        = true,   // random dust particles (bool, default true)
    Pits         = true,   // small holes / imperfections (bool, default true)
    ScratchLines = 7       // number of vertical scratches (uint, default 7)
};
var aging = new AgingBlock(agingSettings);
pipeline.Connect(fileSource.VideoOutput, aging.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(aging.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Alpha Combine

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The AlphaCombine block combines two video streams using alpha channel blending, enabling sophisticated compositing operations with transparency control.

### Block info

Name: AlphaCombineBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input (Primary) | Uncompressed video | 1 |
| Input (Alpha) | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock1-->|Primary|AlphaCombineBlock;
    UniversalSourceBlock2-->|Alpha|AlphaCombineBlock;
    AlphaCombineBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var primarySource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video.mp4"));
var alphaSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("alpha.mp4"));

var alphaCombine = new AlphaCombineBlock();
pipeline.Connect(primarySource.VideoOutput, alphaCombine.Input);
pipeline.Connect(alphaSource.VideoOutput, alphaCombine.AlphaInput);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(alphaCombine.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Auto Deinterlace

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The AutoDeinterlace block automatically detects and deinterlaces interlaced video content, converting it to progressive format. It intelligently determines when deinterlacing is needed based on the video stream properties.

### Block info

Name: AutoDeinterlaceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->AutoDeinterlaceBlock;
    AutoDeinterlaceBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "interlaced_video.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var autoDeinterlace = new AutoDeinterlaceBlock(new AutoDeinterlaceSettings());
pipeline.Connect(fileSource.VideoOutput, autoDeinterlace.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(autoDeinterlace.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Bayer to RGB

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Bayer2RGB block converts Bayer pattern raw sensor data to RGB color video. This is essential for processing video from industrial cameras and sensors that output raw Bayer pattern data.

### Block info

Name: Bayer2RGBBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Bayer pattern video | 1 |
| Output | Uncompressed RGB video | 1 |

### The sample pipeline

```
graph LR;
    IndustrialCameraSource-->Bayer2RGBBlock;
    Bayer2RGBBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Assuming a camera source that outputs Bayer pattern
var cameraSource = new SystemVideoSourceBlock(cameraSettings);

var bayer2rgb = new Bayer2RGBBlock();
pipeline.Connect(cameraSource.Output, bayer2rgb.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(bayer2rgb.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

## Chroma Key

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The ChromaKey block provides professional green screen compositing and color keying functionality, removing specific colors from video content and compositing foreground subjects onto different backgrounds. Features sophisticated color selection, edge refinement, spill suppression, and alpha channel generation.

### Block info

Name: ChromaKeyBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input (Background) | Uncompressed video | 1 |
| Input (Chroma) | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    ImageVideoSourceBlock-->|Background|ChromaKeyBlock;
    SystemVideoSourceBlock-->|Chroma|ChromaKeyBlock;
    ChromaKeyBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Create background source (image or video)
var backgroundSettings = new ImageVideoSourceSettings("background.jpg")
{
    FrameRate = new VideoFrameRate(30.0)
};
var backgroundSource = new ImageVideoSourceBlock(backgroundSettings);

// Create foreground source with green screen
var device = (await DeviceEnumerator.Shared.VideoSourcesAsync())[0];
var videoFormat = device.VideoFormats[0];
var videoSettings = new VideoCaptureDeviceSourceSettings(device)
{
    Format = videoFormat.ToFormat()
};
var videoSource = new SystemVideoSourceBlock(videoSettings);

// Create chroma key block
var chromaKeySettings = new ChromaKeySettingsX(new Size(1920, 1080))
{
    ChromaColor = ChromaKeyColor.Green,
    Sensitivity = 0.5,
    NoiseLevel = 0.1,
    Alpha = 1.0
};
var chromaKey = new ChromaKeyBlock(chromaKeySettings);

// Connect pipeline
pipeline.Connect(backgroundSource.Output, chromaKey.BackgroundInput);
pipeline.Connect(videoSource.Output, chromaKey.ChromaInput);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(chromaKey.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Sample applications

- [ChromaKey Demo (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/ChromaKey)

### Platforms

Windows, macOS, Linux, iOS, Android.

## Codec Alpha Demux

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The CodecAlphaDemux block separates alpha channel from video codecs that support embedded alpha channels (like VP8, VP9, or ProRes with alpha).

### Block info

Name: CodecAlphaDemuxBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Compressed video with alpha | 1 |
| Output (Video) | Uncompressed video | 1 |
| Output (Alpha) | Alpha channel | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->CodecAlphaDemuxBlock;
    CodecAlphaDemuxBlock-->|Video|VideoRendererBlock;
    CodecAlphaDemuxBlock-->|Alpha|AlphaProcessor;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "video_with_alpha.webm"; // VP8/VP9 with alpha
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var alphaDemux = new CodecAlphaDemuxBlock();
pipeline.Connect(fileSource.VideoOutput, alphaDemux.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(alphaDemux.VideoOutput, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Color effects

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block performs basic video frame color processing: fake heat camera toning, sepia toning, invert and slightly shade to blue, cross processing toning, and yellow foreground/blue background color filter.

### Block info

Name: ColorEffectsBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->ColorEffectsBlock;
    ColorEffectsBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// Sepia
var colorEffects = new ColorEffectsBlock(ColorEffectsPreset.Sepia);
pipeline.Connect(fileSource.VideoOutput, colorEffects.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(colorEffects.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Dice

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Dice block divides the video frame into a grid of tiles and applies various transformations to create a fragmented, mosaic-like visual effect.

### Block info

Name: DiceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->DiceBlock;
    DiceBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var dice = new DiceBlock(new DiceVideoEffect());
pipeline.Connect(fileSource.VideoOutput, dice.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(dice.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Edge

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Edge block detects and highlights edges in video frames, creating an edge-detection visual effect useful for artistic purposes or computer vision preprocessing.

### Block info

Name: EdgeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->EdgeBlock;
    EdgeBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var edge = new EdgeBlock();
pipeline.Connect(fileSource.VideoOutput, edge.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(edge.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Deinterlace

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block deinterlaces interlaced video frames into progressive video frames. Several methods of processing are available. Use the DeinterlaceSettings class to configure the block.

### Block info

Name: DeinterlaceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->DeinterlaceBlock;
    DeinterlaceBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var deinterlace = new DeinterlaceBlock(new DeinterlaceSettings());
pipeline.Connect(fileSource.VideoOutput, deinterlace.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(deinterlace.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Fish eye

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The fisheye block simulates a fisheye lens by zooming on the center of the image and compressing the edges.

### Block info

Name: FishEyeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->FishEyeBlock;
    FishEyeBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var fishEye = new FishEyeBlock();
pipeline.Connect(fileSource.VideoOutput, fishEye.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(fishEye.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Flip/Rotate

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block flips and rotates the video stream. Use the VideoFlipRotateMethod enumeration to configure.

### Block info

Name: FlipRotateBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->FlipRotateBlock;
    FlipRotateBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// 90 degree rotation
var flipRotate = new FlipRotateBlock(VideoFlipRotateMethod.Method90R);
pipeline.Connect(fileSource.VideoOutput, flipRotate.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(flipRotate.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Gamma

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block performs gamma correction on a video stream.

### Block info

Name: GammaBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->GammaBlock;
    GammaBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var gamma = new GammaBlock(2.0);
pipeline.Connect(fileSource.VideoOutput, gamma.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(gamma.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Gaussian blur

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block blurs the video stream using the Gaussian function.

### Block info

Name: GaussianBlurBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->GaussianBlurBlock;
    GaussianBlurBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var gaussianBlur = new GaussianBlurBlock();
pipeline.Connect(fileSource.VideoOutput, gaussianBlur.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(gaussianBlur.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Grayscale

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Grayscale block converts color video to grayscale (black and white), removing all color information while preserving luminance.

### Block info

Name: GrayscaleBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->GrayscaleBlock;
    GrayscaleBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var grayscale = new GrayscaleBlock();
pipeline.Connect(fileSource.VideoOutput, grayscale.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(grayscale.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Image overlay

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block overlays an image loaded from a file onto a video stream.

You can set an image position and optional alpha value. 32-bit images with alpha-channel are supported.

### Block info

Name: ImageOverlayBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->ImageOverlayBlock;
    ImageOverlayBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var imageOverlay = new ImageOverlayBlock(@"logo.png");
pipeline.Connect(fileSource.VideoOutput, imageOverlay.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(imageOverlay.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Image Overlay Cairo

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The ImageOverlayCairo block provides advanced image overlay capabilities using the Cairo graphics library, offering enhanced rendering quality and additional features compared to the standard image overlay block.

### Block info

Name: ImageOverlayCairoBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->ImageOverlayCairoBlock;
    ImageOverlayCairoBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var imageOverlayCairo = new ImageOverlayCairoBlock("logo.png");
pipeline.Connect(fileSource.VideoOutput, imageOverlayCairo.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(imageOverlayCairo.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Interlace

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Interlace block converts progressive video to interlaced format, creating alternating field lines. This is useful for broadcast or compatibility with interlaced display systems.

### Block info

Name: InterlaceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->InterlaceBlock;
    InterlaceBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var interlace = new InterlaceBlock(new InterlaceSettings());
pipeline.Connect(fileSource.VideoOutput, interlace.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(interlace.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Key Frame Detector

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The KeyFrameDetector block analyzes video streams to detect and identify key frames (I-frames) in the video sequence, useful for video editing and analysis applications.

### Block info

Name: KeyFrameDetectorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->KeyFrameDetectorBlock;
    KeyFrameDetectorBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var keyFrameDetector = new KeyFrameDetectorBlock();
keyFrameDetector.OnKeyFrameDetected += (sender, e) =>
{
    // OnKeyFrameDetected is EventHandler<TimeSpan>; `e` itself is the timestamp.
    Console.WriteLine($"Key frame detected at timestamp: {e}");
};
pipeline.Connect(fileSource.VideoOutput, keyFrameDetector.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(keyFrameDetector.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## LUT Processor

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The LUT (Look-Up Table) Processor block applies color grading and correction using 3D LUT files, enabling professional color transformations and cinematic looks.

### Block info

Name: LUTProcessorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->LUTProcessorBlock;
    LUTProcessorBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var lutSettings = new LUTVideoEffect
{
    Filename = "cinematic_lut.cube"   // .cube LUT file path
};
var lutProcessor = new LUTProcessorBlock(lutSettings);
pipeline.Connect(fileSource.VideoOutput, lutProcessor.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(lutProcessor.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Mirror

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The mirror block splits the image into two halves and reflects one over the other.

### Block info

Name: MirrorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MirrorBlock;
    MirrorBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var mirrorBlock = new MirrorBlock(MirrorMode.Top);
pipeline.Connect(fileSource.VideoOutput, mirrorBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(mirrorBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Moving Blur

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The MovingBlur block creates dynamic motion blur effects by blending current frames with previous frames, simulating camera motion blur or creating artistic trailing effects.

### Block info

Name: MovingBlurBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MovingBlurBlock;
    MovingBlurBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var movingBlur = new MovingBlurBlock(new MovingBlurVideoEffect());
pipeline.Connect(fileSource.VideoOutput, movingBlur.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(movingBlur.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Moving Echo

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The MovingEcho block creates echo-like visual effects by layering delayed versions of the video frames, producing a ghosting or trail effect.

### Block info

Name: MovingEchoBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MovingEchoBlock;
    MovingEchoBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var movingEcho = new MovingEchoBlock(new MovingEchoVideoEffect());
pipeline.Connect(fileSource.VideoOutput, movingEcho.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(movingEcho.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Moving Zoom Echo

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The MovingZoomEcho block combines motion echo effects with zoom transformations, creating dynamic visual effects that simulate zooming trails.

### Block info

Name: MovingZoomEchoBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MovingZoomEchoBlock;
    MovingZoomEchoBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var movingZoomEcho = new MovingZoomEchoBlock(new MovingZoomEchoVideoEffect());
pipeline.Connect(fileSource.VideoOutput, movingZoomEcho.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(movingZoomEcho.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Optical Animation BW

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The OpticalAnimationBW block applies black and white optical animation effects, creating vintage film-style visual transformations.

### Block info

Name: OpticalAnimationBWBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->OpticalAnimationBWBlock;
    OpticalAnimationBWBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var opticalAnimBW = new OpticalAnimationBWBlock(new OpticalAnimationBWVideoEffect());
pipeline.Connect(fileSource.VideoOutput, opticalAnimBW.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(opticalAnimBW.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Overlay Manager

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The OverlayManager block provides a comprehensive system for managing multiple overlays (text, images, shapes) on video, with support for dynamic updates and animations.

### Block info

Name: OverlayManagerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->OverlayManagerBlock;
    OverlayManagerBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var overlayManager = new OverlayManagerBlock();
pipeline.Connect(fileSource.VideoOutput, overlayManager.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(overlayManager.Output, videoRenderer.Input);

await pipeline.StartAsync();

// Add overlays by constructing the element type and calling Video_Overlay_Add.
var textOverlay = new OverlayManagerText("Hello World", x: 100, y: 100);
overlayManager.Video_Overlay_Add(textOverlay);

using (var logo = new System.Drawing.Bitmap("logo.png"))
{
    var imageOverlay = new OverlayManagerImage(logo, x: 10, y: 10);
    overlayManager.Video_Overlay_Add(imageOverlay);
}
```

### Sample applications

- [OverlayManagerBlock documentation page](OverlayManagerBlock/)

### Platforms

Windows, macOS, Linux, iOS, Android.

## Perspective

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The perspective block applies a 2D perspective transform.

### Block info

Name: PerspectiveBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->PerspectiveBlock;
    PerspectiveBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var persBlock = new PerspectiveBlock(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
pipeline.Connect(fileSource.VideoOutput, persBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(persBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Pinch

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block performs the pinch geometric transform of the image.

### Block info

Name: PinchBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->PinchBlock;
    PinchBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var pinchBlock = new PinchBlock();
pipeline.Connect(fileSource.VideoOutput, pinchBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(pinchBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Pseudo 3D

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Pseudo3D block applies 3D-like perspective transformations to create depth illusions in 2D video.

### Block info

Name: Pseudo3DBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->Pseudo3DBlock;
    Pseudo3DBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var pseudo3D = new Pseudo3DBlock(new Pseudo3DVideoEffect());
pipeline.Connect(fileSource.VideoOutput, pseudo3D.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(pseudo3D.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## QR Code Overlay

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The QRCodeOverlay block generates and overlays QR codes on video content, useful for embedding URLs, metadata, or tracking information.

### Block info

Name: QRCodeOverlayBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->QRCodeOverlayBlock;
    QRCodeOverlayBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var qrCodeOverlay = new QRCodeOverlayBlock("https://www.visioforge.com");
pipeline.Connect(fileSource.VideoOutput, qrCodeOverlay.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(qrCodeOverlay.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Quark

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Quark block applies a particle-like visual effect that breaks the image into quark-style fragments.

### Block info

Name: QuarkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->QuarkBlock;
    QuarkBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var quark = new QuarkBlock(new QuarkVideoEffect());
pipeline.Connect(fileSource.VideoOutput, quark.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(quark.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Ripple

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Ripple block creates water ripple-like distortion effects across the video frame.

### Block info

Name: RippleBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->RippleBlock;
    RippleBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var ripple = new RippleBlock(new RippleVideoEffect());
pipeline.Connect(fileSource.VideoOutput, ripple.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(ripple.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Rotate

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block rotates the image by a specified angle.

### Block info

Name: RotateBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->RotateBlock;
    RotateBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var rotateBlock = new RotateBlock(0.7);
pipeline.Connect(fileSource.VideoOutput, rotateBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(rotateBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Rounded Corners

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The RoundedCorners block applies rounded corners to video frames, creating a modern, soft-edged appearance.

### Block info

Name: RoundedCornersBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->RoundedCornersBlock;
    RoundedCornersBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var roundedCorners = new RoundedCornersBlock(20); // Radius of 20 pixels
pipeline.Connect(fileSource.VideoOutput, roundedCorners.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(roundedCorners.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Resize

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block resizes the video stream. You can configure the resize method, the letterbox flag, and many other options.

Use the `ResizeVideoEffect` class to configure.

### Block info

Name: VideoResizeBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoResizeBlock;
    VideoResizeBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoResize = new VideoResizeBlock(new ResizeVideoEffect(1280, 720) { Letterbox = false });
pipeline.Connect(fileSource.VideoOutput, videoResize.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoResize.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Video sample grabber

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The video sample grabber calls an event for each video frame. You can save or process the received video frame.

### Block info

Name: VideoSampleGrabberBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoSampleGrabberBlock;
    VideoSampleGrabberBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoSG = new VideoSampleGrabberBlock();
videoSG.OnVideoFrameBuffer += VideoSG_OnVideoFrameBuffer;
pipeline.Connect(fileSource.VideoOutput, videoSG.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoSG.Output, videoRenderer.Input);

await pipeline.StartAsync();

private void VideoSG_OnVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    // save or process the video frame
}
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## SMPTE

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The SMPTE block creates professional broadcast-style wipe transitions between two video sources using SMPTE (Society of Motion Picture and Television Engineers) standard transition patterns.

### Block info

Name: SMPTEBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input (Source 1) | Uncompressed video | 1 |
| Input (Source 2) | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock1-->|Source1|SMPTEBlock;
    UniversalSourceBlock2-->|Source2|SMPTEBlock;
    SMPTEBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source1 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video1.mp4"));
var source2 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video2.mp4"));

var smpteSettings = new SMPTEVideoEffect
{
    Type   = SMPTETransitionType.BarWipeLeftToRight,  // SMPTETransitionType enum — 70+ wipe styles
    Border = 0                                        // int — border thickness (0 = no border)
};
var smpte = new SMPTEBlock(smpteSettings);
// SMPTEBlock currently exposes a single Input pad; wire a single source.
pipeline.Connect(source1.VideoOutput, smpte.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(smpte.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## SMPTE Alpha

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The SMPTEAlpha block creates SMPTE-style wipe transitions with alpha channel support for transparency-aware compositing.

### Block info

Name: SMPTEAlphaBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input (Source 1) | Uncompressed video | 1 |
| Input (Source 2) | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock1-->|Source1|SMPTEAlphaBlock;
    UniversalSourceBlock2-->|Source2|SMPTEAlphaBlock;
    SMPTEAlphaBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source1 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video1.mp4"));
var source2 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video2.mp4"));

var smpteAlphaSettings = new SMPTEAlphaVideoEffect
{
    Type = SMPTETransitionType.BarWipeTopToBottom     // SMPTETransitionType enum
};
var smpteAlpha = new SMPTEAlphaBlock(smpteAlphaSettings);
// SMPTEAlphaBlock currently exposes a single Input pad; wire a single source.
pipeline.Connect(source1.VideoOutput, smpteAlpha.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(smpteAlpha.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## SVG Overlay

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The SVGOverlay block renders SVG (Scalable Vector Graphics) content on top of video, enabling high-quality scalable graphics overlays.

### Block info

Name: SVGOverlayBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SVGOverlayBlock;
    SVGOverlayBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var svgSettings = new SVGOverlayVideoEffect
{
    Filename = "logo.svg"   // path to the SVG file; alternative: set Data to inline SVG string
};
var svgOverlay = new SVGOverlayBlock(svgSettings);
pipeline.Connect(fileSource.VideoOutput, svgOverlay.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(svgOverlay.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Simple Video Mark

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The SimpleVideoMark block embeds invisible watermarks or markers into video content for tracking and verification purposes.

### Block info

Name: SimpleVideoMarkBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SimpleVideoMarkBlock;
    SimpleVideoMarkBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoMark = new SimpleVideoMarkBlock(42); // Unique identifier
pipeline.Connect(fileSource.VideoOutput, videoMark.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoMark.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Simple Video Mark Detect

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The SimpleVideoMarkDetect block detects and extracts invisible watermarks embedded by the SimpleVideoMark block.

### Block info

Name: SimpleVideoMarkDetectBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SimpleVideoMarkDetectBlock;
    SimpleVideoMarkDetectBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "marked_video.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var markDetect = new SimpleVideoMarkDetectBlock();
markDetect.VideoMarkDetected += (sender, e) =>
{
    Console.WriteLine($"Detected mark");
};
pipeline.Connect(fileSource.VideoOutput, markDetect.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(markDetect.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Smooth

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Smooth block applies smoothing filters to reduce noise and create softer video appearance.

### Block info

Name: SmoothBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SmoothBlock;
    SmoothBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var smooth = new SmoothBlock(new SmoothVideoEffect());
pipeline.Connect(fileSource.VideoOutput, smooth.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(smooth.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Sphere

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The sphere block applies a sphere geometric transform to the video.

### Block info

Name: SphereBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SphereBlock;
    SphereBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var sphereBlock = new SphereBlock();
pipeline.Connect(fileSource.VideoOutput, sphereBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(sphereBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Square

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The square block distorts the center part of the video into a square.

### Block info

Name: SquareBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SquareBlock;
    SquareBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var squareBlock = new SquareBlock(new SquareVideoEffect());
pipeline.Connect(fileSource.VideoOutput, squareBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(squareBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Pan Zoom

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The `PanZoomBlock` applies pan and zoom transformations to a video stream using Cairo-based rendering via the GStreamer `cairooverlay` element. The block supports static and animated (time-interpolated) pan and zoom, as well as mapping video to an arbitrary target rectangle.

### Block info

Name: PanZoomBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### Settings

The block accepts no constructor parameters. Transformations are configured by calling methods on the block instance:

| Method | Settings class | Description |
| --- | --- | --- |
| `SetZoom(settings)` | `VideoStreamZoomSettings` | Apply a static zoom centered at a point |
| `SetDynamicZoom(settings)` | `VideoStreamDynamicZoomSettings` | Animate zoom between start and stop values over time |
| `SetPan(settings)` | `VideoStreamPanSettings` | Translate the video by a pixel offset |
| `SetDynamicPan(settings)` | `VideoStreamDynamicPanSettings` | Animate pan between start and stop positions over time |
| `SetRect(settings)` | `VideoStreamRectSettings` | Map video to a target rectangle (takes precedence over zoom/pan) |

**`VideoStreamZoomSettings`**

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `ZoomX` | `double` | `1.0` | Horizontal zoom factor |
| `ZoomY` | `double` | `1.0` | Vertical zoom factor |
| `CenterX` | `double` | `0.5` | Horizontal zoom center (0.0–1.0) |
| `CenterY` | `double` | `0.5` | Vertical zoom center (0.0–1.0) |
| `Enabled` | `bool` | `true` | Enable or disable this transformation |

**`VideoStreamPanSettings`**

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `PanX` | `double` | `0.0` | Horizontal offset in pixels |
| `PanY` | `double` | `0.0` | Vertical offset in pixels |
| `Enabled` | `bool` | `true` | Enable or disable this transformation |

`VideoStreamDynamicZoomSettings` extends the static zoom with `StartTime`/`StopTime` (`TimeSpan`) and start/stop zoom and center values, linearly interpolated during playback.

`VideoStreamDynamicPanSettings` extends the static pan with `StartTime`/`StopTime` and start/stop pan values, linearly interpolated during playback.

`VideoStreamRectSettings` maps the video to a `TargetRect` (`Rect`). When enabled, this takes precedence over zoom and pan settings.

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->PanZoomBlock;
    PanZoomBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("test.mp4"));

var panZoom = new PanZoomBlock();
panZoom.SetZoom(new VideoStreamZoomSettings(zoomX: 2.0, zoomY: 2.0, centerX: 0.5, centerY: 0.5));
panZoom.SetPan(new VideoStreamPanSettings(panX: -100, panY: 0));

pipeline.Connect(fileSource.VideoOutput, panZoom.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(panZoom.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Availability

`PanZoomBlock.IsAvailable()` returns `true` if the GStreamer `cairooverlay` element is available.

### Platforms

Windows, macOS, Linux, iOS, Android.

## Stretch

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The stretch block stretches the video in the circle around the center point.

### Block info

Name: StretchBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->StretchBlock;
    StretchBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var stretchBlock = new StretchBlock();
pipeline.Connect(fileSource.VideoOutput, stretchBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(stretchBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Text overlay

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block adds the text overlay on top of the video stream.

### Block info

Name: TextOverlayBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### Configuration

`TextOverlayBlock` is configured using `TextOverlaySettings`. Key properties:

- `Text` (string): The text to overlay.
- `Font` (FontSettings): Font configuration (family, size, weight, etc.).
- `Color` (`SKColor`): Text color.
- `OutlineColor` (`SKColor`): Text outline color.
- `HorizontalAlignment` (enum `TextOverlayHAlign`): Horizontal alignment.
- `VerticalAlignment` (enum `TextOverlayVAlign`): Vertical alignment.
- `XPad` (int): Horizontal padding when using left/right alignment.
- `YPad` (int): Vertical padding when using top/bottom alignment.
- `XPos` (double): Horizontal position when using position alignment (0.0-1.0).
- `YPos` (double): Vertical position when using position alignment (0.0-1.0).
- `DeltaX` (int): X position offset in pixels.
- `DeltaY` (int): Y position offset in pixels.

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->TextOverlayBlock;
    TextOverlayBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var textOverlay = new TextOverlayBlock(new TextOverlaySettings("Hello world!")
{
    Font = new FontSettings
    {
        Name = "Arial",
        Size = 32
    },
    Color = SKColors.Yellow,
    HorizontalAlignment = TextOverlayHAlign.Left,
    VerticalAlignment = TextOverlayVAlign.Top,
    XPad = 50,
    YPad = 50
});
pipeline.Connect(fileSource.VideoOutput, textOverlay.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(textOverlay.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Tunnel

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block applies a light tunnel effect to a video stream.

### Block info

Name: TunnelBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->TunnelBlock;
    TunnelBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var tunnelBlock = new TunnelBlock();
pipeline.Connect(fileSource.VideoOutput, tunnelBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(tunnelBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Twirl

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The twirl block twists the video frame from the center out.

### Block info

Name: TwirlBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->TwirlBlock;
    TwirlBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var twirlBlock = new TwirlBlock();
pipeline.Connect(fileSource.VideoOutput, twirlBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(twirlBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Video balance

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The block processes the video stream and allows you to change brightness, contrast, hue, and saturation. Use the VideoBalanceVideoEffect class to configure the block settings.

### Block info

Name: VideoBalanceBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoBalanceBlock;
    VideoBalanceBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoBalance = new VideoBalanceBlock(new VideoBalanceVideoEffect() { Brightness = 0.25 });
pipeline.Connect(fileSource.VideoOutput, videoBalance.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoBalance.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Video mixer

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The video mixer block has several inputs and one output. The block draws the inputs in the selected order at the selected positions. You can also set the desired level of transparency for each stream.

### Block info

Name: VideoMixerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 or more |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock#1-->VideoMixerBlock;
    UniversalSourceBlock#2-->VideoMixerBlock;
    VideoMixerBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

// Define source files
var filename1 = "test.mp4"; // Replace with your first video file
var fileSource1 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename1));

var filename2 = "test2.mp4"; // Replace with your second video file
var fileSource2 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename2));

// Configure VideoMixerSettings with output resolution and frame rate
// For example, 1280x720 resolution at 30 frames per second
var outputWidth = 1280;
var outputHeight = 720;
var outputFrameRate = new VideoFrameRate(30);
var mixerSettings = new VideoMixerSettings(outputWidth, outputHeight, outputFrameRate);

// Add streams to the mixer
// Stream 1: Main video, occupies the full output frame, Z-order 0 (bottom layer)
mixerSettings.AddStream(new VideoMixerStream(new Rect(0, 0, outputWidth, outputHeight), 0));

// Stream 2: Overlay video, 320x180 box positioned at (50,50), Z-order 1 (on top)
// IMPORTANT: Rect ctor is (left, top, right, bottom) — for a 320x180 box at (50,50),
// pass right=50+320=370 and bottom=50+180=230, NOT width/height directly.
mixerSettings.AddStream(new VideoMixerStream(new Rect(50, 50, 370, 230), 1));

// Create the VideoMixerBlock
var videoMixer = new VideoMixerBlock(mixerSettings);

// Connect source outputs to VideoMixerBlock inputs
pipeline.Connect(fileSource1.VideoOutput, videoMixer.Inputs[0]);
pipeline.Connect(fileSource2.VideoOutput, videoMixer.Inputs[1]);

// Create a VideoRendererBlock to display the mixed video
// VideoView1 is a placeholder for your UI element (e.g., a WPF control)
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoMixer.Output, videoRenderer.Input);

// Start the pipeline
await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

### Video Mixer Types and Configuration

The Media Blocks SDK offers several types of video mixers, allowing you to choose the best fit for your application's performance needs and target platform capabilities. These include CPU-based, Direct3D 11, and OpenGL mixers.

All mixer settings classes inherit from `VideoMixerBaseSettings`, which defines common properties like output resolution (`Width`, `Height`), `FrameRate`, and the list of `Streams` to be mixed.

#### 1. CPU-based Video Mixer (VideoMixerSettings)

This is the default video mixer and relies on CPU processing for mixing video streams. It is platform-agnostic and a good general-purpose option.

To use the CPU-based mixer, you instantiate `VideoMixerSettings`:

```
// Output resolution 1920x1080 at 30 FPS
var outputWidth = 1920;
var outputHeight = 1080;
var outputFrameRate = new VideoFrameRate(30);

var mixerSettings = new VideoMixerSettings(outputWidth, outputHeight, outputFrameRate);

// Add streams (see example in the main Video Mixer section)
// mixerSettings.AddStream(new VideoMixerStream(new Rect(0, 0, outputWidth, outputHeight), 0));
// ...

var videoMixer = new VideoMixerBlock(mixerSettings);
```

#### 2. Direct3D 11 Video Compositor (D3D11VideoCompositorSettings)

For Windows applications, the `D3D11VideoCompositorSettings` provides hardware-accelerated video mixing using Direct3D 11. This can offer significant performance improvements, especially with high-resolution video or a large number of streams.

```
// Output resolution 1920x1080 at 30 FPS
var outputWidth = 1920;
var outputHeight = 1080;
var outputFrameRate = new VideoFrameRate(30);

// Optionally, specify the graphics adapter index (-1 for default)
var adapterIndex = -1;
var d3dMixerSettings = new D3D11VideoCompositorSettings(outputWidth, outputHeight, outputFrameRate)
{
    AdapterIndex = adapterIndex
};

// Streams are added similarly to VideoMixerSettings
// d3dMixerSettings.AddStream(new VideoMixerStream(new Rect(0, 0, outputWidth, outputHeight), 0));
// For more advanced control, you can use D3D11VideoCompositorStream to specify blend states
// d3dMixerSettings.AddStream(new D3D11VideoCompositorStream(new Rect(50, 50, 370, 230), 1)
// {
//     BlendSourceRGB = D3D11CompositorBlend.SourceAlpha,
//     BlendDestRGB = D3D11CompositorBlend.InverseSourceAlpha
// });
// ...

var videoMixer = new VideoMixerBlock(d3dMixerSettings);
```

The `D3D11VideoCompositorStream` class, which inherits from `VideoMixerStream`, allows for fine-grained control over D3D11 blend states if needed.

#### 3. OpenGL Video Mixer (GLVideoMixerSettings)

The `GLVideoMixerSettings` enables hardware-accelerated video mixing using OpenGL. This is a cross-platform solution for leveraging GPU capabilities on Windows, macOS, and Linux.

```
// Output resolution 1920x1080 at 30 FPS
var outputWidth = 1920;
var outputHeight = 1080;
var outputFrameRate = new VideoFrameRate(30);

var glMixerSettings = new GLVideoMixerSettings(outputWidth, outputHeight, outputFrameRate);

// Streams are added similarly to VideoMixerSettings
// glMixerSettings.AddStream(new VideoMixerStream(new Rect(0, 0, outputWidth, outputHeight), 0));
// For more advanced control, you can use GLVideoMixerStream to specify blend functions and equations
// glMixerSettings.AddStream(new GLVideoMixerStream(new Rect(50, 50, 370, 230), 1)
// {
//     BlendFunctionSourceRGB = GLVideoMixerBlendFunction.SourceAlpha,
//     BlendFunctionDesctinationRGB = GLVideoMixerBlendFunction.OneMinusSourceAlpha,
//     BlendEquationRGB = GLVideoMixerBlendEquation.Add
// });
// ...

var videoMixer = new VideoMixerBlock(glMixerSettings);
```

The `GLVideoMixerStream` class, inheriting from `VideoMixerStream`, provides properties to control OpenGL-specific blending parameters.

Choosing the appropriate mixer depends on your application's requirements. For simple mixing or maximum compatibility, the CPU-based mixer is suitable. For performance-critical applications on Windows, D3D11 is recommended. For cross-platform GPU acceleration, OpenGL is the preferred choice.

## Water ripple

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The water ripple block creates a water ripple effect on the video stream. Use the `WaterRippleVideoEffect` class to configure.

### Block info

Name: WaterRippleBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->WaterRippleBlock;
    WaterRippleBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var wrBlock = new WaterRippleBlock(new WaterRippleVideoEffect());
pipeline.Connect(fileSource.VideoOutput, wrBlock.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(wrBlock.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Video Aspect Ratio Crop

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VideoAspectRatioCrop block automatically crops video to a specific aspect ratio, removing letterboxing or pillarboxing.

### Block info

Name: VideoAspectRatioCropBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoAspectRatioCropBlock;
    VideoAspectRatioCropBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var aspectCrop = new VideoAspectRatioCropBlock(new AspectRatioCropVideoEffect { AspectRatio = "16:9" });
pipeline.Connect(fileSource.VideoOutput, aspectCrop.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(aspectCrop.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Video Box

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VideoBox block adds colored borders or letterboxing around video content.

### Block info

Name: VideoBoxBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoBoxBlock;
    VideoBoxBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoBox = new VideoBoxBlock(new BoxVideoEffect
{
    Top = 50,
    Bottom = 50,
    Left = 100,
    Right = 100
});
pipeline.Connect(fileSource.VideoOutput, videoBox.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoBox.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Video Converter

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VideoConverter block converts video between different color spaces and pixel formats.

### Block info

Name: VideoConverterBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoConverterBlock;
    VideoConverterBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoConverter = new VideoConverterBlock();
pipeline.Connect(fileSource.VideoOutput, videoConverter.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoConverter.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Video Crop

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VideoCrop block removes portions of the video frame by cropping specific regions.

### Block info

Name: VideoCropBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoCropBlock;
    VideoCropBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var cropSettings = new CropVideoEffect
{
    Top = 100,
    Bottom = 100,
    Left = 50,
    Right = 50
};
var videoCrop = new VideoCropBlock(cropSettings);
pipeline.Connect(fileSource.VideoOutput, videoCrop.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoCrop.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Video Effects

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VideoEffects block provides a comprehensive collection of video effects including color adjustments, filters, and transformations.

### Block info

Name: VideoEffectsBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoEffectsBlock;
    VideoEffectsBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoEffects = new VideoEffectsBlock();
pipeline.Connect(fileSource.VideoOutput, videoEffects.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoEffects.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Video Padding Changer

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VideoPaddingChanger block modifies video padding/borders dynamically.

### Block info

Name: VideoPaddingChangerBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoPaddingChangerBlock;
    VideoPaddingChangerBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var paddingSettings = new VideoPaddingChangerSettings
{
    Top = 20,
    Bottom = 20,
    Left = 40,
    Right = 40
};
var paddingChanger = new VideoPaddingChangerBlock(paddingSettings);
pipeline.Connect(fileSource.VideoOutput, paddingChanger.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(paddingChanger.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Video Rate

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VideoRate block adjusts the frame rate of video content through duplication or dropping frames.

### Block info

Name: VideoRateBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoRateBlock;
    VideoRateBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoRate = new VideoRateBlock(new VideoFrameRate(60.0)); // Convert to 60fps
pipeline.Connect(fileSource.VideoOutput, videoRate.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoRate.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## Warp

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Warp block applies geometric warping transformations to create distortion effects.

### Block info

Name: WarpBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->WarpBlock;
    WarpBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var warp = new WarpBlock(new WarpVideoEffect());
pipeline.Connect(fileSource.VideoOutput, warp.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(warp.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux, iOS, Android.

## D3D11 Video Converter

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The D3D11 Video Converter block performs hardware-accelerated video format conversion using Direct3D 11. This is useful for efficient color space or format changes on Windows platforms.

### Block info

Name: D3D11VideoConverterBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->D3D11VideoConverterBlock;
    D3D11VideoConverterBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var d3d11Converter = new D3D11VideoConverterBlock();
pipeline.Connect(fileSource.VideoOutput, d3d11Converter.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(d3d11Converter.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows (Direct3D 11 required).

## Video Effects (Windows)

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Video Effects (Windows) block allows you to add, update, and manage multiple video effects in real time. This block is specific to Windows and leverages the Media Foundation pipeline for effects processing.

### Block info

Name: VideoEffectsWinBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoEffectsWinBlock;
    VideoEffectsWinBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var videoEffects = new VideoEffectsWinBlock();
// Example: add a brightness effect
videoEffects.Video_Effects_Add(new VideoEffectBrightness(true, 0.2));
pipeline.Connect(fileSource.VideoOutput, videoEffects.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(videoEffects.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows.

## D3D11 Video Compositor

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The D3D11 Video Compositor block provides hardware-accelerated video mixing and compositing using Direct3D 11. It is designed for high-performance multi-stream video composition on Windows.

### Block info

Name: D3D11VideoCompositorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 or more |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock#1-->D3D11VideoCompositorBlock;
    UniversalSourceBlock#2-->D3D11VideoCompositorBlock;
    D3D11VideoCompositorBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename1 = "test.mp4";
var fileSource1 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename1));

var filename2 = "test2.mp4";
var fileSource2 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename2));

var outputWidth = 1280;
var outputHeight = 720;
var outputFrameRate = new VideoFrameRate(30);
var settings = new D3D11VideoCompositorSettings(outputWidth, outputHeight, outputFrameRate);
settings.AddStream(new D3D11VideoCompositorStream(new Rect(0, 0, outputWidth, outputHeight), 0));
settings.AddStream(new D3D11VideoCompositorStream(new Rect(50, 50, 370, 230), 1));

var d3d11Compositor = new D3D11VideoCompositorBlock(settings);
pipeline.Connect(fileSource1.VideoOutput, d3d11Compositor.Inputs[0]);
pipeline.Connect(fileSource2.VideoOutput, d3d11Compositor.Inputs[1]);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(d3d11Compositor.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows (Direct3D 11 required).

## VR360 Processor

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VR360 Processor block applies 360-degree equirectangular video effects, suitable for VR content. It uses Direct3D 11 for GPU-accelerated processing and allows real-time adjustment of yaw, pitch, roll, and field of view.

### Block info

Name: VR360ProcessorBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VR360ProcessorBlock;
    VR360ProcessorBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var vr360Settings = new D3D11VR360RendererSettings
{
    Yaw = 0,
    Pitch = 0,
    Roll = 0,
    FOV = 90
};
var vr360Processor = new VR360ProcessorBlock(vr360Settings);
pipeline.Connect(fileSource.VideoOutput, vr360Processor.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(vr360Processor.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows (Direct3D 11 required).

---

## Motion Detection

[!button text="Learn more about the SDK" variant="info" target="blank" icon="rocket"](https://www.visioforge.com/media-blocks-sdk-net)

`MotionDetectionBlock` analyzes consecutive video frames to detect motion using a frame-differencing algorithm. It produces a per-frame intensity level (0–100) and a spatial grid matrix via the `OnMotionDetected` event. Frames pass through the block unchanged.

### Block info

Name: MotionDetectionBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### Settings

`MotionDetectionBlockSettings` configures the detection algorithm:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `MotionThreshold` | `int` | `5` | Minimum motion level (0–100) required to fire the event |
| `CompareGreyscale` | `bool` | `true` | Compare frames using greyscale averaging |
| `GridWidth` | `int` | `8` | Number of horizontal cells in the motion matrix |
| `GridHeight` | `int` | `8` | Number of vertical cells in the motion matrix |

The `OnMotionDetected` event provides:

- `Level` — overall motion intensity (0–100)
- `Matrix` — `byte[]` of size `GridWidth × GridHeight`, per-cell motion intensity

The event fires only when `Level >= MotionThreshold`. Event handlers run on a GStreamer background thread and must be thread-safe.

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->MotionDetectionBlock;
    MotionDetectionBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

var motionSettings = new MotionDetectionBlockSettings
{
    MotionThreshold = 10,
    GridWidth = 8,
    GridHeight = 8
};
var motionDetector = new MotionDetectionBlock(motionSettings);
motionDetector.OnMotionDetected += (sender, e) =>
{
    Console.WriteLine($"Motion level: {e.Level}");
};

pipeline.Connect(fileSource.VideoOutput, motionDetector.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(motionDetector.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Platforms

Windows, macOS, Linux.

---

## Squeezeback

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The Squeezeback block reproduces the broadcast "squeezeback" (DVE) effect: the main video is shrunk into a rectangle while a background image fills the rest of the frame — a layout commonly used to roll end credits or promos next to live content. Internally it punches an alpha-transparent hole into the background image at the video rectangle and composites the video through it. The video position and opacity can be animated at runtime, and the background image can be faded in and out.

> Note: `SqueezebackBlockV2` supersedes this block — see [Squeezeback V2](#squeezeback-v2) for the recommended API.

### Block info

Name: SqueezebackBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SqueezebackBlock;
    SqueezebackBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// output frame geometry
var videoInfo = new VideoFrameInfoX(1920, 1080, new VideoFrameRate(30));

// background image and the rectangle the main video is squeezed into
var imageSettings = new ImageOverlaySettings("background.png");
var videoRect = new Rect(960, 540, 1920, 1080); // left, top, right, bottom

var squeezeback = new SqueezebackBlock(pipeline, videoInfo, imageSettings, videoRect);
pipeline.Connect(fileSource.VideoOutput, squeezeback.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(squeezeback.Output, videoRenderer.Input);

await pipeline.StartAsync();

// animate the video into the corner over 1 second
squeezeback.Input_Move(new Rect(1280, 720, 1920, 1080), TimeSpan.FromSeconds(1), null, null);

// fade the background image in
squeezeback.StartFadeIn(TimeSpan.FromSeconds(1));
```

### Platforms

Windows.

---

## Squeezeback V2

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

`SqueezebackBlockV2` is the recommended squeezeback implementation. It builds the effect on top of a `VideoMixerBlock` instead of an alpha-punched overlay, so the background image and the main video are independent mixer layers. This adds a separate background-image rectangle, a `videoOnTop` flag to control z-order, runtime layer swapping, and independent position/opacity/fade animation for both the video and the image.

### Block info

Name: SqueezebackBlockV2.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->SqueezebackBlockV2;
    SqueezebackBlockV2-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// output frame geometry
var videoInfo = new VideoFrameInfoX(1920, 1080, new VideoFrameRate(30));

// background image fills the full frame; the video is squeezed into the corner
var imageRect = new Rect(0, 0, 1920, 1080);     // left, top, right, bottom
var videoRect = new Rect(1280, 720, 1920, 1080);

var squeezeback = new SqueezebackBlockV2(pipeline, videoInfo, "background.png", imageRect, videoRect, videoOnTop: true);
pipeline.Connect(fileSource.VideoOutput, squeezeback.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(squeezeback.Output, videoRenderer.Input);

await pipeline.StartAsync();

// animate the video layer to a new position over 1 second
squeezeback.AnimateVideo(new Rect(960, 540, 1920, 1080), TimeSpan.FromSeconds(1));

// fade the video layer in and out
squeezeback.StartVideoFadeIn(TimeSpan.FromSeconds(1));
```

### Platforms

Windows.

## Video Stabilization

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

The VideoStabilization block removes camera shake from a live or recorded video stream in real time. It estimates the global inter-frame motion with sparse optical flow, smooths the camera trajectory with a causal moving-average window, and warps every frame back onto the smoothed path. Backed by the OpenCV `vfdeshake` element, so it requires the OpenCV redistributable.

### Block info

Name: VideoStabilizationBlock.

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input | Uncompressed video | 1 |
| Output | Uncompressed video | 1 |

### The sample pipeline

```
graph LR;
    UniversalSourceBlock-->VideoStabilizationBlock;
    VideoStabilizationBlock-->VideoRendererBlock;
```

### Sample code

```
var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(
    await UniversalSourceSettings.CreateAsync(@"C:\Videos\shaky.mp4", renderVideo: true, renderAudio: false));

var stabilizer = new VideoStabilizationBlock(new VideoStabilizationSettings
{
    SmoothingRadius = 20,
    CropRatio = 0.9,
});

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(source.VideoOutput, stabilizer.Input);
pipeline.Connect(stabilizer.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Sample applications

- [Video Stabilization Block documentation page](video-stabilization/)

### Platforms

Windows.

---END OF PAGE---


## Video Overlay Manager - Text, Image, PiP Layers in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/VideoProcessing/OverlayManagerBlock/
**Description:** Add text, images, shapes, and PiP overlays to live video using VisioForge Media Blocks SDK OverlayManagerBlock with real-time layer management.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, GStreamer, Playback, Streaming, Effects, Decklink, NDI Source, RTSP, NDI, MP4, GIF, C#
**API:** OverlayManagerBlock, OverlayManagerShadowSettings, VideoView, FontSettings, IVideoView, IOverlayManagerDrawable

# Overlay Manager Block usage guide

## Overview

The `OverlayManagerBlock` is a powerful MediaBlocks component that provides dynamic multi-layer video overlay composition and management. It allows you to add various overlay elements (images, text, shapes, animations) on top of video content with real-time updates, layer management, and advanced features like shadows, rotation, and opacity control.

## Key Features

- **Multiple Overlay Types**: Text, scrolling text, images, image sequences, GIFs, SVG, shapes (rectangles, circles, triangles, stars, lines), video files/URLs, live video (NDI, Decklink), WebView2 web content (Windows), WPF controls (Windows)
- **Video File Overlays**: Play video files or stream URLs as overlays with full playback control and optional audio output
- **WPF Control Overlays**: Render live WPF elements with animations and data binding as video overlays (Windows only)
- **Overlay Groups**: Synchronize multiple overlays for coordinated start/stop with preloading support
- **Squeezeback Effects**: Scale video to a custom rectangle with overlay image on top (broadcast-style)
- **Video Transformations**: Zoom and pan effects that transform the entire video frame
- **Animation Support**: Animate video position/scale with easing functions
- **Fade Effects**: Fade in/out for video and overlay elements
- **Layer Management**: Z-index ordering for proper overlay stacking
- **Advanced Effects**: Shadows, rotation, opacity, custom positioning
- **Real-time Updates**: Dynamic overlay modification during playback
- **Time-based Display**: Show/hide overlays at specific timestamps
- **Custom Drawing**: Callback support for custom Cairo drawing operations, plus a `IOverlayManagerDrawable` contract for user-defined element types
- **Live Video Sources**: Support for NDI network sources and Decklink capture cards
- **Cross-platform**: Works on Windows, Linux, macOS, iOS, and Android

## Class Reference

### OverlayManagerBlock

**Namespace**: `VisioForge.Core.MediaBlocks.VideoProcessing`

```
public class OverlayManagerBlock : MediaBlock, IMediaBlockInternals
```

#### Properties

| Property | Type | Description |
| --- | --- | --- |
| `Type` | `MediaBlockType` | Returns `MediaBlockType.OverlayManager` |
| `Input` | `MediaBlockPad` | Video input pad |
| `Output` | `MediaBlockPad` | Video output pad with overlays |

#### Methods

##### Static Methods

```
public static bool IsAvailable()
```

Checks if the overlay manager is available in the current environment (requires Cairo overlay support).

##### Instance Methods

```
public void Video_Overlay_Add(IOverlayManagerElement overlay)
```

Adds a new overlay element to the video composition.

```
public void Video_Overlay_Remove(IOverlayManagerElement overlay)
```

Removes a specific overlay element.

```
public void Video_Overlay_RemoveAt(int index)
```

Removes an overlay at the specified index.

```
public void Video_Overlay_Clear()
```

Removes all overlay elements.

```
public void Video_Overlay_Update(IOverlayManagerElement overlay)
```

Updates an existing overlay (removes and re-adds with new properties).

## Overlay Element Types

### Common Properties (IOverlayManagerElement)

All overlay elements implement the `IOverlayManagerElement` interface with these common properties:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Name` | `string` | - | Optional name for identification |
| `Enabled` | `bool` | `true` | Enable/disable the overlay |
| `StartTime` | `TimeSpan` | `Zero` | When to start showing (optional) |
| `EndTime` | `TimeSpan` | `Zero` | When to stop showing (optional); `Zero` means no end |
| `Opacity` | `double` | `1.0` | Transparency (0.0-1.0) |
| `Rotation` | `double` | `0.0` | Rotation angle in degrees (0-360) |
| `ZIndex` | `int` | `0` | Layer order (higher = on top) |
| `Shadow` | `OverlayManagerShadowSettings` | - | Shadow configuration |

Either time bound on its own defines a window. `StartTime = TimeSpan.Zero` with a non-zero `EndTime` shows the element from the beginning until that moment; a zero `EndTime` means the element has no end. Both values are compared against the frame timestamp, which counts from the pipeline start - not the wall clock.

### OverlayManagerText

Displays text with optional background and formatting.

```
public class OverlayManagerText : IOverlayManagerElement
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Text` | `string` | "Hello!!!" | Text to display |
| `TextProvider` | `Func<TimeSpan, string>` | `null` | Optional per-frame text callback; overrides `Text` |
| `X` | `int` | `100` | X of the top-left corner, in pixels. `0` is the left edge of the frame. |
| `Y` | `int` | `100` | Y of the top-left corner, in pixels. `0` is the top edge; the first line is fully visible there. |
| `Font` | `FontSettings` | System default | Font configuration |
| `Color` | `SKColor` | `Red` | Text color |
| `Background` | `IOverlayManagerBackground` | `null` | Optional background |
| `CustomWidth` | `int` | `0` | Custom bounding width (0 = auto) |
| `CustomHeight` | `int` | `0` | Custom bounding height (0 = auto) |

**Example:**

```
var text = new OverlayManagerText("Hello World!", 100, 100);
text.Color = SKColors.White;
text.Font.Size = 48;
text.Font.Name = "Arial";
text.Shadow = new OverlayManagerShadowSettings(true, depth: 5, direction: 45);
overlayManager.Video_Overlay_Add(text);
```

#### Text that changes on every frame

Text is redrawn on every frame, so there is no "apply" step and no need to remove and re-add the element. There are two ways to keep it current, and neither touches the pipeline:

**Assign `Text` whenever the value changes.** Safe from any thread; the new value appears on the next frame. Use this when the updates are driven by your own events.

```
// From a sensor callback, a UI event, a background thread - anywhere.
text.Text = $"Sensor: {reading:F1}";
```

**Set `TextProvider` when the text must be rebuilt for each frame** - a clock, a frame counter, or a template mixing several live values. The callback receives the frame timestamp, counted from the pipeline start.

```
var text = new OverlayManagerText(string.Empty, 40, 40);
text.Color = SKColors.Yellow;
text.Font.Size = 28;

text.TextProvider = ts => "Camera 1\nOperator: demo\nREC\n"
    + $"Sensor {_sensorValue:F1}   {DateTime.Now:HH:mm:ss}   {ts:hh\\:mm\\:ss}";

overlayManager.Video_Overlay_Add(text);
```

Both paths are cheap: the text layout (line splitting and measurement) is cached on the element and recomputed only when the string, font or geometry actually changes, so a value that stays the same costs nothing extra.

Three rules for `TextProvider`:

- It runs on the GStreamer streaming thread, **while the overlay list is locked** — the same lock `Video_Overlay_Add` and `Video_Overlay_Remove` take. Blocking on another thread from inside it risks a deadlock, not merely a dropped frame: calling `Dispatcher.Invoke` to read a UI value deadlocks outright if the UI thread happens to be adding or removing an overlay at that moment. Read a field the UI thread has already written, as the example above does.
- Returning `null` falls back to `Text`. A callback that throws is logged once and is then **not called again** — the element falls back to `Text`, because retrying it every frame would unwind an exception at the frame rate while the overlay lock is held. Assigning to `TextProvider` again re-enables it, including assigning the very same delegate.
- `OverlayManagerDateTime` inherits the property, and its `[DATETIME]` token is substituted into whatever the provider returned.

For anything beyond text - custom shapes, gauges, composited bitmaps - use [OverlayManagerCallback](#overlaymanagercallback), which hands you the Cairo context for the frame.

### OverlayManagerImage

Displays static images with stretch modes.

```
public class OverlayManagerImage : IOverlayManagerElement, IDisposable
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `X` | `int` | - | X position |
| `Y` | `int` | - | Y position |
| `Width` | `int` | - | Display width (0 = original) |
| `Height` | `int` | - | Display height (0 = original) |
| `StretchMode` | `OverlayManagerImageStretchMode` | `None` | Image scaling mode |

**Stretch Modes:**

- `None` - Original size
- `Stretch` - Fill target area (may distort)
- `Letterbox` - Fit within area (maintain aspect ratio)
- `CropToFill` - Fill area by cropping (maintain aspect ratio)

**Constructors:**

```
// From file
new OverlayManagerImage(string filename, int x, int y, double alpha = 1.0)

// From SkiaSharp bitmap
new OverlayManagerImage(SKBitmap image, int x, int y, double alpha = 1.0)

// From System.Drawing.Bitmap (Windows only)
new OverlayManagerImage(System.Drawing.Bitmap image, int x, int y, double alpha = 1.0)
```

**Example:**

```
var image = new OverlayManagerImage("logo.png", 10, 10);
image.StretchMode = OverlayManagerImageStretchMode.Letterbox;
image.Width = 200;
image.Height = 100;
overlayManager.Video_Overlay_Add(image);
```

### OverlayManagerGIF

Displays animated GIF images.

```
public class OverlayManagerGIF : IOverlayManagerElement, IDisposable
```

| Property | Type | Description |
| --- | --- | --- |
| `Position` | `SKPoint` | Position of the GIF |
| `AnimationLength` | `TimeSpan` | Total animation duration |

**Example:**

```
var gif = new OverlayManagerGIF("animation.gif", new SKPoint(150, 150));
overlayManager.Video_Overlay_Add(gif);
```

### OverlayManagerImageSequence

Displays a sequence of images, each shown for a specified duration, with support for looping, animation, fade effects, and all standard overlay properties.

```
public class OverlayManagerImageSequence : IOverlayManagerElement, IDisposable
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `X` | `int` | - | X position |
| `Y` | `int` | - | Y position |
| `Width` | `int` | `0` | Display width (0 = original) |
| `Height` | `int` | `0` | Display height (0 = original) |
| `Loop` | `bool` | `true` | Restart sequence after last frame |
| `StretchMode` | `OverlayManagerImageStretchMode` | `None` | Image scaling mode |
| `AnimationLength` | `TimeSpan` | - | Total duration of all frames (read-only) |
| `FrameCount` | `int` | - | Number of loaded frames (read-only) |

**Animation Properties:**

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `AnimationEnabled` | `bool` | `false` | Enable position/size animation |
| `TargetX` | `int` | `0` | Animation target X |
| `TargetY` | `int` | `0` | Animation target Y |
| `TargetWidth` | `int` | `0` | Animation target width (0 = keep current) |
| `TargetHeight` | `int` | `0` | Animation target height (0 = keep current) |
| `AnimationStartTime` | `TimeSpan` | `Zero` | Animation start time |
| `AnimationEndTime` | `TimeSpan` | `Zero` | Animation end time |
| `Easing` | `OverlayManagerPanEasing` | `Linear` | Position animation easing |

**Fade Properties:**

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `FadeEnabled` | `bool` | `false` | Enable fade animation |
| `FadeType` | `OverlayManagerFadeType` | `FadeIn` | Fade direction |
| `FadeStartTime` | `TimeSpan` | `Zero` | Fade start time |
| `FadeEndTime` | `TimeSpan` | `Zero` | Fade end time |
| `FadeEasing` | `OverlayManagerPanEasing` | `Linear` | Fade easing function |

**Constructors:**

```
// Basic: position only
new OverlayManagerImageSequence(IEnumerable<ImageSequenceItem> items, int x, int y)

// Full: position, size, and stretch mode
new OverlayManagerImageSequence(
    IEnumerable<ImageSequenceItem> items,
    int x, int y,
    int width, int height,
    OverlayManagerImageStretchMode stretchMode = None)
```

**Methods:**

```
// Add a frame dynamically during playback
void AddFrame(string filename, TimeSpan duration)

// Start position/size animation
void StartAnimation(int targetX, int targetY, int targetWidth, int targetHeight,
    TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = Linear)

// Get interpolated position/size at the given time
(int X, int Y, int Width, int Height) GetCurrentRect(TimeSpan currentTime)

// Fade effects
void StartFadeIn(TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = Linear)
void StartFadeOut(TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = Linear)
double GetCurrentOpacity(TimeSpan currentTime)
```

**Example - Basic Image Sequence:**

```
// Define images with per-frame durations
var items = new List<ImageSequenceItem>
{
    new ImageSequenceItem("slide1.png", TimeSpan.FromSeconds(3)),
    new ImageSequenceItem("slide2.png", TimeSpan.FromSeconds(2)),
    new ImageSequenceItem("slide3.png", TimeSpan.FromSeconds(4))
};

// Create sequence at position (100, 100), scaled to 320x240
var sequence = new OverlayManagerImageSequence(items, 100, 100, 320, 240)
{
    Loop = true,
    Opacity = 0.9,
    ZIndex = 5,
    Name = "SlideShow"
};

overlayManager.Video_Overlay_Add(sequence);
```

**Example - With Animation and Fade:**

```
// Animate the sequence from top-left to center over 3 seconds
sequence.StartAnimation(
    targetX: 400, targetY: 200,
    targetWidth: 640, targetHeight: 480,
    startTime: TimeSpan.FromSeconds(2),
    duration: TimeSpan.FromSeconds(3),
    easing: OverlayManagerPanEasing.EaseInOut);

// Fade in over the first 1.5 seconds
sequence.StartFadeIn(
    startTime: TimeSpan.Zero,
    duration: TimeSpan.FromSeconds(1.5),
    easing: OverlayManagerPanEasing.EaseOut);
```

**Example - Add Frames Dynamically:**

```
// Add a new frame to a running sequence
sequence.AddFrame("slide4.png", TimeSpan.FromSeconds(2.5));
```

**Convenience Methods on OverlayManagerBlock:**

```
// Add image sequence overlay
var element = overlayManager.Video_Overlay_AddImageSequence(
    items, x: 100, y: 100, width: 320, height: 240,
    loop: true, name: "SlideShow");

// Update position
overlayManager.Video_Overlay_UpdateImageSequencePosition(
    "SlideShow", x: 200, y: 150, width: 400, height: 300);

// Animate position/size
overlayManager.Video_Overlay_AnimateImageSequence(
    "SlideShow", targetX: 500, targetY: 300, targetWidth: 640, targetHeight: 480,
    startTime: currentPosition, duration: TimeSpan.FromSeconds(2),
    easing: OverlayManagerPanEasing.EaseInOut);

// Fade effects
overlayManager.Video_Overlay_ImageSequenceFadeIn(
    "SlideShow", startTime: currentPosition, duration: TimeSpan.FromSeconds(1));
overlayManager.Video_Overlay_ImageSequenceFadeOut(
    "SlideShow", startTime: currentPosition, duration: TimeSpan.FromSeconds(1));
```

#### ImageSequenceItem

Represents a single image frame in an image sequence.

```
public class ImageSequenceItem
```

| Property | Type | Description |
| --- | --- | --- |
| `Filename` | `string` | Full path to the image file |
| `Duration` | `TimeSpan` | How long this image is displayed |

```
// Constructors
new ImageSequenceItem()
new ImageSequenceItem(string filename, TimeSpan duration)
```

### OverlayManagerDateTime

Displays current date/time with custom formatting.

```
public class OverlayManagerDateTime : IOverlayManagerElement
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Text` | `string` | "[DATETIME]" | Text template |
| `Format` | `string` | "MM/dd/yyyy HHss" | DateTime format |
| `X` | `int` | `100` | X position |
| `Y` | `int` | `100` | Y position |
| `Font` | `FontSettings` | System default | Font configuration |
| `Color` | `SKColor` | `Red` | Text color |

**Example:**

```
var dateTime = new OverlayManagerDateTime();
dateTime.Format = "yyyy-MM-dd HH:mm:ss";
dateTime.X = 10;
dateTime.Y = 30;
overlayManager.Video_Overlay_Add(dateTime);
```

### OverlayManagerScrollingText

Displays scrolling text that moves across the video in a specified direction.

```
public class OverlayManagerScrollingText : IOverlayManagerElement
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Text` | `string` | "Scrolling Text" | Text to display |
| `X` | `int` | `0` | X position of the scrolling area |
| `Y` | `int` | `100` | Y position of the scrolling area |
| `Width` | `int` | `0` | Width of scrolling area (0 = uses DefaultWidth) |
| `Height` | `int` | `0` | Height of scrolling area (0 = auto based on font) |
| `DefaultWidth` | `int` | `1920` | Default width when Width is 0 (set to video width) |
| `DefaultHeight` | `int` | `1080` | Default height when Height is 0 for vertical scroll |
| `Speed` | `int` | `5` | Scrolling speed in pixels per frame |
| `Direction` | `ScrollDirection` | `RightToLeft` | Scroll direction |
| `Font` | `FontSettings` | System default | Font configuration |
| `Color` | `SKColor` | `White` | Text color |
| `BackgroundTransparent` | `bool` | `true` | Whether background is transparent |
| `BackgroundColor` | `SKColor` | `Black` | Background color (when not transparent) |
| `Infinite` | `bool` | `true` | Loop scrolling infinitely |
| `TextRestarted` | `EventHandler` | `null` | Called when text loops back to start |

**ScrollDirection Enum:**

- `LeftToRight` - Text scrolls from left to right
- `RightToLeft` - Text scrolls from right to left
- `BottomToTop` - Text scrolls from bottom to top
- `TopToBottom` - Text scrolls from top to bottom

**Example:**

```
// Create a news ticker style scrolling text
var scrollingText = new OverlayManagerScrollingText(
    "Breaking News: VisioForge Media Framework now supports scrolling text overlays!",
    x: 0,
    y: 50,
    speed: 3,
    direction: ScrollDirection.RightToLeft);

scrollingText.Font.Size = 24;
scrollingText.Color = SKColors.Yellow;
scrollingText.BackgroundTransparent = false;
scrollingText.BackgroundColor = SKColors.DarkBlue;

// Set the default width to match your video resolution
// This is used when Width is not explicitly set
scrollingText.DefaultWidth = 1920; // Full HD width

// Or set Width directly for a specific scrolling area width
// scrollingText.Width = 1920;

// Add event handler for when text loops
scrollingText.TextRestarted += (sender, e) => {
    Console.WriteLine("Scrolling text restarted");
};

overlayManager.Video_Overlay_Add(scrollingText);

// To reset scrolling position
scrollingText.Reset();

// To update after changing text or font
scrollingText.Text = "Updated news text...";
scrollingText.Update();
```

### Video Overlays

The Overlay Manager supports video overlays from multiple sources, including video files/URLs, Decklink capture cards, and NDI network sources. Video overlays play within the overlay composition with full playback control.

#### OverlayManagerVideo

Plays video files or stream URLs as overlays on the video composition. Each video overlay runs its own internal playback pipeline with optional audio output.

```
public class OverlayManagerVideo : IOverlayManagerElement, IDisposable
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Source` | `string` | - | Video source file path or URL |
| `X` | `int` | - | X position |
| `Y` | `int` | - | Y position |
| `Width` | `int` | - | Overlay width |
| `Height` | `int` | - | Overlay height |
| `Loop` | `bool` | `true` | Whether the video loops |
| `PlaybackRate` | `double` | `1.0` | Playback speed (1.0 = normal) |
| `StretchMode` | `OverlayManagerImageStretchMode` | `Letterbox` | How to fit video |
| `VideoView` | `IVideoView` | `null` | Optional external video preview window |
| `VideoRendererSettings` | `VideoRendererSettingsX` | `null` | Renderer settings for VideoView |
| `AudioOutput` | `AudioOutputDeviceInfo` | `null` | Audio output device (null = discard audio) |
| `AudioOutput_Volume` | `double` | `1.0` | Audio volume (0.0-1.0+, above 1.0 amplifies) |
| `AudioOutput_Mute` | `bool` | `false` | Mute audio output |

**Methods:**

- `Initialize(bool autoStart)` - Initialize the video pipeline. If `autoStart` is true, begins playing immediately; if false, preloads to PAUSED state.
- `Play()` - Start or resume video playback
- `Pause()` - Pause video playback
- `Stop()` - Stop video playback
- `Seek(TimeSpan position)` - Seek to a specific position in the video
- `UpdateSource(string source)` - Change the video source dynamically
- `Dispose()` - Clean up resources

**Example - Video File Overlay:**

```
// Create a video file overlay
var videoOverlay = new OverlayManagerVideo(
    source: "intro.mp4",
    x: 100,
    y: 100,
    width: 640,
    height: 360)
{
    Loop = true,
    Opacity = 0.9,
    StretchMode = OverlayManagerImageStretchMode.Letterbox,
    ZIndex = 5
};

// Optionally enable audio output
var audioOutputs = await AudioRendererBlock.GetDevicesAsync(AudioOutputDeviceAPI.DirectSound);
videoOverlay.AudioOutput = audioOutputs[0];
videoOverlay.AudioOutput_Volume = 0.5;

// Initialize and add to overlay manager
if (videoOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(videoOverlay);
}

// Control playback at runtime
videoOverlay.Pause();
videoOverlay.Seek(TimeSpan.FromSeconds(10));
videoOverlay.Play();

// Change source dynamically
videoOverlay.UpdateSource("outro.mp4");

// Clean up when done
videoOverlay.Stop();
videoOverlay.Dispose();
```

**Example - Picture-in-Picture:**

```
// Create a small PiP video in the corner
var pipVideo = new OverlayManagerVideo(
    source: "camera_feed.mp4",
    x: 20,
    y: 20,
    width: 240,
    height: 135)
{
    Loop = true,
    Opacity = 0.9,
    StretchMode = OverlayManagerImageStretchMode.Letterbox,
    ZIndex = 100,
    Shadow = new OverlayManagerShadowSettings
    {
        Enabled = true,
        Color = SKColors.DarkGray,
        Opacity = 0.7,
        BlurRadius = 8,
        Depth = 3,
        Direction = 45
    }
};

if (pipVideo.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(pipVideo);
}
```

**Example - Stream URL Overlay:**

```
// Overlay a network stream
var streamOverlay = new OverlayManagerVideo(
    source: "rtsp://192.168.1.21:554/Streaming/Channels/101",
    x: 400,
    y: 50,
    width: 320,
    height: 240)
{
    Loop = false,
    StretchMode = OverlayManagerImageStretchMode.Letterbox,
    ZIndex = 10
};

if (streamOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(streamOverlay);
}
```

#### OverlayManagerDecklinkVideo

Captures and displays video from Blackmagic Decklink capture cards.

```
public class OverlayManagerDecklinkVideo : IOverlayManagerElement
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `DecklinkSettings` | `DecklinkVideoSourceSettings` | - | Decklink device configuration |
| `X` | `int` | - | X position |
| `Y` | `int` | - | Y position |
| `Width` | `int` | - | Overlay width |
| `Height` | `int` | - | Overlay height |
| `StretchMode` | `OverlayManagerImageStretchMode` | `Letterbox` | How to fit video |
| `VideoView` | `IVideoView` | `null` | Optional video preview |
| `VideoRendererSettings` | `VideoRendererSettingsX` | `null` | Renderer settings |

**Example:**

```
// Get Decklink devices
var devices = await DecklinkVideoSourceBlock.GetDevicesAsync();
var decklinkSettings = new DecklinkVideoSourceSettings(devices[0]);
decklinkSettings.Mode = DecklinkMode.HD1080p2997;

// Create Decklink overlay
var decklinkOverlay = new OverlayManagerDecklinkVideo(
    decklinkSettings,
    x: 10,
    y: 10,
    width: 640,
    height: 360);

// Initialize and add to overlay manager
if (decklinkOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(decklinkOverlay);
}

// Clean up when done
decklinkOverlay.Stop();
decklinkOverlay.Dispose();
```

#### OverlayManagerNDIVideo

Captures and displays video from NDI (Network Device Interface) sources.

```
public class OverlayManagerNDIVideo : IOverlayManagerElement
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `NDISettings` | `NDISourceSettings` | - | NDI source configuration |
| `X` | `int` | - | X position |
| `Y` | `int` | - | Y position |
| `Width` | `int` | - | Overlay width |
| `Height` | `int` | - | Overlay height |
| `StretchMode` | `OverlayManagerImageStretchMode` | `Letterbox` | How to fit video |
| `VideoView` | `IVideoView` | `null` | Optional video preview |
| `VideoRendererSettings` | `VideoRendererSettingsX` | `null` | Renderer settings |

**Example:**

```
// Discover NDI sources on the network
var ndiSources = await DeviceEnumerator.Shared.NDISourcesAsync();
var ndiSettings = await NDISourceSettings.CreateAsync(
    null,
    ndiSources[0].Name,
    ndiSources[0].URL);

// Create NDI overlay
var ndiOverlay = new OverlayManagerNDIVideo(
    ndiSettings,
    x: 10,
    y: 10,
    width: 640,
    height: 360);

// Initialize and add to overlay manager
if (ndiOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(ndiOverlay);
}

// Clean up when done
ndiOverlay.Stop();
ndiOverlay.Dispose();
```

**Common Methods for Video Overlays:**

- `Initialize(bool autoStart)` - Initialize the video pipeline
- `Play()` - Start or resume video playback/capture
- `Pause()` - Pause video playback/capture
- `Stop()` - Stop video playback/capture
- `Dispose()` - Clean up resources

**Additional Methods (OverlayManagerVideo only):**

- `Seek(TimeSpan position)` - Seek to a specific position
- `UpdateSource(string source)` - Change the video source dynamically

### OverlayManagerWPFControl (Windows Only)

Renders a WPF `FrameworkElement` as a video overlay. This enables using any WPF visual tree — including controls with Storyboard animations, data binding, and complex layouts — as an overlay. The element is periodically snapshot at a configurable refresh rate.

> **Note**: This overlay type is only available on Windows (`NET_WINDOWS` build target).

```
public class OverlayManagerWPFControl : IOverlayManagerElement, IDisposable
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `ElementFactory` | `Func<FrameworkElement>` | - | Factory that creates the WPF element on the internal STA thread |
| `X` | `int` | - | X position |
| `Y` | `int` | - | Y position |
| `Width` | `int` | - | Overlay width (must be > 0) |
| `Height` | `int` | - | Overlay height (must be > 0) |
| `StretchMode` | `OverlayManagerImageStretchMode` | `Stretch` | How to fit the rendered control |
| `RefreshRate` | `int` | `15` | Snapshots per second (1-60) |
| `Dpi` | `double` | `96` | DPI for rendering |

**Methods:**

- `Initialize()` - Initialize the WPF control overlay and start periodic rendering
- `InvokeOnUIThread(Action action)` - Execute an action on the WPF STA thread for safe runtime updates
- `InvokeOnUIThread<T>(Func<T> func)` - Execute a function on the WPF STA thread and return the result
- `Dispose()` - Clean up resources

**Convenience Method on OverlayManagerBlock:**

```
public OverlayManagerWPFControl Video_Overlay_AddWPFControl(
    Func<FrameworkElement> elementFactory,
    int x, int y, int width, int height,
    int refreshRate = 15,
    string name = null)
```

Creates, initializes, and adds a WPF control overlay in one call. Returns the overlay instance, or `null` if initialization failed.

**Example - Using Convenience Method:**

```
// Add a color-cycling text overlay using the convenience method
var wpfOverlay = overlayManager.Video_Overlay_AddWPFControl(
    elementFactory: () =>
    {
        var border = new Border
        {
            Width = 350,
            Height = 60,
            Background = new SolidColorBrush(Color.FromArgb(160, 0, 0, 0)),
            CornerRadius = new CornerRadius(8),
            Padding = new Thickness(15, 5, 15, 5)
        };

        var text = new TextBlock
        {
            Text = "VisioForge Media Framework",
            FontSize = 28,
            FontWeight = FontWeights.Bold,
            VerticalAlignment = VerticalAlignment.Center,
            HorizontalAlignment = HorizontalAlignment.Center
        };

        var brush = new SolidColorBrush(Colors.Red);
        text.Foreground = brush;
        border.Child = text;

        // Animate text color
        var colorAnim = new ColorAnimationUsingKeyFrames
        {
            Duration = TimeSpan.FromSeconds(5),
            RepeatBehavior = RepeatBehavior.Forever
        };
        colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Red, KeyTime.FromPercent(0.0)));
        colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Gold, KeyTime.FromPercent(0.25)));
        colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Cyan, KeyTime.FromPercent(0.5)));
        colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Magenta, KeyTime.FromPercent(0.75)));
        colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Red, KeyTime.FromPercent(1.0)));
        brush.BeginAnimation(SolidColorBrush.ColorProperty, colorAnim);

        return border;
    },
    x: 50, y: 300, width: 350, height: 60,
    refreshRate: 30, name: "ColorText");

if (wpfOverlay == null)
{
    // Initialization failed
}
```

**Example - Manual Creation with Animated Clock:**

```
// Create a WPF analog clock overlay manually
var clockOverlay = new OverlayManagerWPFControl(
    elementFactory: () =>
    {
        var canvas = new Canvas { Width = 200, Height = 200 };

        // Clock face
        var face = new Ellipse
        {
            Width = 180, Height = 180,
            Stroke = Brushes.White, StrokeThickness = 3
        };
        Canvas.SetLeft(face, 10);
        Canvas.SetTop(face, 10);
        canvas.Children.Add(face);

        // Second hand with rotation animation
        var secondHand = new Line
        {
            X1 = 100, Y1 = 100, X2 = 100, Y2 = 25,
            Stroke = Brushes.Red, StrokeThickness = 1
        };
        var secondRotate = new RotateTransform(DateTime.Now.Second * 6, 100, 100);
        secondHand.RenderTransform = secondRotate;
        canvas.Children.Add(secondHand);

        var anim = new DoubleAnimation
        {
            From = DateTime.Now.Second * 6,
            To = DateTime.Now.Second * 6 + 360,
            Duration = TimeSpan.FromSeconds(60),
            RepeatBehavior = RepeatBehavior.Forever
        };
        secondRotate.BeginAnimation(RotateTransform.AngleProperty, anim);

        return canvas;
    },
    x: 20, y: 20, width: 200, height: 200, refreshRate: 30);

if (clockOverlay.Initialize())
{
    overlayManager.Video_Overlay_Add(clockOverlay);
}

// Update WPF control at runtime (thread-safe)
clockOverlay.InvokeOnUIThread(() =>
{
    // Safe to modify WPF elements here
});

// Clean up
clockOverlay.Dispose();
```

### OverlayManagerWebView2Video (Windows Only)

Renders live web content (HTML, CSS, JavaScript) as a video overlay using Microsoft WebView2. This enables displaying web pages, dynamic HTML dashboards, animated web content, news tickers, or any browser-rendered content as an overlay on your video. The web page is rendered offscreen and captured as video frames at the browser's native refresh rate.

> **Note**: This overlay type is only available on Windows (`NET_WINDOWS` build target). Requires the Microsoft WebView2 Runtime and the GStreamer WebView2 plugin (`webview2src`).

```
public class OverlayManagerWebView2Video : IOverlayManagerElement, IDisposable
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Location` | `string` | `"about:blank"` | URL to display in the overlay |
| `JavaScript` | `string` | `null` | JavaScript code to execute after each navigation completes |
| `Adapter` | `int` | `-1` | DXGI adapter index for GPU selection (-1 = any available device) |
| `UserDataFolder` | `string` | `null` | Absolute path to WebView2 user data folder for cache and profile data |
| `X` | `int` | - | X position |
| `Y` | `int` | - | Y position |
| `Width` | `int` | - | Overlay width |
| `Height` | `int` | - | Overlay height |
| `StretchMode` | `OverlayManagerImageStretchMode` | `Letterbox` | How to fit the rendered content |
| `VideoView` | `IVideoView` | `null` | Optional external video preview window |
| `VideoRendererSettings` | `VideoRendererSettingsX` | `null` | Renderer settings for VideoView |

**Methods:**

- `Initialize(bool autoStart = true)` - Initialize the WebView2 rendering pipeline. If `autoStart` is true, begins rendering immediately; if false, preloads to PAUSED state. Returns `true` if successful.
- `Play()` - Start or resume web page rendering
- `Pause()` - Pause web page rendering
- `Stop()` - Stop web page rendering
- `UpdateLocation(string location)` - Change the displayed URL dynamically
- `Dispose()` - Clean up resources

**Example - Basic Web Page Overlay:**

```
// Display a web page as a video overlay
var webOverlay = new OverlayManagerWebView2Video(
    location: "https://example.com/dashboard",
    x: 50,
    y: 50,
    width: 640,
    height: 480)
{
    Opacity = 0.9,
    StretchMode = OverlayManagerImageStretchMode.Letterbox,
    ZIndex = 5
};

// Initialize and add to overlay manager
if (webOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(webOverlay);
}
else
{
    webOverlay.Dispose();
}
```

**Example - Web Overlay with JavaScript Injection:**

```
// Overlay a web page and inject JavaScript to customize it
var tickerOverlay = new OverlayManagerWebView2Video(
    location: "https://example.com/ticker",
    x: 0,
    y: 680,
    width: 1920,
    height: 40)
{
    // JavaScript runs after each navigation completes
    JavaScript = "document.body.style.background = 'transparent';",
    Opacity = 0.8,
    ZIndex = 10,
    Shadow = new OverlayManagerShadowSettings
    {
        Enabled = true,
        Color = SKColors.Black,
        Opacity = 0.5,
        BlurRadius = 5,
        Depth = 5,
        Direction = 45
    }
};

if (tickerOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(tickerOverlay);
}
```

**Example - Dynamic URL Update at Runtime:**

```
// Change the displayed page at runtime
webOverlay.UpdateLocation("https://example.com/new-page");

// Control rendering
webOverlay.Pause();
webOverlay.Play();

// Clean up when done
webOverlay.Stop();
webOverlay.Dispose();
```

### Shape Overlays

#### OverlayManagerLine

```
public class OverlayManagerLine : IOverlayManagerElement
```

| Property | Type | Description |
| --- | --- | --- |
| `Start` | `SKPoint` | Line start point |
| `End` | `SKPoint` | Line end point |
| `Color` | `SKColor` | Line color |

#### OverlayManagerRectangle

```
public class OverlayManagerRectangle : IOverlayManagerElement
```

| Property | Type | Description |
| --- | --- | --- |
| `Rectangle` | `SKRect` | Rectangle bounds |
| `Color` | `SKColor` | Fill/stroke color |
| `Fill` | `bool` | Fill or stroke only |

#### OverlayManagerCircle

```
public class OverlayManagerCircle : IOverlayManagerElement
```

| Property | Type | Description |
| --- | --- | --- |
| `Center` | `SKPoint` | Circle center |
| `Radius` | `double` | Circle radius |
| `Color` | `SKColor` | Fill/stroke color |
| `Fill` | `bool` | Fill or stroke only |

#### OverlayManagerTriangle

```
public class OverlayManagerTriangle : IOverlayManagerElement
```

| Property | Type | Description |
| --- | --- | --- |
| `Point1` | `SKPoint` | First vertex |
| `Point2` | `SKPoint` | Second vertex |
| `Point3` | `SKPoint` | Third vertex |
| `Color` | `SKColor` | Fill/stroke color |
| `Fill` | `bool` | Fill or stroke only |

#### OverlayManagerStar

```
public class OverlayManagerStar : IOverlayManagerElement
```

| Property | Type | Description |
| --- | --- | --- |
| `Center` | `SKPoint` | Star center |
| `OuterRadius` | `double` | Outer points radius |
| `InnerRadius` | `double` | Inner points radius |
| `StrokeColor` | `SKColor` | Stroke color |
| `FillColor` | `SKColor` | Fill color |

### OverlayManagerSVG

Displays SVG vector graphics.

```
public class OverlayManagerSVG : IOverlayManagerElement, IDisposable
```

| Property | Type | Description |
| --- | --- | --- |
| `X` | `int` | X position |
| `Y` | `int` | Y position |
| `Width` | `int` | Display width |
| `Height` | `int` | Display height |

### OverlayManagerCallback

Custom drawing using Cairo graphics.

```
public class OverlayManagerCallback : IOverlayManagerElement
```

**Event:**

```
public event EventHandler<OverlayManagerCallbackEventArgs> OnDraw;
```

**Example:**

```
var callback = new OverlayManagerCallback();
callback.OnDraw += (sender, e) => {
    var ctx = e.Context;
    ctx.SetSourceRGB(1, 0, 0);
    ctx.Arc(200, 200, 50, 0, 2 * Math.PI);
    ctx.Fill();
};
overlayManager.Video_Overlay_Add(callback);
```

### IOverlayManagerDrawable

The extension point for a user-defined overlay element. `Video_Overlay_Add` accepts any `IOverlayManagerElement`, but only the built-in element types are drawn automatically. A custom type that implements `IOverlayManagerDrawable` is handed the live Cairo context of the frame — the same way `OverlayManagerCallback` is — instead of being silently skipped.

```
public interface IOverlayManagerDrawable
{
    void Draw(OverlayManagerCallbackEventArgs e);
}
```

An element that implements `IOverlayManagerElement` but neither this interface nor a built-in type is not drawn and is reported once in the log.

`Draw` runs on the GStreamer streaming thread **while the overlay list is locked** — the same lock `Video_Overlay_Add` and `Video_Overlay_Remove` take. Keep it short and do not block: calling back into a UI dispatcher from it can deadlock rather than merely drop a frame. An exception thrown from `Draw` is reported once, and the element is still drawn on later frames.

**Example:**

```
public class MyOverlay : IOverlayManagerElement, IOverlayManagerDrawable
{
    public string Name { get; set; } = "MyOverlay";
    public object Cache { get; set; }
    public TimeSpan StartTime { get; set; }
    public TimeSpan EndTime { get; set; }
    public bool Enabled { get; set; } = true;
    public OverlayManagerShadowSettings Shadow { get; set; } = new OverlayManagerShadowSettings();
    public double Opacity { get; set; } = 1.0;
    public double Rotation { get; set; }
    public int ZIndex { get; set; }

    public void Draw(OverlayManagerCallbackEventArgs e)
    {
        var ctx = e.Context;
        ctx.SetSourceRGB(1, 0, 0);
        ctx.Arc(200, 200, 50, 0, 2 * Math.PI);
        ctx.Fill();
    }
}

overlayManager.Video_Overlay_Add(new MyOverlay());
```

`OverlayManagerCallbackEventArgs` exposes the `Context` (`Cairo.Context`) for the frame plus its `Timestamp` and `Duration`, and a `DrawImage` helper that reuses the element's `Rotation`, `Shadow` and `Opacity`.

### OverlayManagerGroup

Groups multiple overlays for synchronized lifecycle management. This is especially useful when you need to preload multiple video overlays and start them at exactly the same time.

```
public class OverlayManagerGroup : IOverlayManagerElement, IDisposable
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Overlays` | `List<IOverlayManagerElement>` | Empty list | Overlays in this group (read-only) |

> **Note**: The standard `IOverlayManagerElement` properties (`Opacity`, `Rotation`, `ZIndex`, `Shadow`) are present on the group but not applied at the group level — individual overlay properties within the group are used for rendering.

**Methods:**

- `Add(IOverlayManagerElement overlay)` - Add an overlay to the group. Throws `InvalidOperationException` if already initialized.
- `Remove(IOverlayManagerElement overlay)` - Remove an overlay from the group. Throws `InvalidOperationException` if already initialized.
- `Initialize()` - Preload all `OverlayManagerVideo` overlays in the group to PAUSED state. Returns `true` if all succeeded. Other overlay types (Decklink, NDI) must be initialized manually.
- `Play()` - Start all `OverlayManagerVideo` overlays synchronously. Must call `Initialize()` first. Other video overlay types must call `Play()` individually.
- `Pause()` - Pause all `OverlayManagerVideo` overlays in the group.
- `Stop()` - Stop all `OverlayManagerVideo` overlays in the group.
- `GetRenderableOverlays()` - Returns all enabled overlays in the group (used internally).
- `Dispose()` - Stop and dispose all overlays in the group.

> **Important**: You cannot add or remove overlays after `Initialize()` has been called.

**Why add non-video overlays to a group?** While `Initialize()`, `Play()`, `Pause()`, and `Stop()` only control `OverlayManagerVideo` instances, adding other overlay types (Decklink, NDI, text, images) to a group provides organizational grouping for rendering and centralized disposal — `Dispose()` cleans up **all** overlays in the group regardless of type.

**Example - Synchronized Video + Decklink Group:**

```
// Create a group for overlays that must start simultaneously
var group = new OverlayManagerGroup("SyncGroup");

// Add a video file overlay
var videoOverlay = new OverlayManagerVideo(
    source: "intro.mp4",
    x: 10, y: 10, width: 640, height: 360)
{
    Loop = true,
    ZIndex = 10
};
group.Add(videoOverlay);

// Add a Decklink capture overlay
var decklinkSettings = new DecklinkVideoSourceSettings(deviceNumber);
decklinkSettings.Mode = DecklinkMode.HD1080p2997;

var decklinkOverlay = new OverlayManagerDecklinkVideo(
    settings: decklinkSettings,
    x: 660, y: 10, width: 640, height: 360)
{
    ZIndex = 11
};

// Initialize Decklink manually (group handles OverlayManagerVideo only)
decklinkOverlay.Initialize(autoStart: false);
group.Add(decklinkOverlay);

// You can also mix in non-video overlays
var label = new OverlayManagerText("Camera 1", 10, 380);
label.Font.Size = 14;
label.Color = SKColors.White;
group.Add(label);

// Add group to overlay manager
overlayManager.Video_Overlay_Add(group);

// Start all OverlayManagerVideo overlays in the group
group.Play();
// Decklink must be started separately (group.Play() only handles OverlayManagerVideo)
decklinkOverlay.Play();

// Later, pause/stop all at once
group.Pause();
group.Stop();

// Clean up
group.Dispose();
```

## Video Transformation Effects

The OverlayManagerBlock supports advanced video transformation effects that modify the entire video frame, not just overlays on top.

### OverlayManagerZoom

Applies a zoom effect to the video frame, scaling from a center point.

```
public class OverlayManagerZoom : IOverlayManagerElement
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `ZoomFactor` | `double` | `1.0` | Zoom level (1.0 = no zoom, 2.0 = 2x zoom) |
| `CenterX` | `double` | `0.5` | Horizontal center (0.0-1.0, relative to frame) |
| `CenterY` | `double` | `0.5` | Vertical center (0.0-1.0, relative to frame) |
| `InterpolationMode` | `OverlayManagerInterpolationMode` | `Bilinear` | Quality/speed tradeoff |

**Example:**

```
// Create a 1.5x zoom centered on the frame
var zoom = new OverlayManagerZoom
{
    ZoomFactor = 1.5,
    CenterX = 0.5,
    CenterY = 0.5,
    Name = "VideoZoom"
};
zoom.ZIndex = -1000; // Process before other overlays
overlayManager.Video_Overlay_Add(zoom);

// Animate zoom over time
zoom.ZoomFactor = 2.0; // Update dynamically
```

### OverlayManagerPan

Applies a pan (translate) effect to the video frame.

```
public class OverlayManagerPan : IOverlayManagerElement
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `OffsetX` | `double` | `0.0` | Horizontal offset in pixels |
| `OffsetY` | `double` | `0.0` | Vertical offset in pixels |
| `InterpolationMode` | `OverlayManagerInterpolationMode` | `Bilinear` | Quality/speed tradeoff |

**Example:**

```
// Pan video 100 pixels right and 50 pixels down
var pan = new OverlayManagerPan
{
    OffsetX = 100,
    OffsetY = 50,
    Name = "VideoPan"
};
pan.ZIndex = -1000; // Process before other overlays
overlayManager.Video_Overlay_Add(pan);
```

### OverlayManagerFade

Applies a fade effect to the entire video frame.

```
public class OverlayManagerFade : IOverlayManagerElement
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `FadeMode` | `OverlayManagerFadeMode` | `None` | Fade type (None, FadeIn, FadeOut) |
| `StartTime` | `TimeSpan` | `Zero` | When fade effect starts |
| `Duration` | `TimeSpan` | `1 second` | How long the fade takes |
| `MinOpacity` | `double` | `0.0` | Minimum opacity (fully faded) |
| `MaxOpacity` | `double` | `1.0` | Maximum opacity (fully visible) |

**Example:**

```
// Fade in video over 2 seconds starting at playback position
var fade = new OverlayManagerFade
{
    FadeMode = OverlayManagerFadeMode.FadeIn,
    StartTime = TimeSpan.Zero,
    Duration = TimeSpan.FromSeconds(2),
    Name = "VideoFade"
};
overlayManager.Video_Overlay_Add(fade);
```

### OverlayManagerSqueezeback

Creates a broadcast-style "squeezeback" effect where the video is scaled to a custom rectangle and an overlay image (typically PNG with alpha transparency) is drawn on top. This is commonly used for lower-thirds, frames, and broadcast graphics.

```
public class OverlayManagerSqueezeback : IOverlayManagerElement
```

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `BackgroundImageFilename` | `string` | - | Overlay image path (PNG with alpha recommended) |
| `VideoRect` | `Rect` | - | Where video is scaled and positioned |
| `BackgroundRect` | `Rect` | `null` | Overlay image position (null = full frame) |
| `VideoOnTop` | `bool` | `false` | Layer order (false = video below, image on top) |
| `VideoOpacity` | `double` | `1.0` | Video layer opacity |
| `BackgroundOpacity` | `double` | `1.0` | Overlay image opacity |

**Animation Properties:**

| Property | Type | Description |
| --- | --- | --- |
| `VideoAnimationEnabled` | `bool` | Enable video position animation |
| `VideoAnimationStartRect` | `Rect` | Animation start position |
| `VideoAnimationTargetRect` | `Rect` | Animation end position |
| `VideoAnimationStartTimeMs` | `double` | Animation start time (ms) |
| `VideoAnimationDurationMs` | `double` | Animation duration (ms) |
| `VideoAnimationEasing` | `OverlayManagerPanEasing` | Easing function |

**Fade Properties:**

| Property | Type | Description |
| --- | --- | --- |
| `VideoFadeMode` | `OverlayManagerFadeMode` | Video fade type |
| `VideoFadeStartTimeMs` | `double` | Video fade start time |
| `VideoFadeDurationMs` | `double` | Video fade duration |
| `BackgroundFadeMode` | `OverlayManagerFadeMode` | Background fade type |
| `BackgroundFadeStartTimeMs` | `double` | Background fade start time |
| `BackgroundFadeDurationMs` | `double` | Background fade duration |

**Example - Basic Squeezeback:**

```
// Create squeezeback with video in lower-right corner
var squeezeback = new OverlayManagerSqueezeback
{
    BackgroundImageFilename = "frame.png", // PNG with transparent center
    VideoRect = new Rect(960, 540, 1920, 1080), // Lower-right quadrant
    Name = "Squeezeback"
};
squeezeback.ZIndex = -2000; // Process first
overlayManager.Video_Overlay_Add(squeezeback);
```

**Example - Animated Squeezeback:**

```
// Get current playback position
var position = await pipeline.Position_GetAsync();

// Animate video from its current VideoRect to a corner over 2 seconds.
// AnimateVideo has no startRect — the start position is implicit (the element's
// current VideoRect), so configure it beforehand if you need a specific starting point.
var squeezeback = overlayManager.Video_Overlay_GetByName("Squeezeback") as OverlayManagerSqueezeback;
squeezeback.VideoRect = new Rect(0, 0, 1920, 1080); // Full screen starting point
squeezeback.AnimateVideo(
    targetRect: new Rect(1280, 720, 1920, 1080), // Lower-right corner
    startTime: position,
    duration: TimeSpan.FromSeconds(2),
    easing: OverlayManagerPanEasing.EaseInOut
);
```

**Example - Fade Effects:**

```
var position = await pipeline.Position_GetAsync();

// Fade out video over 1.5 seconds
squeezeback.StartVideoFadeOut(position, TimeSpan.FromSeconds(1.5));

// Later, fade it back in
squeezeback.StartVideoFadeIn(position, TimeSpan.FromSeconds(1.5));

// Fade background image independently
squeezeback.StartBackgroundFadeOut(position, TimeSpan.FromSeconds(1));
```

**Convenience Methods on OverlayManagerBlock:**

```
// Add squeezeback
var element = overlayManager.Video_Overlay_AddSqueezeback(
    backgroundImageFilename: "frame.png",
    videoRect: new Rect(960, 540, 1920, 1080),
    backgroundRect: null,  // Full frame
    name: "Squeezeback"
);

// Update video position
overlayManager.Video_Overlay_Squeezeback_UpdateVideoPosition("Squeezeback", newRect);

// Animate video (no startRect — start is the element's current VideoRect).
overlayManager.Video_Overlay_Squeezeback_AnimateVideo(
    "Squeezeback", targetRect, startTime, duration, easing);

// Fade controls
overlayManager.Video_Overlay_Squeezeback_VideoFadeIn("Squeezeback", startTime, duration);
overlayManager.Video_Overlay_Squeezeback_VideoFadeOut("Squeezeback", startTime, duration);

// Layer ordering
overlayManager.Video_Overlay_Squeezeback_SetVideoOnTop("Squeezeback");
overlayManager.Video_Overlay_Squeezeback_SetBackgroundOnTop("Squeezeback");
```

### Easing Functions

Animation easing options available via `OverlayManagerPanEasing`:

| Value | Description |
| --- | --- |
| `Linear` | Constant speed |
| `EaseIn` | Slow start, fast end |
| `EaseOut` | Fast start, slow end |
| `EaseInOut` | Slow start and end |
| `EaseInCubic` | Cubic slow start |
| `EaseOutCubic` | Cubic slow end |
| `EaseInOutCubic` | Cubic slow start and end |

### Interpolation Modes

Quality/performance tradeoff for scaling via `OverlayManagerInterpolationMode`:

| Value | Description |
| --- | --- |
| `Nearest` | Fastest, pixelated edges |
| `Bilinear` | Good quality/speed balance |
| `Gaussian` | Higher quality, slower |

## Shadow Settings

Configure drop shadows for overlay elements:

```
public class OverlayManagerShadowSettings
```

| Property | Type | Range | Default | Description |
| --- | --- | --- | --- | --- |
| `Enabled` | `bool` | - | `false` | Enable shadows |
| `Depth` | `double` | 0-30 | `5.0` | Shadow offset distance |
| `Direction` | `double` | 0-360° | `45.0` | Shadow direction |
| `Opacity` | `double` | 0-1 | `0.5` | Shadow transparency |
| `BlurRadius` | `double` | 0-10 | `2.0` | Shadow blur amount |
| `Color` | `SKColor` | - | `Black` | Shadow color |

**Direction Reference:**

- 0° = Right
- 90° = Down
- 180° = Left
- 270° = Up

## Text Backgrounds

Text overlays can have various background shapes:

### OverlayManagerBackgroundRectangle

```
var text = new OverlayManagerText("Info", 100, 100);
text.Background = new OverlayManagerBackgroundRectangle {
    Color = SKColors.Black.WithAlpha(128),
    Fill = true,
    Margin = new Rect(5, 3, 5, 3)   // Margin is a VisioForge.Core.Types.Rect (Left/Top/Right/Bottom)
};
```

### OverlayManagerBackgroundSquare

Similar to rectangle but maintains square aspect ratio.

### OverlayManagerBackgroundImage

Uses an image as text background with stretch modes.

### OverlayManagerBackgroundTriangle/Star

Custom shaped backgrounds for text.

## Font Settings

Configure text appearance:

```
public class FontSettings
```

| Property | Type | Description |
| --- | --- | --- |
| `Name` | `string` | Font family name |
| `Size` | `int` | Font size in points |
| `Style` | `FontStyle` | Normal, Italic, Oblique |
| `Weight` | `FontWeight` | Normal, Bold, Light, etc. |

## Complete Example

```
// Create pipeline and blocks
var pipeline = new MediaBlocksPipeline();
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(videoUri));
var overlayManager = new OverlayManagerBlock();
var videoRenderer = new VideoRendererBlock(pipeline, videoView);

// Connect pipeline
pipeline.Connect(fileSource.VideoOutput, overlayManager.Input);
pipeline.Connect(overlayManager.Output, videoRenderer.Input);

// Add logo watermark
var logo = new OverlayManagerImage("logo.png", 10, 10);
logo.Opacity = 0.5;
logo.ZIndex = 10; // On top
overlayManager.Video_Overlay_Add(logo);

// Add timestamp — position against the known output height (set up when the overlay manager block is configured)
const int frameHeight = 720;
var timestamp = new OverlayManagerDateTime();
timestamp.X = 10;
timestamp.Y = frameHeight - 30;
timestamp.Font.Size = 16;
timestamp.Color = SKColors.White;
timestamp.Shadow = new OverlayManagerShadowSettings(true);
overlayManager.Video_Overlay_Add(timestamp);

// Add animated title (appears after 5 seconds)
var title = new OverlayManagerText("Welcome!", 100, 100);
title.Font.Size = 72;
title.Color = SKColors.Yellow;
title.StartTime = TimeSpan.FromSeconds(5);
title.EndTime = TimeSpan.FromSeconds(10);
title.Rotation = -10; // Slight tilt
title.Background = new OverlayManagerBackgroundRectangle {
    Color = SKColors.DarkBlue,
    Fill = true
};
overlayManager.Video_Overlay_Add(title);

// Start playback
await pipeline.StartAsync();

// Update overlays dynamically
title.Text = "Updated Text!";
overlayManager.Video_Overlay_Update(title);
```

## Sample Application

For a complete working example demonstrating all overlay types, refer to:

- [Overlay Manager Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Overlay%20Manager%20Demo)

## Performance Considerations

1. **Z-Index Ordering**: Elements are sorted by Z-index before rendering. Use appropriate values to minimize sorting overhead.
2. **Image Formats**: Use RGBA8888 format images when possible to avoid color conversion.
3. **Shadow Effects**: Shadows with blur are computationally expensive. Use sparingly for real-time applications.
4. **Updates**: Use `Video_Overlay_Update()` for existing elements rather than remove/add operations.
5. **Resource Management**: Dispose image, GIF, and image sequence overlays when no longer needed to free memory.
6. **Video Overlays**: Each `OverlayManagerVideo` overlay runs its own internal GStreamer pipeline. Limit the number of simultaneous video overlays to avoid excessive CPU and memory usage.
7. **WPF Control Overlays**: Higher `RefreshRate` values increase CPU usage. Use the minimum refresh rate needed for smooth visual updates — 15 fps is sufficient for most static or slowly-changing content.
8. **WebView2 Overlays**: Each `OverlayManagerWebView2Video` overlay runs its own internal rendering pipeline with an offscreen browser. Limit the number of simultaneous WebView2 overlays to avoid excessive CPU, GPU, and memory usage.
9. **Overlay Groups**: Use `OverlayManagerGroup` to preload video overlays. This avoids staggered start times when multiple video overlays need to begin simultaneously.

## Platform Notes

- **Windows**: Supports System.Drawing.Bitmap in addition to SkiaSharp
- **Windows (WPF)**: Supports `OverlayManagerWPFControl` for rendering WPF visual elements as overlays. Requires `NET_WINDOWS` build target.
- **Windows (WebView2)**: Supports `OverlayManagerWebView2Video` for rendering live web content (HTML/CSS/JS) as overlays. Requires Microsoft WebView2 Runtime and the GStreamer WebView2 plugin (`webview2src`).
- **iOS**: Font defaults to "System-ui"
- **Android**: Font defaults to "System-ui"
- **Linux/macOS**: Enumerates available fonts at runtime

## Thread Safety

The overlay manager uses internal locking for thread-safe operations. You can safely add, remove, or update overlays from any thread.

## Troubleshooting

1. **Overlay not visible**: Check `Enabled` property, `StartTime`/`EndTime`, and `ZIndex` ordering.
2. **Text appears blurry**: Ensure font size is appropriate for video resolution.
3. **Memory usage**: Dispose unused image/GIF/image sequence overlays and use appropriate image sizes.
4. **Video overlay shows no frames**: Ensure `Initialize()` returns `true` before adding to the overlay manager. Check that the source file path is valid and accessible, and that GStreamer has the required codecs.
5. **WPF overlay not updating**: Verify `RefreshRate` is appropriate for your content. Use `InvokeOnUIThread()` for all WPF element modifications to avoid cross-thread exceptions.
6. **WebView2 overlay not rendering**: Ensure the Microsoft WebView2 Runtime is installed on the target machine. Check that `Initialize()` returns `true` before adding to the overlay manager. The GStreamer WebView2 plugin (`webview2src`) must be available.
7. **Group overlays not starting together**: Ensure all overlays are added to the group before calling `Initialize()`. Overlays cannot be added after initialization.

## Frequently Asked Questions

### How do I overlay a video file on top of another video in C#?

Use `OverlayManagerVideo` to play a video file or stream URL as an overlay. Create an instance with the source path, position, and dimensions, then call `Initialize()` and add it to the `OverlayManagerBlock`. You get full playback control with `Play()`, `Pause()`, `Stop()`, and `Seek()` methods, plus optional audio output. See the [OverlayManagerVideo](#overlaymanagervideo) section for examples.

### Can I use WPF controls as live video overlays?

Yes. `OverlayManagerWPFControl` renders any WPF `FrameworkElement` as a video overlay, including controls with Storyboard animations, data binding, and complex visual trees. The element is periodically snapshot at a configurable refresh rate (1-60 fps). This is Windows-only and requires the `NET_WINDOWS` build target. Use the convenience method `Video_Overlay_AddWPFControl()` for the simplest setup. See the [OverlayManagerWPFControl](#overlaymanagerwpfcontrol-windows-only) section.

### How do I synchronize multiple video overlays to start at the same time?

Use `OverlayManagerGroup` to group overlays that need coordinated lifecycle. Add all overlays to the group before calling `Initialize()`, which preloads video overlays to PAUSED state. Then call `Play()` to start them all simultaneously. This is especially useful for multi-camera compositions. See the [OverlayManagerGroup](#overlaymanagergroup) section.

### Can I play audio from a video file overlay?

Yes. Set the `AudioOutput` property on `OverlayManagerVideo` to an audio output device before calling `Initialize()`. Control volume with `AudioOutput_Volume` (0.0-1.0+) and mute with `AudioOutput_Mute`. If `AudioOutput` is null (the default), audio from the video file is discarded.

### What overlay types does OverlayManagerBlock support?

The OverlayManagerBlock supports: text (`OverlayManagerText`), date/time (`OverlayManagerDateTime`), scrolling text (`OverlayManagerScrollingText`), images (`OverlayManagerImage`), animated GIFs (`OverlayManagerGIF`), image sequences (`OverlayManagerImageSequence`), SVG graphics (`OverlayManagerSVG`), shapes (rectangle, circle, triangle, star, line), video files/URLs (`OverlayManagerVideo`), Decklink capture cards (`OverlayManagerDecklinkVideo`), NDI network sources (`OverlayManagerNDIVideo`), WebView2 web content (`OverlayManagerWebView2Video`, Windows only), WPF controls (`OverlayManagerWPFControl`, Windows only), overlay groups (`OverlayManagerGroup`), custom Cairo drawing (`OverlayManagerCallback`), and video transformation effects (zoom, pan, fade, squeezeback).

### Can I render live web content as a video overlay?

Yes. `OverlayManagerWebView2Video` renders any web page (HTML, CSS, JavaScript) as a video overlay using Microsoft WebView2. You can display dashboards, animated web content, tickers, or any browser-rendered content. It supports JavaScript injection after navigation for customizing the displayed page. This is Windows-only and requires the Microsoft WebView2 Runtime. See the [OverlayManagerWebView2Video](#overlaymanagerwebview2video-windows-only) section.

---END OF PAGE---


## Video Stabilization SDK for .NET — VideoStabilizationBlock
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/VideoProcessing/video-stabilization/
**Description:** Remove camera shake from live or recorded video in C# with VideoStabilizationBlock (OpenCV deshake) from the VisioForge Media Blocks SDK.
**Tags:** Media Blocks SDK, .NET, MediaBlocksPipeline, Windows, macOS, GStreamer, OpenCV, Effects, Playback, C#
**API:** VideoStabilizationBlock, VideoStabilizationSettings, UniversalSourceBlock, VideoRendererBlock, MediaBlocksPipeline

# Video Stabilization Block

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Overview

The `VideoStabilizationBlock` removes camera shake from a live or recorded video stream in real time. It estimates the global inter-frame motion (translation and rotation) with sparse optical flow, smooths the resulting camera trajectory with a causal moving-average window, and warps every frame back onto the smoothed path. A small centre zoom (crop ratio) hides the borders exposed by the compensation.

The block is backed by the OpenCV `vfdeshake` GStreamer element, so it requires the OpenCV SDK redistributable. It is currently available on Windows and macOS.

Latency is zero: only past frames are used for smoothing, so the block can be used in live pipelines.

## Key Features

- Global motion estimation (translation + rotation) via `goodFeaturesToTrack` + pyramidal Lucas-Kanade optical flow and a partial-affine RANSAC fit.
- Causal trajectory smoothing with a configurable window radius - no added frame latency.
- Automatic centre zoom (`CropRatio`) to keep the borders hidden.
- Per-frame correction limits (`MaxShift`, `MaxAngle`) as safety limiters.
- Live retuning: every property can be changed while the pipeline runs.
- Passthrough mode (`Enabled = false`) for an instant before/after comparison.

## Settings

`VideoStabilizationSettings` maps one-to-one to the element properties:

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `Enabled` | `bool` | `true` | When `false` the block passes frames through untouched. |
| `SmoothingRadius` | `int` | `15` | Number of past frames averaged when smoothing the camera trajectory. Larger = steadier, slower-reacting. Range `1` - `1000`. |
| `CropRatio` | `double` | `0.9` | Fraction of the frame kept visible. The frame is zoomed by `1 / CropRatio` around its centre to hide the exposed borders. `1.0` disables the zoom. Range `0.5` - `1.0`. |
| `MaxShift` | `int` | `100` | Maximum per-frame translation correction in pixels (safety limiter). Minimum `0`. |
| `MaxAngle` | `double` | `15` | Maximum per-frame rotation correction in degrees (safety limiter). Range `0` - `90`. |

Every property **clamps silently** to its range on assignment - an out-of-range value is corrected, not rejected, so read the property back if you need to know what was applied.

## Availability

`IsAvailable()` looks the `vfdeshake` element up in the GStreamer registry, so call it **after** the SDK has been initialized:

```
await VisioForgeX.InitSDKAsync();

if (!VideoStabilizationBlock.IsAvailable())
{
    // Add the VisioForge.CrossPlatform.OpenCV.Windows.x64 NuGet package.
}
```

## Sample code - preview a stabilized file

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.OpenCV;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.X.OpenCV;
using VisioForge.Core.Types.X.Sources;

// Initialize the SDK once at application startup before building any pipeline.
await VisioForgeX.InitSDKAsync();

var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(
    await UniversalSourceSettings.CreateAsync(@"C:\Videos\shaky.mp4", renderVideo: true, renderAudio: false));

var stabilizer = new VideoStabilizationBlock(new VideoStabilizationSettings
{
    Enabled = true,
    SmoothingRadius = 20,
    CropRatio = 0.9,
});

// VideoView1 is a VisioForge VideoView control on your form/window.
var renderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(source.VideoOutput, stabilizer.Input);
pipeline.Connect(stabilizer.Output, renderer.Input);

await pipeline.StartAsync();
```

## Sample code - stabilize and save to MP4

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.OpenCV;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.Types.X.OpenCV;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.VideoEncoders;

// Initialize the SDK once at application startup before building any pipeline.
await VisioForgeX.InitSDKAsync();

var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(
    await UniversalSourceSettings.CreateAsync(@"C:\Videos\shaky.mp4", renderVideo: true, renderAudio: false));

var stabilizer = new VideoStabilizationBlock(new VideoStabilizationSettings { CropRatio = 0.9 });

var h264 = new H264EncoderBlock(new OpenH264EncoderSettings());
var mp4 = new MP4SinkBlock(new MP4SinkSettings(@"C:\Videos\stabilized.mp4"));

pipeline.Connect(source.VideoOutput, stabilizer.Input);
pipeline.Connect(stabilizer.Output, h264.Input);
pipeline.Connect(h264.Output, mp4.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();

// The file plays to its end and the pipeline finalizes the MP4 on EOS - handle OnStop to know when.
// To end the recording EARLY, call StopAsync(): it pushes EOS so the muxer writes the moov atom.
// Killing the process instead leaves an unplayable file.
// await pipeline.StopAsync();
```

## Sample code - preview and record the stabilized output

To watch the stabilized video and record it at the same time, split the stabilizer output with a `TeeBlock`: one branch feeds the renderer, the other the H264 encoder and the MP4 sink.

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.OpenCV;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types.X.OpenCV;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.VideoEncoders;

// Initialize the SDK once at application startup before building any pipeline.
await VisioForgeX.InitSDKAsync();

var pipeline = new MediaBlocksPipeline();

var source = new UniversalSourceBlock(
    await UniversalSourceSettings.CreateAsync(@"C:\Videos\shaky.mp4", renderVideo: true, renderAudio: false));

var stabilizer = new VideoStabilizationBlock(new VideoStabilizationSettings { CropRatio = 0.9 });

var tee = new TeeBlock(2, MediaBlockPadMediaType.Video);
var renderer = new VideoRendererBlock(pipeline, VideoView1);
var h264 = new H264EncoderBlock(new OpenH264EncoderSettings());
var mp4 = new MP4SinkBlock(new MP4SinkSettings(@"C:\Videos\stabilized.mp4"));

pipeline.Connect(source.VideoOutput, stabilizer.Input);
pipeline.Connect(stabilizer.Output, tee.Input);
pipeline.Connect(tee.Outputs[0], renderer.Input);
pipeline.Connect(tee.Outputs[1], h264.Input);
pipeline.Connect(h264.Output, mp4.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();

// The file plays to its end and the pipeline finalizes the MP4 on EOS - handle OnStop to know when.
// To end the recording EARLY, call StopAsync(): it pushes EOS so the muxer writes the moov atom.
// Killing the process instead leaves an unplayable file.
// await pipeline.StopAsync();
```

## Use in the X engines

`VideoStabilizationBlock` implements `IVideoProcessingBlock`, so it can be inserted directly into the high-level X engines - `VideoCaptureCoreX` and `MediaPlayerCoreX` - with `Video_Processing_AddBlock()`. The engine wires the block into its video path for you, which means you can stabilize a **live camera** and not only a file.

Add the block **before the engine builds its pipeline**. For `VideoCaptureCoreX` that means before `StartAsync()`; for `MediaPlayerCoreX` it means before `OpenAsync()`, because the player builds its graph during Open - a block added after that is ignored (it only produces a warning in the log).

```
using VisioForge.Core;
using VisioForge.Core.MediaBlocks.OpenCV;
using VisioForge.Core.Types.X.OpenCV;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.VideoCaptureX;

// Initialize the SDK once at application startup before creating any engine.
await VisioForgeX.InitSDKAsync();

if (!VideoStabilizationBlock.IsAvailable())
{
    // Add the VisioForge.CrossPlatform.OpenCV.Windows.x64 NuGet package.
    return;
}

// Enumerate the cameras.
var cameras = await DeviceEnumerator.Shared.VideoSourcesAsync();
if (cameras.Length == 0)
{
    return;
}

// VideoView1 is a VisioForge VideoView control on your form/window.
var core = new VideoCaptureCoreX(VideoView1);

// This constructor picks an HD (or the best available) format and frame rate for the device.
core.Video_Source = new VideoCaptureDeviceSourceSettings(cameras[0]);

var stabilizer = new VideoStabilizationBlock(new VideoStabilizationSettings
{
    SmoothingRadius = 20,
    CropRatio = 0.9,
});

core.Video_Processing_AddBlock(stabilizer);

// StartAsync returns false if a block failed to build - it does not throw.
if (!await core.StartAsync())
{
    // Handle the failure: the OpenCV redistributable or the camera may be unavailable.
}
```

`ApplySettings()` works exactly the same way inside an engine: change the values on `stabilizer.Settings` and call `stabilizer.ApplySettings()` to retune the effect while the camera keeps running.

The engine owns the block

Once you pass a block to `Video_Processing_AddBlock()`, the engine owns it: it builds the block on start and **disposes it when capture or playback stops**. Do not dispose it yourself, and do not reuse the same instance for a second session - create a new block for each start. `ApplySettings()` is safe to call at any time (it is a no-op once the block has been disposed).

## Live retuning

The `vfdeshake` element re-reads its properties every frame. Change any value on the `Settings` object and call `ApplySettings()` to retune the effect without rebuilding the pipeline:

```
stabilizer.Settings.Enabled = false;      // instant before/after toggle
stabilizer.Settings.SmoothingRadius = 30; // steadier
stabilizer.Settings.CropRatio = 0.85;     // zoom in a little more
stabilizer.ApplySettings();
```

## Tips

- Increase `SmoothingRadius` for steadier results on continuous shake; decrease it if the stabilization reacts too slowly to intentional camera moves.
- Lower `CropRatio` (for example `0.85`) when the shake is large, so the wider compensation stays hidden behind the zoom. Higher values keep more of the frame but may expose the edges.
- Global motion estimation works best when the scene is dominated by the camera motion. Scenes with large moving foreground objects are harder to stabilize.

## Demos

- **[Video Stabilization Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Video%20Stabilization%20Demo)** - Media Blocks pipeline: open a file, preview the stabilized playback, optionally record it to MP4, and tune the settings live.
- **[Video Stabilization Capture X](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WPF/CSharp/Video%20Stabilization%20Capture%20X)** - live camera stabilization with `VideoCaptureCoreX` and `Video_Processing_AddBlock()`.
- **[Video Stabilization Camera Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/Video%20Stabilization%20Camera%20Demo)** - the same live camera, but built by hand as a `MediaBlocksPipeline`: camera source -> stabilizer -> renderer, with live tuning.

---END OF PAGE---


## Video Renderer in C# .NET - DirectX, OpenGL, Metal
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/VideoRendering/
**Description:** Display video in WPF, WinForms, Avalonia, and MAUI apps with hardware-accelerated rendering using VisioForge Media Blocks SDK for .NET.
**Tags:** Media Blocks SDK, .NET, Windows, macOS, Linux, Android, iOS
**API:** VideoRendererBlock, UniversalSourceBlock, VideoView, MediaBlocksPipeline, UniversalSourceSettings

# Video Renderer Block

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Overview

The Video Renderer block is an essential component designed for developers who need to display video streams in their applications. This powerful tool enables you to render video content on specific areas of windows or screens across various platforms and UI frameworks.

The block utilizes a platform-specific visual control called `VideoView` which leverages DirectX technology on Windows systems and typically implements OpenGL rendering on other platforms. The SDK fully supports cross-platform development with compatibility for both Avalonia and MAUI UI frameworks.

One of the key advantages of this block is its flexibility - developers can implement multiple video views and renderers to display the same video stream in different locations simultaneously, whether in separate sections of a window or across multiple windows.

## Rendering Technologies

### DirectX Integration

On Windows platforms, the Video Renderer Block seamlessly integrates with DirectX for high-performance hardware-accelerated rendering. This integration provides several benefits:

- **Hardware acceleration**: Utilizes the GPU for efficient video processing and rendering
- **Low-latency playback**: Minimizes delay between frame processing and display
- **Direct3D surface sharing**: Enables efficient memory management and reduced copying of video data
- **Multiple display support**: Handles rendering across various display configurations
- **Support for High DPI**: Ensures crisp rendering on high-resolution displays

The renderer automatically selects the appropriate DirectX version based on your system capabilities, supporting DirectX 11 and DirectX 12 where available.

### OpenGL Implementation

For cross-platform compatibility, the Video Renderer uses OpenGL on Linux and older macOS systems:

- **Consistent rendering API**: Provides a unified approach across different operating systems
- **Shader-based processing**: Enables advanced video effects and color transformations
- **Texture mapping optimization**: Efficiently handles video frame presentation
- **Framebuffer objects support**: Allows for off-screen rendering and complex composition
- **Hardware-accelerated scaling**: Delivers high-quality resizing with minimal performance impact

OpenGL ES variants are utilized on mobile platforms to ensure optimal performance while maintaining compatibility with the core rendering pipeline.

### Metal Framework Support

On newer Apple platforms (macOS, iOS, iPadOS), the Video Renderer can leverage Metal - Apple's modern graphics and compute API:

- **Native Apple integration**: Optimized specifically for Apple hardware
- **Reduced CPU overhead**: Minimizes processing bottlenecks compared to OpenGL
- **Enhanced parallel execution**: Better utilizes multi-core processors
- **Improved memory bandwidth**: More efficient video frame handling
- **Integration with Apple's video toolchain**: Seamless interoperability with AV Foundation and Core Video

The renderer automatically selects Metal when available on Apple platforms, falling back to OpenGL when necessary on older versions.

## Technical Specifications

### Block Information

Name: VideoRendererBlock

| Pin direction | Media type | Pins count |
| --- | --- | --- |
| Input video | uncompressed video | one or more |

## Implementation Guide

### Setting Up Your Video View

The Video View component serves as the visual element where your video content will be displayed. It needs to be properly integrated into your application's UI layout.

### Creating a Basic Pipeline

Below is a visual representation of a simple pipeline implementation:

```
graph LR;
    UniversalSourceBlock-->VideoRendererBlock;
```

This diagram illustrates how a source block connects directly to the video renderer to create a functional video playback system.

### Code Implementation Example

The following sample demonstrates how to implement a basic video rendering pipeline:

```
// Create a pipeline
var pipeline = new MediaBlocksPipeline();

// create a source block
var filename = "test.mp4";
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(filename));

// create a video renderer block
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// connect the blocks
pipeline.Connect(fileSource.VideoOutput, videoRenderer.Input);

// start the pipeline
await pipeline.StartAsync();
```

## Platform Compatibility

The Video Renderer block offers wide compatibility across multiple operating systems and devices:

- Windows
- macOS
- Linux
- iOS
- Android

This makes it an ideal solution for developers building cross-platform applications that require consistent video rendering capabilities.

---END OF PAGE---


## Direct3D 11 GPU Video Decoding and Effects in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediablocks/windows/
**Description:** Use Direct3D 11 hardware-accelerated video decoding, effects, and DirectShow integration on Windows with VisioForge Media Blocks SDK for .NET.
**Tags:** Media Blocks SDK, .NET, DirectShow, Windows, macOS, Linux, Android, iOS
**API:** D3D11H264DecoderBlock, D3D11UploadBlock, D3D11DownloadBlock, UniversalSourceBlock, UniversalSourceSettings

# Windows Platform Blocks - VisioForge Media Blocks SDK .Net

[Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

This section covers MediaBlocks specifically optimized for Windows platforms.

## Available Blocks

### Direct3D 11 Hardware Decoders

Windows provides hardware-accelerated video decoding through Direct3D 11:

- **D3D11H264DecoderBlock**: Hardware H.264/AVC decoding
- **D3D11H265DecoderBlock**: Hardware H.265/HEVC decoding
- **D3D11VP8DecoderBlock**: Hardware VP8 decoding
- **D3D11VP9DecoderBlock**: Hardware VP9 decoding
- **D3D11AV1DecoderBlock**: Hardware AV1 decoding
- **D3D11MPEG2DecoderBlock**: Hardware MPEG-2 decoding

See [Video Decoders Documentation](../VideoDecoders/)

### Direct3D 11 Processing

- **D3D11UploadBlock**: Upload video from system memory to GPU
- **D3D11DownloadBlock**: Download video from GPU to system memory
- **D3D11VideoConverterBlock**: GPU-accelerated color space conversion

See [Video Processing Documentation](../VideoProcessing/#d3d11-video-converter)

### Direct3D 11 Composition

- **D3D11VideoCompositorBlock**: GPU-accelerated video compositing and mixing

### Windows Video Effects

- **VideoEffectsWinBlock**: Windows-specific video effects
- **VR360ProcessorBlock**: 360-degree VR video processing

### Special Blocks

See [Special Blocks Documentation](../Special/)

## Platform Requirements

- **Windows**: Windows 7 SP1 or later
- **Direct3D 11**: GPU with D3D11 support
- **Hardware Decode**: GPU with hardware video decode support

## Features

- **Hardware Acceleration**: Leverage GPU for encoding, decoding, and processing
- **Direct3D 11 Integration**: Efficient video processing on GPU
- **Low CPU Usage**: Offload processing to dedicated hardware
- **High Performance**: Handle multiple HD/4K streams simultaneously
- **Power Efficiency**: Reduce power consumption with hardware acceleration

## Sample Code

### Hardware H.264 Decoding

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video.mp4"));

// D3D11 hardware decoder
var d3d11Decoder = new D3D11H264DecoderBlock();
pipeline.Connect(fileSource.VideoOutput, d3d11Decoder.Input);

// Process on GPU or download to system memory
var d3d11Download = new D3D11DownloadBlock();
pipeline.Connect(d3d11Decoder.Output, d3d11Download.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(d3d11Download.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### GPU Video Processing Pipeline

```
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video.mp4"));

// Upload to GPU
var d3d11Upload = new D3D11UploadBlock();
pipeline.Connect(fileSource.VideoOutput, d3d11Upload.Input);

// GPU color conversion
var d3d11Converter = new D3D11VideoConverterBlock();
pipeline.Connect(d3d11Upload.Output, d3d11Converter.Input);

// Download from GPU
var d3d11Download = new D3D11DownloadBlock();
pipeline.Connect(d3d11Converter.Output, d3d11Download.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(d3d11Download.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

### Video Composition

```
var pipeline = new MediaBlocksPipeline();

var source1 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video1.mp4"));
var source2 = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync("video2.mp4"));

// Upload both to GPU
var upload1 = new D3D11UploadBlock();
var upload2 = new D3D11UploadBlock();
pipeline.Connect(source1.VideoOutput, upload1.Input);
pipeline.Connect(source2.VideoOutput, upload2.Input);

// Configure the compositor — two streams on a 1920x1080 @ 30 fps canvas
var compositorSettings = new D3D11VideoCompositorSettings(1920, 1080, VideoFrameRate.FPS_30);
compositorSettings.Streams.Add(new VideoMixerStream(new Rect(0, 0, 960, 1080), zorder: 0));
compositorSettings.Streams.Add(new VideoMixerStream(new Rect(960, 0, 1920, 1080), zorder: 1));

// Composite on GPU — each added stream creates one input pad; access them via Inputs[].
var compositor = new D3D11VideoCompositorBlock(compositorSettings);
pipeline.Connect(upload1.Output, compositor.Inputs[0]);
pipeline.Connect(upload2.Output, compositor.Inputs[1]);

// Download result
var download = new D3D11DownloadBlock();
pipeline.Connect(compositor.Output, download.Input);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);
pipeline.Connect(download.Output, videoRenderer.Input);

await pipeline.StartAsync();
```

## Performance Tips

- Keep video in GPU memory between operations to avoid upload/download overhead
- Use hardware decoders when available for best performance
- Chain GPU operations together before downloading to system memory
- Monitor GPU memory usage when processing multiple streams
- Check hardware support before using D3D11 blocks

## Checking Hardware Support

```
// Check if D3D11 H.264 decoder is available
if (D3D11H264DecoderBlock.IsAvailable())
{
    // Use hardware decoder
    var decoder = new D3D11H264DecoderBlock();
}
else
{
    // Fall back to software decoder
    var decoder = new UniversalDecoderBlock(MediaBlockPadMediaType.Video);
}
```

## Platforms

Windows 7 SP1 or later (Windows 10/11 recommended for best hardware support).

## Related Documentation

- [VideoDecoders](../VideoDecoders/) - Hardware decoding blocks
- [VideoProcessing](../VideoProcessing/) - GPU processing blocks
- [Special](../Special/) - Platform-specific utilities

---END OF PAGE---


## VisioForge Media Player SDK in C# .NET — Cheat Sheet
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/cheat-sheet/
**Description:** One-page Media Player SDK reference with NuGet packages, MediaPlayerCoreX APIs, a canonical example, platform support, and pitfalls.
**Tags:** Media Player SDK, .NET, MediaPlayerCoreX, Windows, macOS, Linux, Android, iOS, Avalonia, MAUI, WPF, WinForms, GStreamer, Playback, Streaming, RTSP, HLS, MP4, H.264, H.265, AAC, C#, NuGet
**API:** MediaPlayerCoreX, VideoView, UniversalSourceSettings, AudioRendererSettings, ErrorsEventArgs

# VisioForge Media Player SDK in C# .NET — Cheat Sheet

Use VisioForge Media Player SDK .Net when you need to play local files (MP4, MKV, MOV, WebM), network streams (RTSP, HLS, MPEG-DASH), and audio (MP3, AAC, FLAC) inside a C# app on Windows, macOS, Linux, Android, or iOS. `MediaPlayerCoreX` is the primary cross-platform engine; `VideoView` is the UI control that binds the engine to the visual tree.

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Platform support

- **Windows** (x64 and x86) — WinForms, WPF, WinUI, MAUI, Avalonia, Console
- **macOS** (native and MacCatalyst) — MAUI, Avalonia, Console
- **Linux** (x64) — Avalonia, Console; requires system GStreamer 1.22+
- **Android** — via MAUI
- **iOS** — via MAUI

All cross-platform targets use a GStreamer-backed decoding pipeline with hardware acceleration where available. For the full codec × platform matrix, see [platform-matrix.md](../../platform-matrix/).

## NuGet packages

Main SDK package (always required):

```
<PackageReference Include="VisioForge.DotNet.MediaPlayer" Version="2026.2.19" />
```

Windows x64 native runtime:

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />
```

Windows x86 native runtime:

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x86" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x86" Version="2026.4.29" />
```

macOS (native) and MacCatalyst (MAUI macOS):

```
<PackageReference Include="VisioForge.CrossPlatform.Core.macOS" Version="2026.8.5" />
<PackageReference Include="VisioForge.CrossPlatform.Core.macCatalyst" Version="2026.8.5" />
```

Linux x64 (plus system GStreamer 1.22+):

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Linux.x64" Version="2025.9.0" />
```

Android and iOS:

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.7.27" />
<PackageReference Include="VisioForge.CrossPlatform.Core.iOS" Version="2025.12.0" />
```

Optional UI framework packages — add whichever you target:

```
<PackageReference Include="VisioForge.DotNet.Core.UI.MAUI" Version="2026.2.19" />
<PackageReference Include="VisioForge.DotNet.Core.UI.Avalonia" Version="2026.2.19" />
```

Full per-IDE install walkthrough: [install/index.md](../../install/).

## Primary API classes

| Class | Role | See also |
| --- | --- | --- |
| `MediaPlayerCoreX` | Main playback engine (cross-platform, GStreamer-backed) | [Quick Start](../) |
| `VideoView` | UI control that binds the player to the visual tree | [Avalonia guide](../guides/avalonia-player/) |
| `UniversalSourceSettings` | Builds a source descriptor from a URI (file, URL, stream) | [video-player-csharp.md](../guides/video-player-csharp/) |
| `AudioRendererSettings` | Configures audio output device | [video-player-csharp.md](../guides/video-player-csharp/) |
| `ErrorsEventArgs` | Error event payload surfaced via `OnError` | [video-player-csharp.md](../guides/video-player-csharp/) |

## Canonical minimum example

```
using System;
using VisioForge.Core;
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.AudioRenderers;
using VisioForge.Core.Types.X.Sources;

public partial class MainForm : Form
{
    private MediaPlayerCoreX _player;

    private async void MainForm_Load(object sender, EventArgs e)
    {
        // 1. Initialize the SDK (once per process)
        await VisioForgeX.InitSDKAsync();

        // 2. Create the player bound to a VideoView control
        _player = new MediaPlayerCoreX(VideoView1);
        _player.OnError += Player_OnError;

        // 3. (Optional) pick an audio output device
        var devices = await _player.Audio_OutputDevicesAsync(
            AudioOutputDeviceAPI.DirectSound);
        if (devices.Length > 0)
            _player.Audio_OutputDevice = new AudioRendererSettings(devices[0]);

        // 4. Build a source from a file path or stream URL
        var source = await UniversalSourceSettings.CreateAsync(
            "C:\\Videos\\sample.mp4");

        // 5. Open and play
        await _player.OpenAsync(source);
        await _player.PlayAsync();

        // Mid-playback control:
        //   await _player.PauseAsync();
        //   await _player.ResumeAsync();
        //   await _player.StopAsync();
    }

    private void Player_OnError(object sender, ErrorsEventArgs e)
    {
        Console.WriteLine($"Player error: {e.Message}");
    }

    protected override async void OnFormClosing(FormClosingEventArgs e)
    {
        // 6. Dispose the player and tear down the SDK
        if (_player != null) await _player.DisposeAsync();
        VisioForgeX.DestroySDK();
        base.OnFormClosing(e);
    }
}
```

## Typical workflow

1. Initialize the SDK with `VisioForgeX.InitSDKAsync()`.
2. Instantiate `MediaPlayerCoreX` bound to a `VideoView` (omit the view for audio-only).
3. Optionally configure audio output with `AudioRendererSettings`.
4. Create a source via `UniversalSourceSettings.CreateAsync(uri)`.
5. `OpenAsync(source)` → `PlayAsync()`; control with `PauseAsync`, `ResumeAsync`, `Position_SetAsync`, `Rate_SetAsync`, `StopAsync`.
6. Dispose the player and call `VisioForgeX.DestroySDK()` on app exit.

## Common pitfalls

- **SDK init/destroy must bracket all usage.** Forgetting `VisioForgeX.DestroySDK()` at shutdown leaks native handles and can leave GStreamer threads running. Always pair it with `InitSDKAsync()`.
- **AnyCPU on Windows needs both redistributables.** Deploy BOTH `VisioForge.CrossPlatform.Core.Windows.x86` AND `.x64` (plus the matching Libav packages) or the app will fail at runtime on whichever architecture is missing.
- **Enumerate audio devices asynchronously before assigning.** `Audio_OutputDevicesAsync(...)` must complete before you construct `AudioRendererSettings` and set `Audio_OutputDevice`; setting it against an uninitialized device list throws.
- **Linux requires system GStreamer 1.22+.** The Linux NuGet redistributable assumes system-installed GStreamer (`gstreamer1.0-*` packages) — it is NOT a substitute, and the Windows Libav packages do not apply to Linux.
- **`MediaPlayerCoreX` ≠ `MediaPlayerCore`.** `MediaPlayerCoreX` is the cross-platform GStreamer-backed engine used throughout this page. `MediaPlayerCore` (no `X`) is the first-class Windows-only DirectShow engine with different method signatures — both are fully supported; do not mix APIs between them.

## See also

- **UI frameworks**
  - WinForms / WPF desktop → [video-player-csharp.md](../guides/video-player-csharp/)
  - Avalonia cross-platform (Windows/macOS/Linux) → [avalonia-player.md](../guides/avalonia-player/)
  - .NET MAUI (mobile + desktop) → [maui-player.md](../guides/maui-player/)
  - Android only → [android-player.md](../guides/android-player/)
- **Network streaming**
  - RTSP → [rtsp.md](../../general/network-streaming/rtsp/)
  - HLS → [hls-streaming.md](../../general/network-streaming/hls-streaming/)
- **Deployment**
  - Windows → [../deployment-x/Windows.md](../../deployment-x/Windows/)
  - macOS → [../deployment-x/macOS.md](../../deployment-x/macOS/)
  - Linux (Ubuntu) → [../deployment-x/Ubuntu.md](../../deployment-x/Ubuntu/)
  - Android → [../deployment-x/Android.md](../../deployment-x/Android/)
  - iOS → [../deployment-x/iOS.md](../../deployment-x/iOS/)
- **Getting started + full guide** → [index.md](../), [video-player-csharp.md](../guides/video-player-csharp/)

## FAQ

### Can the SDK play RTSP streams?

Yes. Pass an `rtsp://` URI to `UniversalSourceSettings.CreateAsync(...)` and call `OpenAsync` / `PlayAsync` — the same code path as a local file. HTTP, HLS, and MPEG-DASH URIs work identically.

### Which platforms require GStreamer to be installed at the system level?

Linux. On Linux x64, the `VisioForge.CrossPlatform.Core.Linux.x64` NuGet package relies on a system-installed GStreamer 1.22+ runtime. Windows, macOS, Android, and iOS bundle everything through their NuGet redistributables — no system install needed.

### What is the difference between `MediaPlayerCoreX` and `MediaPlayerCore`?

`MediaPlayerCoreX` is the cross-platform engine used throughout this cheat sheet — it runs on Windows, macOS, Linux, Android, and iOS via GStreamer and uses async method signatures. `MediaPlayerCore` (no `X`) is the Windows-only DirectShow engine with a synchronous, event-based API; it remains a first-class, fully supported engine (choose it when you target Windows-only and need DirectShow-specific behaviour). For new cross-platform projects, prefer `MediaPlayerCoreX`.

### How do I play audio without showing a video window?

Instantiate `MediaPlayerCoreX` without a `VideoView` (`new MediaPlayerCoreX()`) and proceed with the same `UniversalSourceSettings.CreateAsync` → `OpenAsync` → `PlayAsync` flow. Audio-only sources (MP3, AAC, FLAC, WAV) will play through the configured `Audio_OutputDevice`.

---END OF PAGE---


## Extract Video Frames in C# .NET — Bitmap, SKBitmap, Byte[]
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/code-samples/get-frame-from-video-file/
**Description:** Get video frames as Bitmap, SKBitmap, or byte arrays using VisioForge Media Player SDK .NET. Seek to any timestamp and batch-generate thumbnails.
**Tags:** Media Player SDK, .NET, MediaPlayerCore, VideoEditCore, Windows, Playback, Editing, MP4, C#
**API:** MediaInfoReaderX, VideoEditCore, MediaPlayerCore, ExtractFrameWithVideoEditCore, ExtractFrameWithMediaPlayerCore

# Extracting Video Frames from Video Files in .NET

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

Video frame extraction is a common requirement in many multimedia applications. Whether you're building a video editing tool, creating thumbnails, or performing video analysis, extracting specific frames from video files is an essential capability. This guide explains different approaches to capturing frames from video files in .NET applications.

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Why Extract Video Frames?

There are numerous use cases for video frame extraction:

- Creating thumbnail images for video galleries
- Extracting key frames for video analysis
- Generating preview images at specific timestamps
- Building video editing tools with frame-by-frame precision
- Creating timelapse sequences from video footage
- Capturing still images from video recordings

## Understanding Video Frame Extraction

Video files contain sequences of frames displayed at specific intervals to create the illusion of motion. When extracting a frame, you're essentially capturing a single image at a specific timestamp within the video. This process involves:

1. Opening the video file
2. Seeking to the specific timestamp
3. Decoding the frame data
4. Converting it to an image format

## Frame Extraction Methods in .NET

There are several approaches to extract frames from video files in .NET, depending on your requirements and environment.

### Using Windows-Specific SDK Components

For Windows-only applications, the classic SDK components offer straightforward methods for frame extraction:

```
// Using VideoEditCore for frame extraction
using VisioForge.Core.VideoEdit;
using VisioForge.Core.Types.MediaPlayer;

public void ExtractFrameWithVideoEditCore()
{
    var videoEdit = new VideoEditCore();
    var bitmap = videoEdit.Helpful_GetFrameFromFile(
        "C:\\Videos\\sample.mp4",
        TimeSpan.FromSeconds(5),
        oldWay: false,
        MediaPlayerSourceMode.LAV);
    bitmap.Save("C:\\Output\\frame.png");
}

// Using MediaPlayerCore for frame extraction
using VisioForge.Core.MediaPlayer;
using VisioForge.Core.Types.MediaPlayer;

public void ExtractFrameWithMediaPlayerCore()
{
    var mediaPlayer = new MediaPlayerCore();
    var bitmap = mediaPlayer.Helpful_GetFrameFromFile(
        "C:\\Videos\\sample.mp4",
        TimeSpan.FromSeconds(10),
        oldWay: false,
        MediaPlayerSourceMode.LAV);
    bitmap.Save("C:\\Output\\frame.png");
}
```

The `Helpful_GetFrameFromFile` method simplifies the process by handling the file opening, seeking, and frame decoding operations in a single call. All four arguments are required: the file path, the seek timestamp, an `oldWay` flag (pass `false` for the modern decoder path), and a `MediaPlayerSourceMode` engine selector (`LAV`, `FFMPEG`, or `File_DS`).

### Cross-Platform Solutions with X-Engine

Modern .NET applications often need to run on multiple platforms. The X-engine provides cross-platform capabilities for video frame extraction:

#### Extracting Frames as System.Drawing.Bitmap

The most common approach is to extract frames as `System.Drawing.Bitmap` objects:

```
using VisioForge.Core.MediaInfo;

public void ExtractFrameAsBitmap()
{
    // Extract the frame at the beginning of the video (TimeSpan.Zero)
    var bitmap = MediaInfoReaderX.GetFileSnapshotBitmap("C:\\Videos\\sample.mp4", TimeSpan.Zero);

    // Extract a frame at 30 seconds into the video
    var frame30sec = MediaInfoReaderX.GetFileSnapshotBitmap("C:\\Videos\\sample.mp4", TimeSpan.FromSeconds(30));

    // Save the extracted frame
    bitmap.Save("C:\\Output\\first-frame.png");
    frame30sec.Save("C:\\Output\\frame-30sec.png");
}
```

#### Extracting Frames as SkiaSharp Bitmaps

For applications using SkiaSharp for graphics processing, you can extract frames directly as `SKBitmap` objects:

```
using VisioForge.Core.MediaInfo;
using SkiaSharp;

public void ExtractFrameAsSkiaBitmap()
{
    // Extract the frame at 15 seconds into the video
    var skBitmap = MediaInfoReaderX.GetFileSnapshotSKBitmap("C:\\Videos\\sample.mp4", TimeSpan.FromSeconds(15));

    // Work with the SKBitmap
    using (var image = SKImage.FromBitmap(skBitmap))
    using (var data = image.Encode(SKEncodedImageFormat.Png, 100))
    using (var stream = File.OpenWrite("C:\\Output\\frame-skia.png"))
    {
        data.SaveTo(stream);
    }
}
```

#### Working with Raw RGB Data

For more advanced scenarios or when you need direct pixel manipulation, you can extract frames as RGB byte arrays:

```
using VisioForge.Core.MediaInfo;

public void ExtractFrameAsRGBArray()
{
    // GetFileSnapshotRGB returns Tuple<byte[], int, int>: pixels + width + height.
    var snapshot = MediaInfoReaderX.GetFileSnapshotRGB("C:\\Videos\\sample.mp4", TimeSpan.FromSeconds(20));
    byte[] rgbData = snapshot.Item1;
    int width = snapshot.Item2;
    int height = snapshot.Item3;

    // Process the RGB data — the buffer holds R, G, B values for each pixel; width and
    // height come directly from the tuple, so no separate metadata call is needed.
}
```

## Best Practices for Video Frame Extraction

When implementing video frame extraction in your applications, consider these best practices:

### Performance Considerations

- Extracting frames can be CPU-intensive, especially for high-resolution videos
- Consider implementing caching mechanisms for frequently accessed frames
- For batch extraction, implement parallel processing where appropriate

```
// Example of parallel frame extraction
public void ExtractMultipleFramesInParallel(string videoPath, TimeSpan[] timestamps)
{
    Parallel.ForEach(timestamps, timestamp => {
        var bitmap = MediaInfoReaderX.GetFileSnapshotBitmap(videoPath, timestamp);
        bitmap.Save($"C:\\Output\\frame-{timestamp.TotalSeconds}.png");
    });
}
```

### Error Handling

Always implement proper error handling when working with video files:

```
public Bitmap SafeExtractFrame(string videoPath, TimeSpan position)
{
    try
    {
        return MediaInfoReaderX.GetFileSnapshotBitmap(videoPath, position);
    }
    catch (FileNotFoundException)
    {
        Console.WriteLine("Video file not found");
    }
    catch (InvalidOperationException)
    {
        Console.WriteLine("Invalid position in video");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error extracting frame: {ex.Message}");
    }

    return null;
}
```

### Memory Management

Proper memory management is crucial, especially when working with large video files:

```
public void ExtractFrameWithProperDisposal()
{
    Bitmap bitmap = null;
    try
    {
        bitmap = MediaInfoReaderX.GetFileSnapshotBitmap("C:\\Videos\\sample.mp4", TimeSpan.FromSeconds(5));
        // Process the bitmap...
    }
    finally
    {
        bitmap?.Dispose();
    }
}
```

## Common Applications

Frame extraction is used in various multimedia applications:

- **Video Players**: Generating preview thumbnails
- **Media Libraries**: Creating video thumbnails for gallery views
- **Video Analysis**: Extracting frames for computer vision processing
- **Content Management**: Creating preview images for video assets
- **Video Editing**: Providing visual reference for timeline editing

## Conclusion

Extracting frames from video files is a powerful capability for .NET developers working with multimedia content. Whether you're building Windows-specific applications or cross-platform solutions, the methods described in this guide provide efficient ways to capture and work with video frames.

By understanding the different approaches and following best practices, you can implement robust frame extraction functionality in your .NET applications.

## See also

Once you can pull a frame at any timestamp, you can index and search the whole file by content:

- [Semantic video search](../../../general/ai/semantic-video-search/) — find a moment by describing it in plain text, then seek to that timestamp to extract the frame.
- [Open-vocabulary detection](../../../general/ai/open-vocabulary-detection/) — detect any object you can name in a text prompt, with no training data.

---

For more code samples and examples, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Video Player Code Examples and Tutorials in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/code-samples/
**Description:** Implement playback, frame extraction, playlists, and streaming with VisioForge Media Player SDK .NET. WinForms, WPF, and Console samples included.
**Tags:** Media Player SDK, .NET, Windows, Playback, Streaming

# .NET Media Player SDK Implementation Examples

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

This page collects ready-to-use C# recipes for the most common playback scenarios using the Media Player SDK .Net. Each snippet is verified against the SDK source and demos under [`Media Player SDK`](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK). The Windows-only `MediaPlayerCore` engine is used in the examples below; cross-platform code based on `MediaPlayerCoreX` follows the same overall shape with engine-specific source settings.

## Available Recipes

### Basic Playback

- Open a local file and start playback
- Pause, resume, and stop a running player
- Adjust the output volume

### Streaming

- Play a network stream (HTTP / RTSP) by URL
- Switch source engine to the FFmpeg backend for live streams

### Effects and Processing

- Capture the current frame as a `Bitmap`
- Seek to a specific position and read playback time

## Recipe — Simple Player

The following class wraps `MediaPlayerCore` with start/stop calls. The constructor receives an `IVideoView` instance (`VideoView` for WPF, `VideoViewWinForms` for WinForms, etc.) that is provided by your UI layer.

```
using System;
using System.Threading.Tasks;
using VisioForge.Core.MediaPlayer;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Events;

public class SimplePlayer
{
    private readonly MediaPlayerCore _player;

    public SimplePlayer(IVideoView videoView)
    {
        _player = new MediaPlayerCore(videoView);

        // Subscribe to events.
        _player.OnStop += OnPlaybackStopped;
        _player.OnError += OnPlaybackError;
    }

    public async Task PlayFileAsync(string filePath)
    {
        _player.Playlist_Clear();
        _player.Playlist_Add(filePath);
        await _player.PlayAsync();
    }

    public Task StopAsync() => _player.StopAsync();

    private void OnPlaybackStopped(object sender, StopEventArgs e)
    {
        Console.WriteLine("Playback finished.");
    }

    private void OnPlaybackError(object sender, ErrorsEventArgs e)
    {
        Console.WriteLine($"Error: {e.Message}");
    }
}
```

## Recipe — Player With Pause and Volume Controls

`MediaPlayerCore` exposes `PauseAsync`/`ResumeAsync` for in-flight playback control and a per-output-device volume API (`Audio_OutputDevice_Volume_Set`) that accepts an integer in the 0–100 range.

```
using System;
using System.Threading.Tasks;
using VisioForge.Core.MediaPlayer;
using VisioForge.Core.Types;

public class ControllablePlayer
{
    private readonly MediaPlayerCore _player;
    private bool _isPaused;

    public ControllablePlayer(IVideoView videoView)
    {
        _player = new MediaPlayerCore(videoView);
    }

    public async Task PlayPauseAsync()
    {
        if (_isPaused)
        {
            await _player.ResumeAsync();
            _isPaused = false;
        }
        else
        {
            await _player.PauseAsync();
            _isPaused = true;
        }
    }

    public Task SeekAsync(TimeSpan position) =>
        _player.Position_Set_TimeAsync(position);

    public void SetVolume(int volume)
    {
        // volume: 0 (mute) … 100 (full) for the first audio output device.
        _player.Audio_OutputDevice_Volume_Set(0, volume);
    }

    public Task<TimeSpan> GetDurationAsync() => _player.Duration_TimeAsync();

    public Task<TimeSpan> GetPositionAsync() => _player.Position_Get_TimeAsync();
}
```

## Recipe — Capture the Current Frame

`Frame_GetCurrent()` returns the most recently rendered frame as a `System.Drawing.Bitmap`. Save it via the `Bitmap.Save` API or use `Frame_Save` for built-in disk output with `ImageFormat`.

```
using System.Drawing.Imaging;
using System.Threading.Tasks;

public Task<bool> SaveCurrentFrameAsync(MediaPlayerCore player, string outputPath)
{
    // Built-in helper: encodes the current frame to PNG (or any ImageFormat).
    return player.Frame_SaveAsync(outputPath, ImageFormat.Png);
}
```

## Recipe — Play a Network Stream

To consume RTSP, RTMP, HTTP, UDP, or TCP URLs through the FFmpeg back-end, switch `Source_Mode` to `MediaPlayerSourceMode.FFMPEG` and add the URL to the playlist like any other source.

```
using System.Threading.Tasks;
using VisioForge.Core.MediaPlayer;
using VisioForge.Core.Types.MediaPlayer;

public async Task PlayRtspAsync(MediaPlayerCore player, string url)
{
    player.Source_Mode = MediaPlayerSourceMode.FFMPEG;

    player.Playlist_Clear();
    player.Playlist_Add(url);

    await player.PlayAsync();
}
```

## Recipe — Playlist Navigation

The built-in playlist API tracks the current index for you. `Playlist_PlayNext` advances to the next item; `OnStop` fires on natural end-of-stream, where you can chain the next track.

```
using System;
using System.Threading.Tasks;
using VisioForge.Core.MediaPlayer;
using VisioForge.Core.Types.Events;

public class PlaylistPlayer
{
    private readonly MediaPlayerCore _player;

    public PlaylistPlayer(IVideoView videoView)
    {
        _player = new MediaPlayerCore(videoView);
        _player.OnStop += OnTrackFinished;
    }

    public void AddToPlaylist(string filePath) => _player.Playlist_Add(filePath);

    public Task PlayAsync() => _player.PlayAsync();

    public Task<bool> NextAsync() => _player.Playlist_PlayNextAsync();

    private async void OnTrackFinished(object sender, StopEventArgs e)
    {
        // Auto-advance to the next playlist entry on natural EOS.
        if (e.Successful)
        {
            await _player.Playlist_PlayNextAsync();
        }
    }
}
```

## Featured Implementation Examples

### Video Processing Examples

- [How to get a specific frame from a video file?](get-frame-from-video-file/)
- [How to play a fragment of the source file?](play-fragment-file/)
- [How to show the first frame?](show-first-frame/)

### Advanced Playback Examples

- [Memory playback implementation](memory-playback/)
- [Playlist API integration](playlist-api/)
- [Previous frame and reverse video playback](reverse-video-playback/)

---

## Additional Resources

For a more extensive collection of code examples and implementation scenarios, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Play Video from Memory Stream or Byte Array in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/code-samples/memory-playback/
**Description:** Play video and audio from memory streams and byte arrays with VisioForge Media Player SDK .NET. Efficient buffering for secure, file-free playback.
**Tags:** Media Player SDK, .NET, Windows, Playback, Streaming, C#
**API:** MemoryStreamSource, MediaPlayerSourceMode

# Play Media from Memory in .NET SDK

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Introduction to Memory-Based Media Playback

Memory-based playback offers a powerful alternative to traditional file-based media consumption in .NET applications. By loading and processing media directly from memory, developers can achieve more responsive playback, enhanced security through reduced file access, and greater flexibility in handling different data sources.

This guide explores the various approaches to implementing memory-based playback in your .NET applications, complete with code examples and best practices.

## Advantages of Memory-Based Media Playback

Before diving into implementation details, let's understand why memory-based playback is valuable:

- **Improved performance**: By eliminating file I/O operations during playback, your application can deliver smoother media experiences.
- **Enhanced security**: Media content doesn't need to be stored as accessible files on the filesystem.
- **Stream processing**: Work with data from various sources, including network streams, encrypted content, or dynamically generated media.
- **Virtual file systems**: Implement custom media access patterns without filesystem dependencies.
- **In-memory transformations**: Apply real-time modifications to media content before playback.

## Implementation Approaches

### Stream-Based Playback from Existing Files

The most straightforward approach to memory-based playback begins with existing media files that you load into memory streams. This technique is ideal when you want the performance benefits of memory playback while still maintaining your content in traditional file formats.

```
// Create a FileStream from an existing media file
var fileStream = new FileStream(mediaFilePath, FileMode.Open);

// Convert to a managed IStream for the media player
var managedStream = new ManagedIStream(fileStream);

// Configure stream settings for your content
bool videoPresent = true;
bool audioPresent = true;

// Set the memory stream as the media source
MediaPlayer1.Source_MemoryStream = new MemoryStreamSource(
    managedStream,
    videoPresent,
    audioPresent,
    fileStream.Length
);

// Set the player to memory playback mode
MediaPlayer1.Source_Mode = MediaPlayerSourceMode.Memory_DS;

// Start playback
await MediaPlayer1.PlayAsync();
```

When using this approach, remember to properly dispose of the FileStream when playback is complete to prevent resource leaks.

### Byte Array-Based Playback

For scenarios where your media content already exists as a byte array in memory (perhaps downloaded from a network source or decrypted from protected storage), you can play directly from this data structure:

```
// Assume 'mediaBytes' is a byte array containing your media content
byte[] mediaBytes = GetMediaContent();

// Create a MemoryStream from the byte array
using (var memoryStream = new MemoryStream(mediaBytes))
{
    // Convert to a managed IStream
    var managedStream = new ManagedIStream(memoryStream);

    // Configure stream settings based on your content
    bool videoPresent = true;  // Set to false for audio-only content
    bool audioPresent = true;  // Set to false for video-only content

    // Create and assign the memory stream source
    MediaPlayer1.Source_MemoryStream = new MemoryStreamSource(
        managedStream,
        videoPresent,
        audioPresent,
        memoryStream.Length
    );

    // Set memory playback mode
    MediaPlayer1.Source_Mode = MediaPlayerSourceMode.Memory_DS;

    // Begin playback
    await MediaPlayer1.PlayAsync();

    // Additional playback handling code...
}
```

This technique is particularly useful when dealing with content that should never be written to disk for security reasons.

### Advanced: Custom Stream Implementations

For more complex scenarios, you can implement custom stream handlers that provide media data from any source you can imagine:

```
// Example of a custom stream provider
public class CustomMediaStreamProvider : Stream
{
    private byte[] _buffer;
    private long _position;

    // Constructor might take a custom data source
    public CustomMediaStreamProvider(IDataSource dataSource)
    {
        // Initialize your stream from the data source
    }

    // Implement required Stream methods
    public override int Read(byte[] buffer, int offset, int count)
    {
        // Custom implementation to provide data
    }

    // Other required Stream overrides
    // ...
}

// Usage example:
var customStream = new CustomMediaStreamProvider(myDataSource);
var managedStream = new ManagedIStream(customStream);

MediaPlayer1.Source_MemoryStream = new MemoryStreamSource(
    managedStream,
    hasVideo,
    hasAudio,
    streamLength
);
```

## Performance Considerations

When implementing memory-based playback, keep these performance factors in mind:

1. **Memory allocation**: For large media files, ensure your application has sufficient memory available.
2. **Buffering strategy**: Consider implementing a sliding buffer for very large files rather than loading the entire content into memory.
3. **Garbage collection impact**: Large memory allocations can trigger garbage collection, potentially causing playback stuttering.
4. **Thread synchronization**: If providing stream data from another thread or async source, ensure proper synchronization to prevent playback issues.

## Error Handling Best Practices

Robust error handling is critical when implementing memory-based playback:

```
try
{
    var fileStream = new FileStream(mediaFilePath, FileMode.Open);
    var managedStream = new ManagedIStream(fileStream);

    MediaPlayer1.Source_MemoryStream = new MemoryStreamSource(
        managedStream,
        true,
        true,
        fileStream.Length
    );

    MediaPlayer1.Source_Mode = MediaPlayerSourceMode.Memory_DS;
    await MediaPlayer1.PlayAsync();
}
catch (FileNotFoundException ex)
{
    LogError("Media file not found", ex);
    DisplayUserFriendlyError("The requested media file could not be found.");
}
catch (UnauthorizedAccessException ex)
{
    LogError("Access denied to media file", ex);
    DisplayUserFriendlyError("You don't have permission to access this media file.");
}
catch (Exception ex)
{
    LogError("Unexpected playback error", ex);
    DisplayUserFriendlyError("An error occurred during media playback.");
}
finally
{
    // Ensure resources are properly cleaned up
    CleanupResources();
}
```

## Required Dependencies

To successfully implement memory-based playback using the Media Player SDK, ensure you have these dependencies:

- Base redistributable components
- SDK redistributable components

For more information on installing or deploying these dependencies to your users' systems, refer to our [deployment guide](../../deployment/).

## Advanced Scenarios

### Encrypted Media Playback

For applications dealing with protected content, you can integrate decryption into your memory-based playback pipeline:

```
// Read encrypted content
byte[] encryptedContent = File.ReadAllBytes(encryptedMediaPath);

// Decrypt the content
byte[] decryptedContent = DecryptMedia(encryptedContent, encryptionKey);

// Play from decrypted memory without writing to disk
using (var memoryStream = new MemoryStream(decryptedContent))
{
    var managedStream = new ManagedIStream(memoryStream);
    // Continue with standard memory playback setup...
}
```

### Network Streaming to Memory

Pull content from network sources directly into memory for playback:

```
using (HttpClient client = new HttpClient())
{
    // Download media content
    byte[] mediaContent = await client.GetByteArrayAsync(mediaUrl);

    // Play from memory
    using (var memoryStream = new MemoryStream(mediaContent))
    {
        // Continue with standard memory playback setup...
    }
}
```

## Conclusion

Memory-based media playback provides a flexible and powerful approach for .NET applications requiring enhanced performance, security, or custom media handling. By understanding the implementation options and following best practices for resource management, you can deliver smooth and responsive media experiences to your users.

For more sample code and advanced implementations, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Play Video File Fragments and Segments in C# .NET Apps
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/code-samples/play-fragment-file/
**Description:** Play precise time-based segments of video and audio files with VisioForge Media Player SDK .NET on Windows and cross-platform environments.
**Tags:** Media Player SDK, .NET, MediaPlayerCoreX, Windows, macOS, Linux, Android, iOS, Playback, MKV, C#
**API:** MediaPlayerCoreX, UniversalSourceSettings

# Playing Media File Fragments: Implementation Guide for .NET Developers

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

When developing media applications, one frequently requested feature is the ability to play specific segments of a video or audio file. This functionality is crucial for creating video editors, highlight reels, educational platforms, or any application requiring precise media segment playback.

## Understanding Fragment Playback in .NET Applications

Fragment playback allows you to define specific time segments of a media file for playback, effectively creating clips without modifying the source file. This technique is particularly useful when you need to:

- Create preview segments from longer media files
- Focus on specific sections of instructional videos
- Create looping segments for demonstrations or presentations
- Build clip-based media players for sports highlights or video compilations
- Implement training applications that focus on specific video segments

The Media Player SDK .NET provides two primary engines for implementing fragment playback, each with its own approach and platform compatibility considerations.

## Windows-Only Implementation: MediaPlayerCore Engine

The MediaPlayerCore engine provides a straightforward implementation for Windows applications. This solution works across WPF, WinForms, and console applications but is limited to Windows operating systems.

### Setting Up Fragment Playback

To implement fragment playback with the MediaPlayerCore engine, you'll need to follow three key steps:

1. Activate the selection mode on your MediaPlayer instance
2. Define the starting position of your fragment (in milliseconds)
3. Define the ending position of your fragment (in milliseconds)

### Implementation Example

The following C# code demonstrates how to configure fragment playback to play only the segment between 2000ms and 5000ms of your source file:

```
// Step 1: Enable fragment selection mode
MediaPlayer1.Selection_Active = true;

// Step 2: Set the starting position to 2000 milliseconds (2 seconds)
MediaPlayer1.Selection_Start = TimeSpan.FromMilliseconds(2000);

// Step 3: Set the ending position to 5000 milliseconds (5 seconds)
MediaPlayer1.Selection_Stop = TimeSpan.FromMilliseconds(5000);

// When you call Play() or PlayAsync(), only the specified fragment will play
```

When your application calls the Play or PlayAsync method after setting these properties, the player will automatically jump to the selection start position and stop playback when it reaches the selection end position.

### Required Redistributables for Windows Implementation

For the MediaPlayerCore engine implementation to function correctly, you must include:

- Base redistributable package
- SDK redistributable package

These packages contain the necessary components for the Windows-based playback functionality. For detailed information on deploying these redistributables to end-user machines, refer to the [deployment documentation](../../deployment/).

## Cross-Platform Implementation: MediaPlayerCoreX Engine

For developers requiring fragment playback functionality across multiple platforms, the MediaPlayerCoreX engine provides a more versatile solution. This implementation works across Windows, macOS, iOS, Android, and Linux environments.

### Setting Up Cross-Platform Fragment Playback

The cross-platform implementation follows a similar conceptual approach but uses different property names. The key steps include:

1. Creating a MediaPlayerCoreX instance
2. Loading your media source
3. Defining the segment start and stop positions
4. Initiating playback

### Cross-Platform Implementation Example

The following example demonstrates how to implement fragment playback in a cross-platform .NET application:

```
// Step 1: Create a new instance of MediaPlayerCoreX with your video view
MediaPlayerCoreX MediaPlayer1 = new MediaPlayerCoreX(VideoView1);

// Step 2: Set the source media file
var fileSource = await UniversalSourceSettings.CreateAsync("video.mkv");
await MediaPlayer1.OpenAsync(fileSource);

// Step 3: Define the segment start time (2 seconds from beginning)
MediaPlayer1.Segment_Start = TimeSpan.FromMilliseconds(2000);

// Step 4: Define the segment end time (5 seconds from beginning)
MediaPlayer1.Segment_Stop = TimeSpan.FromMilliseconds(5000);

// Step 5: Start playback of the defined segment
await MediaPlayer1.PlayAsync();
```

This implementation uses the Segment\_Start and Segment\_Stop properties instead of the Selection properties used in the Windows-only implementation. Also note the asynchronous approach used in the cross-platform example, which improves UI responsiveness.

## Advanced Fragment Playback Techniques

### Dynamic Fragment Adjustment

In more complex applications, you might need to adjust fragment boundaries dynamically. Both engines support changing the segment boundaries during runtime:

```
// For Windows-only implementation
private void UpdateFragmentBoundaries(int startMs, int endMs)
{
    MediaPlayer1.Selection_Start = TimeSpan.FromMilliseconds(startMs);
    MediaPlayer1.Selection_Stop = TimeSpan.FromMilliseconds(endMs);

    // If playback is in progress, restart it to apply the new boundaries
    if (MediaPlayer1.State() == PlaybackState.Play)
    {
        MediaPlayer1.Position_Set_Time(MediaPlayer1.Selection_Start);
    }
}

// For cross-platform implementation
private async Task UpdateFragmentBoundariesAsync(int startMs, int endMs)
{
    MediaPlayer1.Segment_Start = TimeSpan.FromMilliseconds(startMs);
    MediaPlayer1.Segment_Stop = TimeSpan.FromMilliseconds(endMs);

    // If playback is in progress, restart from the new start position (State is a sync property on MediaPlayerCoreX)
    if (MediaPlayer1.State == PlaybackState.Play)
    {
        await MediaPlayer1.Position_SetAsync(MediaPlayer1.Segment_Start);
    }
}
```

### Multiple Fragment Playback

For applications that need to play multiple fragments sequentially, you can implement a fragment queue:

```
public class MediaFragment
{
    public TimeSpan StartTime { get; set; }
    public TimeSpan EndTime { get; set; }
}

private Queue<MediaFragment> fragmentQueue = new Queue<MediaFragment>();
private bool isProcessingQueue = false;

// Add fragments to the queue
public void EnqueueFragment(TimeSpan start, TimeSpan end)
{
    fragmentQueue.Enqueue(new MediaFragment { StartTime = start, EndTime = end });

    if (!isProcessingQueue && MediaPlayer1 != null)
    {
        PlayNextFragment();
    }
}

// Process the fragment queue
private async void PlayNextFragment()
{
    if (fragmentQueue.Count == 0)
    {
        isProcessingQueue = false;
        return;
    }

    isProcessingQueue = true;
    var fragment = fragmentQueue.Dequeue();

    // Set the fragment boundaries
    MediaPlayer1.Segment_Start = fragment.StartTime;
    MediaPlayer1.Segment_Stop = fragment.EndTime;

    // Subscribe to completion event for this fragment
    MediaPlayer1.OnStop += (s, e) => PlayNextFragment();

    // Start playback
    await MediaPlayer1.PlayAsync();
}
```

### Performance Considerations

For optimal performance when using fragment playback, consider the following tips:

1. For frequent seeking between fragments, use formats with good keyframe density
2. MP4 and MOV files generally perform better for fragment-heavy applications
3. Setting fragments at keyframe boundaries improves seeking performance
4. Consider preloading files before setting fragment boundaries
5. On mobile platforms, keep fragments reasonably sized to avoid memory pressure

## Conclusion

Implementing fragment playback in your .NET media applications provides substantial flexibility and enhanced user experience. Whether you're developing for Windows only or targeting multiple platforms, the Media Player SDK .NET offers robust solutions for precise media segment playback.

By leveraging the techniques demonstrated in this guide, you can create sophisticated media experiences that allow users to focus on exactly the content they need, without the overhead of editing or splitting source files.

For more code samples and implementations, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) where you'll find comprehensive examples of media player implementations, including fragment playback and other advanced media features.

---END OF PAGE---


## Playlist Playback Management in .NET with C# Code Examples
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/code-samples/playlist-api/
**Description:** Implement playlist functionality in WinForms, WPF, and Console apps using VisioForge Media Player SDK .NET. Sequential and custom playback order.
**Tags:** Media Player SDK, .NET, MediaPlayerCore, Windows, Playback, MP4, C#
**API:** NewFilePlaybackEventArgs

# Complete Guide to Playlist API Implementation in .NET

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [MediaPlayerCore](#)

## Introduction to Playlist Management

The Playlist API provides a powerful and flexible way to manage media content in your .NET applications. Whether you're developing a music player, video application, or any media-centric software, efficient playlist management is essential for delivering a seamless user experience.

This guide covers everything you need to know about implementing playlist functionality using the MediaPlayerCore component. You'll learn how to create playlists, navigate between tracks, handle playlist events, and optimize performance in various .NET environments.

## Key Features and Benefits

- **Simple Integration**: Easy-to-implement API that integrates seamlessly with existing .NET applications
- **Format Compatibility**: Support for a wide range of audio and video formats
- **Cross-Platform**: Works consistently across WinForms, WPF, and console applications
- **Performance Optimized**: Built for efficient memory usage and responsive playback
- **Event-Driven Architecture**: Rich event system for building reactive UI experiences

## Getting Started with Playlist API

Before diving into specific methods, ensure you have properly initialized the MediaPlayer component in your application. The following sections contain practical code examples that you can implement directly in your project.

### Creating Your First Playlist

Creating a playlist is the first step in managing multiple media files. The API provides straightforward methods to add files to your playlist collection:

```
// Initialize the media player (assuming you've added the component to your form)
// this.mediaPlayer1 = new MediaPlayer();

// Add individual files to the playlist
this.mediaPlayer1.Playlist_Add(@"c:\media\intro.mp4");
this.mediaPlayer1.Playlist_Add(@"c:\media\main_content.mp4");
this.mediaPlayer1.Playlist_Add(@"c:\media\conclusion.mp4");

// Start playback from the first item
this.mediaPlayer1.Play();
```

This approach allows you to build playlists programmatically, which is ideal for applications where playlist content is determined at runtime.

## Core Playlist Operations

### Navigating Through Playlist Items

Once you've created a playlist, your users will need to navigate between items. The API provides intuitive methods for moving to the next or previous file:

```
// Play the next file in the playlist
this.mediaPlayer1.Playlist_PlayNext();

// Play the previous file in the playlist
this.mediaPlayer1.Playlist_PlayPrevious();
```

These methods automatically handle the transition between media files, including stopping the current playback and starting the new item.

### Managing Playlist Content

During application runtime, you may need to modify the playlist by removing specific items or clearing it entirely:

```
// Remove a specific file from the playlist
this.mediaPlayer1.Playlist_Remove(@"c:\media\intro.mp4");

// Clear all items from the playlist
this.mediaPlayer1.Playlist_Clear();
```

This dynamic content management allows your application to adapt to user preferences or changing requirements on the fly.

### Retrieving Playlist Information

Accessing information about the current state of the playlist is crucial for building an informative user interface:

```
// Get the current file's index (0-based)
int currentIndex = this.mediaPlayer1.Playlist_GetPosition();

// Get the total number of files in the playlist
int totalFiles = this.mediaPlayer1.Playlist_GetCount();

// Get a specific filename by its index
string fileName = this.mediaPlayer1.Playlist_GetFilename(1); // Gets the second file

// Display current playback information
string statusMessage = $"Playing file {currentIndex + 1} of {totalFiles}: {fileName}";
```

These methods enable you to create dynamic interfaces that reflect the current state of media playback.

## Advanced Playlist Control

### Resetting and Repositioning

For more precise control over playlist navigation, you can reset the playlist or jump to a specific position:

```
// Reset the playlist to start from the first file
this.mediaPlayer1.Playlist_Reset();

// Jump to a specific position in the playlist (0-based index)
this.mediaPlayer1.Playlist_SetPosition(2); // Jump to the third item
```

These methods are particularly useful for implementing features like "restart playlist" or allowing users to select specific items from a playlist view.

### Custom Event Handling for Playlist Navigation

To create a responsive application, you'll want to implement custom event handling for playlist navigation. Since the MediaPlayerCore doesn't have a dedicated playlist item changed event, you can create your own tracking mechanism using the existing events:

```
private int _lastPlaylistIndex = -1;

// Track playlist position changes when playback starts
private void mediaPlayer1_OnStart(object sender, EventArgs e)
{
    int currentIndex = this.mediaPlayer1.Playlist_GetPosition();
    if (currentIndex != _lastPlaylistIndex)
    {
        _lastPlaylistIndex = currentIndex;

        // Handle playlist item change
        string currentFile = this.mediaPlayer1.Playlist_GetFilename(currentIndex);
        UpdatePlaylistUI(currentIndex, currentFile);
    }
}

// Also track when a new file playback starts
private void mediaPlayer1_OnNewFilePlaybackStarted(object sender, NewFilePlaybackEventArgs e)
{
    int currentIndex = this.mediaPlayer1.Playlist_GetPosition();
    _lastPlaylistIndex = currentIndex;

    // Handle playlist item change
    string currentFile = this.mediaPlayer1.Playlist_GetFilename(currentIndex);
    UpdatePlaylistUI(currentIndex, currentFile);
}

// Handle playlist completion
private void mediaPlayer1_OnPlaylistFinished(object sender, EventArgs e)
{
    // Handle playlist completion
    this.lblPlaybackStatus.Text = "Playlist finished";

    // Optionally reset or loop playlist
    // this.mediaPlayer1.Playlist_Reset();
    // this.mediaPlayer1.Play();
}

private void UpdatePlaylistUI(int index, string filename)
{
    // Update UI elements with new information
    this.lblCurrentTrack.Text = $"Now playing: {Path.GetFileName(filename)}";
    this.lblTrackNumber.Text = $"Track {index + 1} of {this.mediaPlayer1.Playlist_GetCount()}";

    // Update playlist selection in UI
    // ...
}
```

This approach allows you to detect and respond to playlist navigation events in your application by subscribing to the actual events provided by MediaPlayerCore:

```
// Subscribe to events
this.mediaPlayer1.OnStart += mediaPlayer1_OnStart;
this.mediaPlayer1.OnNewFilePlaybackStarted += mediaPlayer1_OnNewFilePlaybackStarted;
this.mediaPlayer1.OnPlaylistFinished += mediaPlayer1_OnPlaylistFinished;
```

### Async Playlist Operations

The MediaPlayerCore provides async versions of playlist navigation methods for improved responsiveness:

```
// Play the next file asynchronously
await this.mediaPlayer1.Playlist_PlayNextAsync();

// Play the previous file asynchronously
await this.mediaPlayer1.Playlist_PlayPreviousAsync();
```

Using these async methods is recommended for UI applications to prevent blocking the main thread during playback transitions.

## Implementation Patterns and Best Practices

### Implementing Repeat and Shuffle Modes

Most media players include repeat and shuffle functionality. Here's how to implement these common features:

```
private bool repeatEnabled = false;
private bool shuffleEnabled = false;
private Random random = new Random();

// Handle playlist navigation when a track finishes. OnStop fires for both normal end-of-file
// and explicit Stop() calls — use OnPlaylistFinished (below) to react only at the end of the
// whole playlist. StopEventArgs exposes Successful (bool) and Position (TimeSpan); there is no
// StopReason enum.
private void MediaPlayer1_OnStop(object sender, StopEventArgs e)
{
    if (!e.Successful)
    {
        return; // Error or aborted — don't auto-advance
    }

    if (repeatEnabled)
    {
        // Just replay the current item
        this.mediaPlayer1.Play();
    }
    else if (shuffleEnabled)
    {
        // Play a random item
        int totalFiles = this.mediaPlayer1.Playlist_GetCount();
        int randomIndex = random.Next(0, totalFiles);
        this.mediaPlayer1.Playlist_SetPosition(randomIndex);
        this.mediaPlayer1.Play();
    }
    else
    {
        // Standard behavior: play next if available
        if (this.mediaPlayer1.Playlist_GetPosition() < this.mediaPlayer1.Playlist_GetCount() - 1)
        {
            this.mediaPlayer1.Playlist_PlayNext();
        }
        // Otherwise we've reached the end of the playlist — OnPlaylistFinished fires separately.
    }
}

// Subscribe to the stop event
this.mediaPlayer1.OnStop += MediaPlayer1_OnStop;
```

### Memory Management for Large Playlists

When dealing with large playlists, consider implementing lazy loading techniques:

```
// Store playlist information separately for large playlists
private List<string> masterPlaylist = new List<string>();

public void LoadLargePlaylist(string[] filePaths)
{
    // Clear existing playlist
    this.mediaPlayer1.Playlist_Clear();
    masterPlaylist.Clear();

    // Store all paths
    masterPlaylist.AddRange(filePaths);

    // Load only the first batch of items (e.g., 100)
    int initialBatchSize = Math.Min(100, filePaths.Length);
    for (int i = 0; i < initialBatchSize; i++)
    {
        this.mediaPlayer1.Playlist_Add(filePaths[i]);
    }

    // Start playback
    this.mediaPlayer1.Play();
}

// Implement dynamic loading as user approaches the end of loaded items
private void CheckAndLoadMoreItems()
{
    int currentPosition = this.mediaPlayer1.Playlist_GetPosition();
    int loadedCount = this.mediaPlayer1.Playlist_GetCount();

    // If we're near the end of loaded items but have more in master playlist
    if (currentPosition > loadedCount - 10 && loadedCount < masterPlaylist.Count)
    {
        // Load next batch
        int nextBatchSize = Math.Min(50, masterPlaylist.Count - loadedCount);
        for (int i = 0; i < nextBatchSize; i++)
        {
            this.mediaPlayer1.Playlist_Add(masterPlaylist[loadedCount + i]);
        }
    }
}
```

## Cross-Platform Considerations

The Playlist API functions consistently across different .NET environments, but there are some platform-specific considerations:

### WPF Implementation Notes

When implementing in WPF applications, you'll typically use data binding with your playlist:

```
// Create an observable collection to bind to UI
private ObservableCollection<PlaylistItem> observablePlaylist = new ObservableCollection<PlaylistItem>();

// Sync the observable collection with the player's playlist
private void SyncObservablePlaylist()
{
    observablePlaylist.Clear();
    for (int i = 0; i < this.mediaPlayer1.Playlist_GetCount(); i++)
    {
        string filename = this.mediaPlayer1.Playlist_GetFilename(i);
        observablePlaylist.Add(new PlaylistItem
        {
            Index = i,
            FileName = System.IO.Path.GetFileName(filename),
            FullPath = filename
        });
    }
}
```

## Conclusion

The Playlist API provides a robust foundation for building feature-rich media applications in .NET. By using the methods and patterns outlined in this guide, you can create intuitive playlist management systems that enhance the user experience of your application.

For more advanced scenarios, explore the additional capabilities of the MediaPlayerCore component, including custom event handling, media metadata extraction, and format-specific optimizations.

---END OF PAGE---


## Reverse Video Playback in .NET with C# Code Examples
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/code-samples/reverse-video-playback/
**Description:** Implement reverse video playback with frame-by-frame navigation using VisioForge Media Player SDK .NET on Windows and cross-platform targets.
**Tags:** Media Player SDK, .NET, MediaPlayerCoreX, Windows, macOS, Linux, Android, iOS, Playback, MP4, C#
**API:** MediaPlayerCoreX, MediaPlayerCore, PlaybackState, UniversalSourceSettings

# Implementing Reverse Video Playback in .NET Applications

Playing video in reverse is a powerful feature for media applications, allowing users to review content, create unique visual effects, or enhance the user experience with non-linear playback options. This guide provides complete implementations for reverse playback in .NET applications, focusing on both cross-platform and Windows-specific solutions.

## Understanding Reverse Playback Mechanisms

Reverse video playback can be achieved through several techniques, each with distinct advantages depending on your application's requirements:

1. **Rate-based reverse playback** - Setting a negative playback rate to reverse the video stream
2. **Frame-by-frame backward navigation** - Manually stepping backward through cached video frames
3. **Buffer-based approaches** - Creating a frame buffer to enable smooth reverse navigation

Let's explore how to implement each approach using the Media Player SDK for .NET.

## Cross-Platform Reverse Playback with MediaPlayerCoreX

The MediaPlayerCoreX engine provides cross-platform support for reverse video playback with a straightforward implementation. This approach works across Windows, macOS, and other supported platforms.

### Basic Implementation

The simplest method for reverse playback involves setting a negative rate value:

```
// Create new instance of MediaPlayerCoreX
MediaPlayerCoreX MediaPlayer1 = new MediaPlayerCoreX(VideoView1);

// Set the source file
var fileSource = await UniversalSourceSettings.CreateAsync("video.mp4");
await MediaPlayer1.OpenAsync(fileSource);

// Start normal playback first
await MediaPlayer1.PlayAsync();

// Change to reverse playback with normal speed
MediaPlayer1.Rate_Set(-1.0);
```

### Controlling Reverse Playback Speed

You can control the reverse playback speed by adjusting the negative rate value:

```
// Double-speed reverse playback
MediaPlayer1.Rate_Set(-2.0);

// Half-speed reverse playback (slow motion in reverse)
MediaPlayer1.Rate_Set(-0.5);

// Quarter-speed reverse playback (very slow motion in reverse)
MediaPlayer1.Rate_Set(-0.25);
```

### Tracking Position During Reverse Playback

`MediaPlayerCoreX` does not raise a position-changed event; poll the position on a timer instead:

```
// Poll the player position every 100 ms and update the UI
var positionTimer = new System.Threading.Timer(_ =>
{
    TimeSpan currentPosition = MediaPlayer1.Position_Get();
    UpdatePositionUI(currentPosition);

    // Detect reaching the start while playing backwards
    if (MediaPlayer1.Rate_Get() < 0 && currentPosition <= TimeSpan.FromMilliseconds(100))
    {
        // Switch to forward playback (or pause)
        MediaPlayer1.Rate_Set(1.0);
    }
}, null, TimeSpan.Zero, TimeSpan.FromMilliseconds(100));
```

## Windows-Specific Frame-by-Frame Reverse Navigation

The classic `MediaPlayerCore` engine (Windows-only) provides enhanced frame-by-frame control with its frame caching system, allowing precise backward navigation even with codecs that don't natively support it. Declare a separate classic-engine instance — the `ReversePlayback_*` API lives on `MediaPlayerCore` and is **not** available on `MediaPlayerCoreX`.

### Setting Up Frame Caching

Before starting playback, configure the reverse playback cache:

```
// Classic Windows engine — different type from MediaPlayerCoreX above
MediaPlayerCore classicPlayer = new MediaPlayerCore(VideoView1);

// Configure reverse playback before starting
classicPlayer.ReversePlayback_CacheSize = 100; // Cache 100 frames
classicPlayer.ReversePlayback_Enabled = true;  // Enable the feature

// Start playback
await classicPlayer.PlayAsync();
```

### Navigating Frame by Frame

With the cache configured, you can navigate to previous frames:

```
// Navigate to the previous frame
classicPlayer.ReversePlayback_PreviousFrame();

// Navigate backward multiple frames
for(int i = 0; i < 5; i++)
{
    classicPlayer.ReversePlayback_PreviousFrame();
    // Optional: add delay between frames for controlled playback
    await Task.Delay(40); // ~25fps equivalent timing
}
```

### Advanced Frame Cache Configuration

For applications with specific memory or performance requirements, you can fine-tune the cache:

```
// For high-resolution videos, you might need fewer frames to manage memory
classicPlayer.ReversePlayback_CacheSize = 50; // Reduce cache size

// For applications that need extensive backward navigation
classicPlayer.ReversePlayback_CacheSize = 250; // Increase cache size
```

## Implementing UI Controls for Reverse Playback

A complete reverse playback implementation typically includes dedicated UI controls:

```
// Button click handler for reverse playback
private async void ReversePlaybackButton_Click(object sender, EventArgs e)
{
    if(MediaPlayer1.State == PlaybackState.Play)
    {
        // Toggle between forward and reverse
        if(MediaPlayer1.Rate_Get() > 0)
        {
            MediaPlayer1.Rate_Set(-1.0);
            UpdateUIForReverseMode(true);
        }
        else
        {
            MediaPlayer1.Rate_Set(1.0);
            UpdateUIForReverseMode(false);
        }
    }
    else
    {
        // Start playback in reverse
        await MediaPlayer1.PlayAsync();
        MediaPlayer1.Rate_Set(-1.0);
        UpdateUIForReverseMode(true);
    }
}

// Button click handler for frame-by-frame backward navigation
// (assumes the Windows-only classic engine `classicPlayer` declared above)
private async void PreviousFrameButton_Click(object sender, EventArgs e)
{
    // Ensure we're paused first — classic MediaPlayerCore exposes State() as a method (X is a property).
    if (classicPlayer.State() == PlaybackState.Play)
    {
        await classicPlayer.PauseAsync();
    }

    // Navigate to previous frame
    classicPlayer.ReversePlayback_PreviousFrame();
    UpdateFrameCountDisplay();
}
```

## Performance Considerations

Reverse playback can be resource-intensive, especially with high-resolution videos. Consider these optimization techniques:

1. **Limit cache size** for devices with memory constraints
2. **Use hardware acceleration** when available
3. **Monitor performance** during reverse playback with debugging tools
4. **Provide fallback options** for devices that struggle with full-speed reverse playback

```
// Example of performance monitoring during reverse playback.
// Rate tracking lives on MediaPlayerCoreX (`MediaPlayer1`);
// cache adjustment targets the classic MediaPlayerCore (`classicPlayer`).
private void MonitorPerformance()
{
    Timer performanceTimer = new Timer(1000);
    performanceTimer.Elapsed += (s, e) =>
    {
        if(MediaPlayer1.Rate_Get() < 0)
        {
            // Log or display current memory usage, frame rate, etc.
            LogPerformanceMetrics();
        }

        // Adjust classic-engine frame cache if memory pressure is high
        if(IsMemoryUsageHigh())
        {
            classicPlayer.ReversePlayback_CacheSize =
                Math.Max(10, classicPlayer.ReversePlayback_CacheSize / 2);
        }
    };
    performanceTimer.Start();
}
```

## Required Dependencies

To ensure proper functionality of reverse playback features, include these dependencies:

- Base redistributable package
- SDK redistributable package

These packages contain the necessary codecs and media processing components to enable smooth reverse playback across different video formats.

## Additional Resources and Advanced Techniques

For complex media applications requiring advanced reverse playback features, consider exploring:

- Frame extraction and manual rendering for custom effects
- Keyframe analysis for optimized navigation
- Buffering strategies for smoother reverse playback

## Conclusion

Implementing reverse video playback adds significant value to media applications, providing users with enhanced control over content navigation. By following the implementation patterns in this guide, developers can create robust, performant reverse playback experiences in .NET applications.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page for more complete code samples and implementation examples.

---END OF PAGE---


## Display First Frame of Video in C# .NET Applications
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/code-samples/show-first-frame/
**Description:** Show the first video frame in WinForms, WPF, and Console apps with C# examples using VisioForge Media Player SDK .NET for thumbnail previews.
**Tags:** Media Player SDK, .NET, VideoCaptureCore, Windows, Capture, Playback, Streaming, C#

# Displaying the First Frame of Video Files in .NET Applications

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) [VideoCaptureCore](#)

## Overview

When developing media applications, it's often necessary to preview video content without playing the entire file. This technique is particularly useful for creating thumbnail galleries, video selection screens, or providing users with a visual preview before committing to watching a video.

## Implementation Guide

The Media Player SDK .NET provides a simple yet powerful way to display the first frame of any video file. This is achieved through the `Play_PauseAtFirstFrame` property, which when set to `true`, instructs the player to pause immediately after loading the first frame.

### How It Works

When the `Play_PauseAtFirstFrame` property is enabled:

1. The player loads the video file
2. Renders the first frame to the video display surface
3. Automatically pauses playback
4. Maintains the first frame on screen until further user action

If this property is not enabled (set to `false`), the player will proceed with normal playback after loading.

## Code Implementation

### Basic Example

```
// create player and configure the file name
// ...

// set the property to true
MediaPlayer1.Play_PauseAtFirstFrame = true;

// play the file
await MediaPlayer1.PlayAsync();
```

Resume playback from the first frame:

```
// resume playback
await MediaPlayer1.ResumeAsync();
```

## Practical Applications

This feature is particularly useful for:

- Providing preview capabilities in video editing applications
- Generating video poster frames for streaming applications
- Implementing "hover to preview" functionality in media browsers

## Required Components

To implement this functionality in your application, you'll need:

- Base redist package
- SDK redist package

For more information on distributing these components with your application, see: [How can the required redists be installed or deployed to the user's PC?](../../deployment/)

## Additional Resources

Find more code samples and implementation examples in our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

## Technical Considerations

When implementing this feature, keep in mind:

- First frame display is nearly instantaneous for most video formats
- Resource usage is minimal as the player doesn't buffer beyond the first frame
- Works with all supported video formats including MP4, MOV, AVI, and more

---END OF PAGE---


## Deploy .NET Video Player - NuGet and Runtime Setup
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/deployment/
**Description:** Configure NuGet packages and runtime dependencies for VisioForge Media Player SDK .NET apps on Windows and cross-platform environments.
**Tags:** Media Player SDK, .NET, DirectShow, MediaPlayerCoreX, Windows, macOS, Linux, Android, iOS, Playback, Streaming, Decoding, IP Camera, MP4, WebM, OGG, FLAC, Vorbis, NuGet

# Media Player SDK .Net Deployment Guide

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

This comprehensive guide covers all deployment scenarios for the Media Player SDK .Net, ensuring your applications work correctly across different environments. Whether you're developing cross-platform applications or Windows-specific solutions, this guide provides the necessary steps for successful deployment.

## Engine Types Overview

The Media Player SDK .Net offers two primary engine types, each designed for specific deployment scenarios:

### MediaPlayerCoreX Engine (Cross-Platform)

MediaPlayerCoreX is our cross-platform solution that works across multiple operating systems. For detailed deployment instructions specific to this engine, refer to the main [Cross-Platform Deployment Guide](../../deployment-x/).

### MediaPlayerCore Engine (Windows-Only)

The MediaPlayerCore engine is optimized specifically for Windows environments. When deploying applications that use this engine on computers without the SDK pre-installed, you must include the necessary SDK components with your application.

> **Important**: For AnyCPU applications, you should deploy both x86 and x64 redistributables to ensure compatibility across different system architectures.

## Deployment Options

There are three primary methods for deploying the Media Player SDK .Net components:

1. Using NuGet packages (recommended for most scenarios)
2. Using automatic silent installers (requires administrative privileges)
3. Manual installation (for complete control over the deployment process)

## NuGet Package Deployment

NuGet packages provide the simplest deployment method, automatically handling the inclusion of necessary files in your application folder during the build process.

### Required NuGet Packages

#### Core Packages (Always Required)

- **SDK Base Package**:
- [x86 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.Base.x86/)
- [x64 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.Base.x64/)
- **Media Player SDK Package**:
- [x86 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MediaPlayer.x86/)
- [x64 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MediaPlayer.x64/)

#### Feature-Specific Packages (Add as Needed)

##### Media Format Support

- **FFMPEG Package** (for file playback using FFMPEG source mode):
- [x86 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.FFMPEG.x86/)
- [x64 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.FFMPEG.x64/)
- **MP4 Output Package**:
- [x86 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MP4.x86/)
- [x64 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MP4.x64/)
- **WebM Output Package**:
- [x86 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.WebM.x86/)

##### Source Support

- **VLC Source Package** (for file/IP camera sources):
- [x86 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VLC.x86/)
- [x64 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VLC.x64/)

##### Audio Format Support

- **XIPH Formats Package** (Ogg, Vorbis, FLAC output/source):
- [x86 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.XIPH.x86/)
- [x64 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.XIPH.x64/)

##### Filter Support

- **LAV Filters Package**:
- [x86 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.LAV.x86/)
- [x64 Version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.LAV.x64/)

## Automatic Silent Installers

For scenarios where you prefer installer-based deployment, the SDK offers automatic silent installers that require administrative privileges.

### Available Installers

#### Core Components

- **Base Package** (always required):
- [x86 Installer](https://files.visioforge.com/redists_net/redist_dotnet_base_x86.exe)
- [x64 Installer](https://files.visioforge.com/redists_net/redist_dotnet_base_x64.exe)

#### Media Format Support

- **FFMPEG Package** (for file/IP camera sources):
- [x86 Installer](https://files.visioforge.com/redists_net/redist_dotnet_ffmpeg_x86.exe)
- [x64 Installer](https://files.visioforge.com/redists_net/redist_dotnet_ffmpeg_x64.exe)

#### Source Support

- **VLC Source Package** (for file/IP camera sources):
- [x86 Installer](https://files.visioforge.com/redists_net/redist_dotnet_vlc_x86.exe)
- [x64 Installer](https://files.visioforge.com/redists_net/redist_dotnet_vlc_x64.exe)

#### Audio Format Support

- **XIPH Formats Package** (Ogg, Vorbis, FLAC output/source):
- [x86 Installer](https://files.visioforge.com/redists_net/redist_dotnet_xiph_x86.exe)
- [x64 Installer](https://files.visioforge.com/redists_net/redist_dotnet_xiph_x64.exe)

#### Filter Support

- **LAV Filters Package**:
- [x86 Installer](https://files.visioforge.com/redists_net/redist_dotnet_lav_x86.exe)
- [x64 Installer](https://files.visioforge.com/redists_net/redist_dotnet_lav_x64.exe)

> **Note**: To uninstall any installed package, run the executable with administrative privileges using the parameters: `/x //`

## Manual Installation

For advanced deployment scenarios requiring precise control over component installation, follow these steps:

### Step 1: Runtime Dependencies

- **With Administrative Privileges**: Install the VC++ 2022 (v143) runtime (x86/x64) and OpenMP runtime DLLs using redistributable executables or MSM modules.
- **Without Administrative Privileges**: Copy the VC++ 2022 (v143) runtime (x86/x64) and OpenMP runtime DLLs directly to your application folder.

### Step 2: Core Components

- Copy the VisioForge\_MFP/VisioForge\_MFPX (or x64 versions) DLLs from the Redist\Filters directory to your application folder.

### Step 3: .NET Assemblies

- Either copy the .NET assemblies to your application folder or install them to the Global Assembly Cache (GAC).

### Step 4: DirectShow Filters

- Copy and COM-register SDK DirectShow filters using [regsvr32.exe](https://support.microsoft.com/en-us/topic/how-to-use-the-regsvr32-tool-and-troubleshoot-regsvr32-error-messages-a98d960a-7392-e6fe-d90a-3f4e0cb543e5) or another suitable method.

### Step 5: Environment Configuration

- Add the folder containing the filters to the system PATH environment variable if your application executable is located in a different directory.

## DirectShow Filter Configuration

The SDK uses various DirectShow filters for specific functionality. Below is a comprehensive list organized by feature category:

### Basic Feature Filters

- VisioForge\_Video\_Effects\_Pro.ax
- VisioForge\_MP3\_Splitter.ax
- VisioForge\_H264\_Decoder.ax
- VisioForge\_Audio\_Mixer.ax

### Audio Effect Filters

- VisioForge\_Audio\_Effects\_4.ax (legacy audio effects)

### Streaming Support Filters

#### RTSP Streaming

- VisioForge\_RTSP\_Sink.ax
- MP4 filters (legacy/modern, excluding muxer)

#### SSF Streaming

- VisioForge\_SSF\_Muxer.ax
- MP4 filters (legacy/modern, excluding muxer)

### Source Filters

#### VLC Source

- VisioForge\_VLC\_Source.ax
- Complete Redist\VLC folder with COM registration
- VLC\_PLUGIN\_PATH environment variable pointing to VLC\plugins folder

#### FFMPEG Source

- VisioForge\_FFMPEG\_Source.ax
- Complete Redist\FFMPEG folder, added to the Windows PATH variable

#### Memory Source

- VisioForge\_AsyncEx.ax

#### WebM Decoding

- VisioForge\_WebM\_Ogg\_Source.ax
- VisioForge\_WebM\_Source.ax
- VisioForge\_WebM\_Split.ax
- VisioForge\_WebM\_Vorbis\_Decoder.ax
- VisioForge\_WebM\_VP8\_Decoder.ax
- VisioForge\_WebM\_VP9\_Decoder.ax

#### Network Streaming Sources

- VisioForge\_RTSP\_Source.ax
- VisioForge\_RTSP\_Source\_Live555.ax
- FFMPEG, VLC or LAV filters

#### Audio Format Sources

- VisioForge\_Xiph\_FLAC\_Source.ax (FLAC source)
- VisioForge\_Xiph\_Ogg\_Demux2.ax (Ogg Vorbis source)
- VisioForge\_Xiph\_Vorbis\_Decoder.ax (Ogg Vorbis source)

### Special Feature Filters

#### Video Encryption

- VisioForge\_Encryptor\_v8.ax
- VisioForge\_Encryptor\_v9.ax

#### GPU Acceleration

- VisioForge\_DXP.dll / VisioForge\_DXP64.dll (DirectX 11 GPU video effects)

#### LAV Source

- Complete contents of redist\LAV\x86(x64), with all .ax files registered

### Filter Registration Tip

To simplify the COM registration process for all DirectShow filters in a directory, place the "reg\_special.exe" file from the SDK redist into the filters folder and run it with administrative privileges.

---

For more code samples and examples, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Android Video Player with HLS and RTSP Streaming in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/guides/android-player/
**Description:** Build Android video player apps with streaming, hardware acceleration, and multi-format support using VisioForge Media Player SDK .NET.
**Tags:** Media Player SDK, .NET, MediaPlayerCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Playback, Streaming, RTSP, HLS, MP4, C#
**API:** MediaPlayerCoreX

# Android Media Player SDK - Professional Video Playback Solution

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Overview

The VisioForge Android Player SDK enables developers to integrate professional video playback, streaming, and editing into native Android apps. Built on GStreamer, it provides a comprehensive API for feature-rich applications.

The SDK supports extensive video formats, codecs, and streaming protocols.

## Key Features

### Video Playback and Streaming

Our Android player SDK delivers powerful playback with hardware acceleration, ensuring optimal performance for high-resolution content. Developers integrate the player using an intuitive API with support for MP4, MKV, AVI, WebM, and other formats.

The player provides precise control with play, pause, seek, and navigation. Variable playback speeds and frame-by-frame navigation give complete control over the viewing experience.

Stream content from various sources including HTTP Live Streaming (HLS), RTSP, and RTMP. Adaptive bitrate streaming adjusts quality based on bandwidth for mobile users.

### Video Editing and Effects

The SDK includes video editing capabilities for creating editor applications. Apply real-time effects including brightness, contrast, and saturation adjustments.

Overlay text, images, and SVG graphics with control over positioning and transparency for picture-in-picture, watermarks, and interactive elements.

### Native Android and Cross-Platform Support

The SDK integrates seamlessly with Android Studio, supporting Java and Kotlin development. The VideoView component embeds into any Android layout.

The SDK also supports .NET MAUI and Avalonia for cross-platform development, enabling code sharing across Android, iOS, Windows, macOS, and Linux.

## Technical Capabilities

### Codec and Format Support

The SDK supports extensive video codecs with hardware-accelerated decoding for H.264, H.265/HEVC, VP8, and VP9. Audio playback supports AAC, MP3, Opus, and Vorbis.

### API and Performance

Our API reference provides detailed documentation. Code samples demonstrate common use cases. Events and callbacks provide real-time notifications.

The SDK is optimized for mobile with attention to battery and memory. Hardware acceleration ensures smooth playback.

## Getting Started

### Installation and Setup

Integrate the VisioForge Android Player SDK using NuGet. Add the package reference to your project. For .NET MAUI, configure to use the VideoView control.

Setup instructions are in our documentation.

### Quick Start Code Example

Here's how to create a basic media player:

#### Add VideoView to Layout

```
<VisioForge.Core.UI.Android.VideoViewTX
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:id="@+id/videoView" />
```

#### Initialize Player

```
using VisioForge.Core.MediaPlayerX;

public class MainActivity : Activity
{
    private MediaPlayerCoreX _player;

    protected override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);
        SetContentView(Resource.Layout.activity_main);

        var videoView = FindViewById<VisioForge.Core.UI.Android.VideoViewTX>(Resource.Id.videoView);
        _player = new MediaPlayerCoreX(videoView);
    }

    protected override void OnDestroy()
    {
        VisioForgeX.DestroySDK();
        base.OnDestroy();
    }
}
```

#### Playback Controls

```
private async void PlayVideo()
{
    await _player.OpenAsync(new Uri("https://example.com/video.mp4"));
    await _player.PlayAsync();
}

private async void PauseVideo() => await _player.PauseAsync();
private async void ResumeVideo() => await _player.ResumeAsync();
private async void StopVideo() => await _player.StopAsync();
```

### Sample Applications

GitHub samples demonstrate SDK capabilities: [Media Player sample](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK%20X/Android/MediaPlayer) with playback, streaming, and editing.

### Alternative: Media Blocks SDK

The [Media Blocks SDK](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/Android/MediaPlayer) provides lower-level API for custom pipelines.

## Use Cases

The Android Player SDK is ideal for:

- **Video Streaming Apps**: Adaptive streaming support
- **Educational Platforms**: Video lessons and e-learning
- **Media Players**: Native mediaplayer apps with subtitle support
- **Social Media**: User-generated content playback
- **Video Editors**: Mobile editing with real-time preview
- **Security**: Surveillance apps with live streaming

The SDK supports Android TV and picture-in-picture mode on Android 8.0+.

## Licensing

The Android Player SDK is available under a commercial license. A single license covers all supported platforms. Trial versions are available.

## Conclusion

The VisioForge Android Player SDK provides professional video playback for Android applications. With streaming, editing, and advanced features, developers can create powerful media apps quickly.

For more information, visit our [product page](https://www.visioforge.com/media-player-sdk-net) or [API documentation](https://api.visioforge.org/dotnet/api/index.html).

## Related Resources

- [Android Implementation Guide](../../../deployment-x/Android/) - Detailed deployment instructions for Android
- [Code Samples](../../code-samples/) - Working examples and snippets
- [Cross-Platform Avalonia Player Guide](../avalonia-player/) - Building cross-platform video apps
- [Changelog](../../../changelog/) - Latest updates and releases
- [End User License Agreement](../../../../eula/) - Licensing information

---END OF PAGE---


## Avalonia Video Player in C# .NET — Cross-Platform Playback
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/guides/avalonia-player/
**Description:** Embed video playback in Avalonia apps (Windows/macOS/Linux). H.264, HEVC, RTSP, HLS support. XAML-first API. Full C# sample with MediaPlayer control.
**Tags:** Media Player SDK, .NET, C++, MediaPlayerCoreX, Windows, macOS, Linux, Android, iOS, Avalonia, GStreamer, Playback, Streaming, RTSP, HLS, MPEG-DASH, MP4, H.264, H.265, C#, NuGet
**API:** VideoView, MediaPlayerCoreX, IVideoView, UniversalSourceSettings, ErrorsEventArgs

# Build a Cross-Platform Video Player in C# with Avalonia UI

Build a video player in C# that runs on **Windows, macOS, Linux, Android, and iOS** from a single Avalonia UI codebase. This guide uses the MVVM pattern with [VisioForge Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)'s `MediaPlayerCoreX` engine and the `VideoView` control, and references the [SimplePlayerMVVM demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK%20X/Avalonia/SimplePlayerMVVM) on GitHub for every snippet shown.

Supported formats out of the box: **H.264, H.265/HEVC, VP9, AV1, MP4, MKV, WebM, RTSP, HLS, MPEG-DASH**.

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Quick Start

For an absolute minimum Avalonia video player — no MVVM, no multiple platforms — add `VideoView` to an AXAML file and wire it to `MediaPlayerCoreX` in code-behind:

```
<UserControl xmlns:vf="clr-namespace:VisioForge.Core.UI.Avalonia;assembly=VisioForge.Core.UI.Avalonia">
    <vf:VideoView x:Name="videoView" Background="Black" />
</UserControl>
```

```
using VisioForge.Core;
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types.X.Sources;

public partial class MainView : UserControl
{
    private MediaPlayerCoreX _player;

    public MainView()
    {
        InitializeComponent();
        Loaded += async (_, _) =>
        {
            _player = new MediaPlayerCoreX(videoView);
            var src = await UniversalSourceSettings.CreateAsync("video.mp4");
            await _player.OpenAsync(src);
            await _player.PlayAsync();
        };
    }
}
```

That is the full picture: `VideoView` on the UI, `MediaPlayerCoreX` instance bound to it, `OpenAsync` + `PlayAsync`. Everything that follows on this page adds production features on top — MVVM, platform-specific file pickers, seeking, volume, speed, cleanup, and deployment for each target OS.

The rest of this guide references the [`SimplePlayerMVVM`](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK%20X/Avalonia/SimplePlayerMVVM) demo project to walk through the full production implementation.

## 1. Prerequisites

Before you begin, ensure you have the following installed:

- .NET SDK (latest version, e.g., .NET 8 or newer)
- An IDE such as Visual Studio, JetBrains Rider, or VS Code with C# and Avalonia extensions.
- For Android development:
- Android SDK
- Java Development Kit (JDK)
- For iOS development (requires a macOS machine):
- Xcode
- Necessary provisioning profiles and certificates.
- VisioForge .NET SDK (MediaPlayer SDK X). You can obtain this from the VisioForge website. The necessary packages will be added via NuGet.

## 2. Project Setup

This section outlines how to set up the solution structure and include the necessary VisioForge SDK packages.

### 2.1. Solution Structure

The `SimplePlayerMVVM` solution consists of several projects:

- **SimplePlayerMVVM**: A .NET Standard library containing the core application logic, including ViewModels, Views (AXAML), and shared interfaces. This is the main project where most of our application logic resides.
- **SimplePlayerMVVM.Android**: The Android-specific head project.
- **SimplePlayerMVVM.Desktop**: The desktop-specific head project (Windows, macOS, Linux).
- **SimplePlayerMVVM.iOS**: The iOS-specific head project.

### 2.2. Core Project (`SimplePlayerMVVM.csproj`)

The main project, `SimplePlayerMVVM.csproj`, targets multiple platforms. Key package references include:

- `Avalonia`: The core Avalonia UI framework.
- `Avalonia.Themes.Fluent`: Provides a Fluent Design theme.
- `ReactiveUI.Avalonia`: For MVVM support using ReactiveUI.
- `VisioForge.DotNet.MediaBlocks`: Core VisioForge media processing components.
- `VisioForge.DotNet.Core.UI.Avalonia`: VisioForge UI components for Avalonia, including the `VideoView`.

```
<Project Sdk="Microsoft.NET.Sdk">
 <PropertyGroup>
  <Nullable>enable</Nullable>
  <LangVersion>latest</LangVersion>
  <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
 </PropertyGroup>
 <ItemGroup>
  <AvaloniaResource Include="Assets\**" />
 </ItemGroup>
 <PropertyGroup Condition="$([MSBuild]::IsOsPlatform('Windows'))">
  <TargetFrameworks>net10.0-android;net10.0-ios;net10.0-windows</TargetFrameworks>
 </PropertyGroup>
 <PropertyGroup Condition="$([MSBuild]::IsOsPlatform('OSX'))">
  <TargetFrameworks>net10.0-android;net10.0-ios;net10.0-macos</TargetFrameworks>
 </PropertyGroup>
 <PropertyGroup Condition="$([MSBuild]::IsOsPlatform('Linux'))">
  <TargetFrameworks>net10.0-android;net10.0</TargetFrameworks>
 </PropertyGroup>
 <ItemGroup>
  <AvaloniaResource Include="Assets\**" />
 </ItemGroup>
 <ItemGroup>
  <PackageReference Include="Avalonia" Version="12.0.5" />
  <PackageReference Include="Avalonia.Themes.Fluent" Version="12.0.5" />
  <PackageReference Include="Avalonia.Fonts.Inter" Version="12.0.5" />
  <!--Condition below is needed to remove AvaloniaUI.DiagnosticsSupport package from build output in Release configuration.-->
  <PackageReference Condition="'$(Configuration)' == 'Debug'" Include="AvaloniaUI.DiagnosticsSupport" Version="2.2.3" />
  <PackageReference Include="ReactiveUI.Avalonia" Version="12.0.3" />
 </ItemGroup>
 <ItemGroup Condition="'$(TargetFramework)' == 'net10.0-android'">
  <PackageReference Include="Avalonia.Android" Version="12.0.5" />
 </ItemGroup>
 <ItemGroup>
  <PackageReference Include="VisioForge.DotNet.MediaBlocks" Version="2025.5.1" />
  <PackageReference Include="VisioForge.DotNet.Core.UI.Avalonia" Version="2025.5.1" />
 </ItemGroup>
</Project>
```

This setup allows the core logic to be shared across all target platforms.

### 2.3. Platform-Specific Projects

Each platform head project (`SimplePlayerMVVM.Android.csproj`, `SimplePlayerMVVM.Desktop.csproj`, `SimplePlayerMVVM.iOS.csproj`) includes platform-specific dependencies and configurations.

**Desktop (`SimplePlayerMVVM.Desktop.csproj`):**

- References `Avalonia.Desktop`.
- Includes platform-specific VisioForge native libraries (e.g., `VisioForge.CrossPlatform.Core.Windows.x64`, `VisioForge.CrossPlatform.Core.macOS`).

```
  <PropertyGroup Condition="$([MSBuild]::IsOsPlatform('Windows'))">
    <TargetFramework>net10.0-windows</TargetFramework>
    <OutputType>WinExe</OutputType>
  </PropertyGroup>
  <ItemGroup Condition="$([MSBuild]::IsOsPlatform('Windows'))">
    <PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
    <PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64.UPX" Version="2026.4.29" />
  </ItemGroup>
  <PropertyGroup Condition="$([MSBuild]::IsOsPlatform('OSX'))">
    <TargetFramework>net10.0-macos</TargetFramework>
    <OutputType>Exe</OutputType>
  </PropertyGroup>
  <ItemGroup Condition="$([MSBuild]::IsOsPlatform('OSX'))">
    <PackageReference Include="VisioForge.CrossPlatform.Core.macOS" Version="2026.8.5" />
  </ItemGroup>
  <PropertyGroup Condition="$([MSBuild]::IsOsPlatform('Linux'))">
    <TargetFramework>net10.0</TargetFramework>
    <OutputType>Exe</OutputType>
  </PropertyGroup>
```

**Android (`SimplePlayerMVVM.Android.csproj`):**

- References `Avalonia.Android`.
- Includes Android-specific VisioForge libraries and dependencies like `VisioForge.CrossPlatform.Core.Android`.

```
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0-android</TargetFramework>
    <SupportedOSPlatformVersion>21</SupportedOSPlatformVersion>
    <Nullable>enable</Nullable>
    <ApplicationId>com.CompanyName.Simple_Player_MVVM</ApplicationId>
    <ApplicationVersion>1</ApplicationVersion>
    <ApplicationDisplayVersion>1.0</ApplicationDisplayVersion>
    <AndroidPackageFormat>apk</AndroidPackageFormat>
    <AndroidEnableProfiledAot>false</AndroidEnableProfiledAot>
  </PropertyGroup>
  <!-- ... other items ... -->
  <ItemGroup>
    <ProjectReference Include="..\..\..\..\AndroidDependency\VisioForge.Core.Android.X10.csproj" />
    <ProjectReference Include="..\SimplePlayerMVVM\SimplePlayerMVVM.csproj" />
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.7.27" />
  </ItemGroup>
</Project>
```

**iOS (`SimplePlayerMVVM.iOS.csproj`):**

- References `Avalonia.iOS`.
- Includes iOS-specific VisioForge libraries like `VisioForge.CrossPlatform.Core.iOS`.

```
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0-ios</TargetFramework>
    <SupportedOSPlatformVersion>13.0</SupportedOSPlatformVersion>
    <Nullable>enable</Nullable>
    <RootNamespace>Simple_Player_MVVM.iOS</RootNamespace>
    <ApplicationId>com.visioforge.avaloniaplayer</ApplicationId>
  </PropertyGroup>
  <!-- ... other items ... -->
  <ItemGroup>
    <PackageReference Include="Avalonia.iOS" Version="12.0.5" />
    <PackageReference Include="VisioForge.CrossPlatform.Core.iOS" Version="2025.12.0" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\SimplePlayerMVVM\SimplePlayerMVVM.csproj" />
  </ItemGroup>
</Project>
```

These project files are crucial for managing dependencies and build configurations for each platform.

## 3. Core MVVM Structure

The application follows the MVVM pattern, separating UI (Views) from logic (ViewModels) and data (Models). ReactiveUI is used to facilitate this pattern.

### 3.1. `ViewModelBase.cs`

This abstract class serves as the base for all ViewModels in the application. It inherits from `ReactiveObject`, which is part of ReactiveUI and provides the necessary infrastructure for property change notifications.

```
using ReactiveUI;

namespace Simple_Player_MVVM.ViewModels
{
    public abstract class ViewModelBase : ReactiveObject
    {
    }
}
```

Any ViewModel that needs to notify the UI of property changes should inherit from `ViewModelBase`.

### 3.2. `ViewLocator.cs`

The `ViewLocator` class is responsible for locating and instantiating Views based on the type of their corresponding ViewModel. It implements Avalonia's `IDataTemplate` interface.

```
using Avalonia.Controls;
using Avalonia.Controls.Templates;
using Simple_Player_MVVM.ViewModels;
using System;

namespace Simple_Player_MVVM
{
    public class ViewLocator : IDataTemplate
    {
        public Control? Build(object? data)
        {
            if (data is null)
                return null;

            var name = data.GetType().FullName!.Replace("ViewModel", "View", StringComparison.Ordinal);
            var type = Type.GetType(name);

            if (type != null)
            {
                return (Control)Activator.CreateInstance(type)!;
            }

            return new TextBlock { Text = "Not Found: " + name };
        }

        public bool Match(object? data)
        {
            return data is ViewModelBase;
        }
    }
}
```

When Avalonia needs to display a ViewModel, the `ViewLocator`'s `Match` method checks if the data object is a `ViewModelBase`. If it is, the `Build` method attempts to find a corresponding View by replacing "ViewModel" with "View" in the ViewModel's class name and instantiates it.

This convention-based approach simplifies the association between Views and ViewModels.

### 3.3. Application Initialization (`App.axaml` and `App.axaml.cs`)

The `App.axaml` file defines the application-level resources, including the `ViewLocator` as a data template and the theme (FluentTheme).

**`App.axaml`**:

```
<Application xmlns="https://github.com/avaloniaui"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:local="using:Simple_Player_MVVM"
             x:Class="Simple_Player_MVVM.App"
             RequestedThemeVariant="Default">
    <Application.DataTemplates>
        <local:ViewLocator/>
    </Application.DataTemplates>

    <Application.Styles>
        <FluentTheme />
    </Application.Styles>
</Application>
```

**`App.axaml.cs`**: The `App.axaml.cs` file handles the application's initialization and lifecycle.

Key responsibilities in `OnFrameworkInitializationCompleted`:

1. Creates an instance of `MainViewModel`.
2. Sets up the main window or view based on the application lifetime (`IClassicDesktopStyleApplicationLifetime` for desktop, `ISingleViewApplicationLifetime` for mobile/web-like views).
3. Assigns the `MainViewModel` instance as the `DataContext` for the main window/view.
4. Retrieves the `IVideoView` instance from the `MainView` (hosted within `MainWindow` or directly as `MainView`).
5. Passes the `IVideoView` and the `TopLevel` control (necessary for file dialogs and other top-level interactions) to the `MainViewModel`.

```
using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.ApplicationLifetimes;
using Avalonia.Markup.Xaml;
using Simple_Player_MVVM.ViewModels;
using Simple_Player_MVVM.Views;
using VisioForge.Core.Types;

namespace Simple_Player_MVVM
{
    public partial class App : Application
    {
        public override void Initialize()
        {
            AvaloniaXamlLoader.Load(this);
        }

        public override void OnFrameworkInitializationCompleted()
        {
            IVideoView videoView = null;
            var model = new MainViewModel();
            if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
            {
                desktop.MainWindow = new MainWindow
                {
                    DataContext = model
                };

                videoView = (desktop.MainWindow as MainWindow).GetVideoView();
                model.VideoViewIntf = videoView;
                model.TopLevel = desktop.MainWindow;
            }
            else if (ApplicationLifetime is ISingleViewApplicationLifetime singleViewPlatform)
            {
                singleViewPlatform.MainView = new MainView
                {
                    DataContext = model
                };

                videoView = (singleViewPlatform.MainView as MainView).GetVideoView();
                model.VideoViewIntf = videoView;
                model.TopLevel = TopLevel.GetTopLevel(singleViewPlatform.MainView);
            }

            base.OnFrameworkInitializationCompleted();
        }
    }
}
```

This setup ensures that the `MainViewModel` has access to the necessary UI components for video playback and interaction, regardless of the platform.

## 4. MainViewModel Implementation (`MainViewModel.cs`)

The `MainViewModel` is central to the media player's functionality. It manages the player's state, handles user interactions, and communicates with the VisioForge `MediaPlayerCoreX` engine.

Key components of `MainViewModel`:

### 4.1. Properties for UI Binding

The ViewModel exposes several properties that are bound to UI elements in `MainView.axaml`. These properties use `ReactiveUI`'s `RaiseAndSetIfChanged` to notify the UI of changes.

- **`VideoViewIntf` (IVideoView):** A reference to the `VideoView` control in the UI, passed from `App.axaml.cs`.
- **`TopLevel` (TopLevel):** A reference to the top-level control, used for displaying file dialogs.
- **`Position` (string?):** Current playback position (e.g., "00:01:23").
- **`Duration` (string?):** Total duration of the media file (e.g., "00:05:00").
- **`Filename` (string? or Foundation.NSUrl? for iOS):** The name or path of the currently loaded file.
- **`VolumeValue` (double?):** Current volume level (0-100).
- **`PlayPauseText` (string?):** Text for the Play/Pause button (e.g., "PLAY" or "PAUSE").
- **`SpeedText` (string?):** Text indicating the current playback speed (e.g., "SPEED: 1X").
- **`SeekingValue` (double?):** Current value of the seeking slider.
- **`SeekingMaximum` (double?):** Maximum value of the seeking slider (corresponds to media duration in milliseconds).

```
// Example property
private string? _Position = "00:00:00";
public string? Position
{
    get => _Position;
    set => this.RaiseAndSetIfChanged(ref _Position, value);
}

// ... other properties ...
```

### 4.2. Commands for UI Interactions

ReactiveUI `ReactiveCommand` instances are used to handle actions triggered by UI elements (e.g., button clicks, slider value changes).

- **`OpenFileCommand`:** Opens a file dialog to select a media file.
- **`PlayPauseCommand`:** Plays or pauses the media.
- **`StopCommand`:** Stops playback.
- **`SpeedCommand`:** Cycles through playback speeds (1x, 2x, 0.5x).
- **`VolumeValueChangedCommand`:** Updates the player volume when the volume slider changes.
- **`SeekingValueChangedCommand`:** Seeks to a new position when the seeking slider changes.
- **`WindowClosingCommand`:** Handles cleanup when the application window is closing.

```
// Constructor - Command initialization
public MainViewModel()
{
    OpenFileCommand = ReactiveCommand.Create(OpenFileAsync);
    PlayPauseCommand = ReactiveCommand.CreateFromTask(PlayPauseAsync);
    StopCommand = ReactiveCommand.CreateFromTask(StopAsync);
    // ... other command initializations ...

    // Subscribe to property changes to trigger commands for sliders
    this.WhenAnyValue(x => x.VolumeValue).Subscribe(_ => VolumeValueChangedCommand.Execute().Subscribe());
    this.WhenAnyValue(x => x.SeekingValue).Subscribe(_ => SeekingValueChangedCommand.Execute().Subscribe());

    _tmPosition = new System.Timers.Timer(1000); // Timer for position updates
    _tmPosition.Elapsed += tmPosition_Elapsed;

    VisioForgeX.InitSDK(); // Initialize VisioForge SDK
}
```

Note: `VisioForgeX.InitSDK()` initializes the VisioForge SDK. This should be called once at application startup.

### 4.3. VisioForge `MediaPlayerCoreX` Integration

A private field `_player` of type `MediaPlayerCoreX` holds the instance of the VisioForge media player engine.

```
private MediaPlayerCoreX _player;
```

### 4.4. Engine Creation (`CreateEngineAsync`)

This asynchronous method initializes or re-initializes the `MediaPlayerCoreX` instance.

```
private async Task CreateEngineAsync()
{
    if (_player != null)
    {
        await _player.StopAsync();
        await _player.DisposeAsync();
    }

    _player = new MediaPlayerCoreX(VideoViewIntf); // Pass the Avalonia VideoView
    _player.OnError += _player_OnError; // Subscribe to error events
    _player.Audio_Play = true; // Ensure audio is enabled

    // Create source settings from the filename
    var sourceSettings = await UniversalSourceSettings.CreateAsync(Filename);
    await _player.OpenAsync(sourceSettings);
}
```

Key steps:

1. Disposes of any existing player instance.
2. Creates a new `MediaPlayerCoreX`, passing the `IVideoView` from the UI.
3. Subscribes to the `OnError` event for error handling.
4. Sets `Audio_Play = true` to enable audio playback by default.
5. Uses `UniversalSourceSettings.CreateAsync(Filename)` to create source settings appropriate for the selected file.
6. Opens the media source using `_player.OpenAsync(sourceSettings)`.

### 4.5. File Opening (`OpenFileAsync`)

This method is responsible for allowing the user to select a media file.

```
private async Task OpenFileAsync()
{
    await StopAllAsync(); // Stop any current playback
    PlayPauseText = "PLAY";

#if __IOS__ && !__MACCATALYST__
    // iOS specific: Use IDocumentPickerService
    var filePicker = Locator.Current.GetService<IDocumentPickerService>();
    var res = await filePicker.PickVideoAsync();
    if (res != null)
    {
        Filename = (Foundation.NSUrl)res;
        var access = IOSHelper.CheckFileAccess(Filename); // Helper to check file access
        if (!access)
        {
            IOSHelper.ShowToast("File access error");
            return;
        }
    }
#else
    // Other platforms: Use Avalonia's StorageProvider
    try
    {
        var files = await TopLevel.StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
        {
            Title = "Open video file",
            AllowMultiple = false
        });

        if (files.Count >= 1)
        {
            var file = files[0];
            Filename = file.Path.AbsoluteUri;

#if __ANDROID__
            // Android specific: Convert content URI to file path if necessary
            if (!Filename.StartsWith('/'))
            {
                Filename = global::VisioForge.Core.UI.Android.FileDialogHelper.GetFilePathFromUri(AndroidHelper.GetContext(), file.Path);
            }
#endif
        }
    }
    catch (Exception ex)
    {
        // Handle cancellation or errors
        Debug.WriteLine($"File open error: {ex.Message}");
    }
#endif
}
```

Platform-specific considerations:

- **iOS:** Uses an `IDocumentPickerService` (resolved via `Locator.Current.GetService`) to present the native document picker. `IOSHelper.CheckFileAccess` is used to ensure the app has permission to access the selected file. The filename is stored as an `NSUrl`.
- **Android:** If the path obtained from the file picker is a content URI, `FileDialogHelper.GetFilePathFromUri` (from `VisioForge.Core.UI.Android`) is used to convert it to an actual file path. This requires an `IAndroidHelper` to get the Android context.
- **Desktop/Other:** Uses `TopLevel.StorageProvider.OpenFilePickerAsync` for the standard Avalonia file dialog.

### 4.6. Playback Controls

- **`PlayPauseAsync`:**
- If the player is not initialized or stopped (`PlaybackState.Free`), it calls `CreateEngineAsync` and then `_player.PlayAsync()`.
- If playing (`PlaybackState.Play`), it calls `_player.PauseAsync()`.
- If paused (`PlaybackState.Pause`), it calls `_player.ResumeAsync()`.
- Updates `PlayPauseText` accordingly and starts/stops the `_tmPosition` timer.

  ```
  private async Task PlayPauseAsync()
  {
      // ... (null/empty filename check) ...

      if (_player == null || _player.State == PlaybackState.Free)
      {
          await CreateEngineAsync();
          await _player.PlayAsync();
          _tmPosition.Start();
          PlayPauseText = "PAUSE";
      }
      else if (_player.State == PlaybackState.Play)
      {
          await _player.PauseAsync();
          PlayPauseText = "PLAY";
      }
      else if (_player.State == PlaybackState.Pause)
      {
          await _player.ResumeAsync();
          PlayPauseText = "PAUSE";
      }
  }
  ```
- **`StopAsync`:**
- Calls `StopAllAsync` to stop the player and reset UI elements.
- Resets `SpeedText` and `PlayPauseText`.

  ```
  private async Task StopAsync()
  {
      await StopAllAsync();
      SpeedText = "SPEED: 1X";
      PlayPauseText = "PLAY";
  }
  ```
- **`StopAllAsync` (Helper):**
- Stops the `_tmPosition` timer.
- Calls `_player.StopAsync()`.
- Resets `SeekingMaximum` to null (so it gets re-calculated on next play).

  ```
  private async Task StopAllAsync()
  {
      if (_player == null) return;
      _tmPosition.Stop();
      if (_player != null) await _player.StopAsync();
      await Task.Delay(300); // Small delay to ensure stop completes
      SeekingMaximum = null;
  }
  ```

### 4.7. Playback Speed (`SpeedAsync`)

Cycles through playback rates: 1.0, 2.0, and 0.5.

```
private async Task SpeedAsync()
{
    if (SpeedText == "SPEED: 1X")
    {
        SpeedText = "SPEED: 2X";
        await _player.Rate_SetAsync(2.0);
    }
    else if (SpeedText == "SPEED: 2X")
    {
        SpeedText = "SPEED: 0.5X";
        await _player.Rate_SetAsync(0.5);
    }
    else if (SpeedText == "SPEED: 0.5X") // Assumes this was the previous state
    {
        SpeedText = "SPEED: 1X";
        await _player.Rate_SetAsync(1.0);
    }
}
```

Uses `_player.Rate_SetAsync(double rate)` to change the playback speed.

### 4.8. Position and Duration Updates (`tmPosition_Elapsed`)

This method is called by the `_tmPosition` timer (typically every second) to update the UI with the current playback position and duration.

```
private async void tmPosition_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
    if (_player == null) return;

    var pos = await _player.Position_GetAsync();
    var progress = (int)pos.TotalMilliseconds;

    try
    {
        await Dispatcher.UIThread.InvokeAsync(async () =>
        {
            if (_player == null) return;

            _isTimerUpdate = true; // Flag to prevent seeking loop

            if (SeekingMaximum == null)
            {
                SeekingMaximum = (int)(await _player.DurationAsync()).TotalMilliseconds;
            }

            SeekingValue = Math.Min(progress, (int)(SeekingMaximum ?? progress));

            Position = $"{pos.ToString(@"hh\:mm\:ss", CultureInfo.InvariantCulture)}";
            Duration = $"{(await _player.DurationAsync()).ToString(@"hh\:mm\:ss", CultureInfo.InvariantCulture)}";

            _isTimerUpdate = false;
        });
    }
    catch (Exception exception)
    {
        System.Diagnostics.Debug.WriteLine(exception);
    }
}
```

Key actions:

1. Retrieves current position (`_player.Position_GetAsync()`) and duration (`_player.DurationAsync()`).
2. Updates `SeekingMaximum` if it hasn't been set yet (usually after a file is opened).
3. Updates `SeekingValue` with the current progress.
4. Formats and updates `Position` and `Duration` strings.
5. Uses `Dispatcher.UIThread.InvokeAsync` to ensure UI updates happen on the UI thread.
6. Sets `_isTimerUpdate = true` before updating `SeekingValue` and `false` after, to prevent the `OnSeekingValueChanged` handler from re-seeking when the timer updates the slider position.

### 4.9. Seeking (`OnSeekingValueChanged`)

Called when the `SeekingValue` property changes (i.e., the user moves the seeking slider).

```
private async Task OnSeekingValueChanged()
{
    if (!_isTimerUpdate && _player != null && SeekingValue.HasValue)
    {
        await _player.Position_SetAsync(TimeSpan.FromMilliseconds(SeekingValue.Value));
    }
}
```

If not currently being updated by the timer (`!_isTimerUpdate`), it calls `_player.Position_SetAsync()` to seek to the new position.

### 4.10. Volume Control (`OnVolumeValueChanged`)

Called when the `VolumeValue` property changes (i.e., the user moves the volume slider).

```
private void OnVolumeValueChanged()
{
    if (_player != null && VolumeValue.HasValue)
    {
        // Volume for MediaPlayerCoreX is 0.0 to 1.0
        _player.Audio_OutputDevice_Volume = VolumeValue.Value / 100.0;
    }
}
```

Sets `_player.Audio_OutputDevice_Volume`. Note that the ViewModel uses a 0-100 scale for `VolumeValue`, while the player expects 0.0-1.0.

### 4.11. Error Handling (`_player_OnError`)

A simple error handler that logs errors to the debug console.

```
private void _player_OnError(object sender, VisioForge.Core.Types.Events.ErrorsEventArgs e)
{
    Debug.WriteLine(e.Message);
}
```

More sophisticated error handling (e.g., showing a message to the user) could be implemented here.

### 4.12. Resource Cleanup (`OnWindowClosing`)

This method is invoked when the main window is closing. It ensures that VisioForge SDK resources are properly released.

```
private void OnWindowClosing()
{
    if (_player != null)
    {
        _player.OnError -= _player_OnError; // Unsubscribe from events
        _player.Stop(); // Ensure player is stopped (sync version here for quick cleanup)
        _player.Dispose();
        _player = null;
    }

    VisioForgeX.DestroySDK(); // Destroy VisioForge SDK instance
}
```

It stops the player, disposes of it, and importantly, calls `VisioForgeX.DestroySDK()` to release all SDK resources. This is crucial to prevent memory leaks or issues when the application exits.

This ViewModel orchestrates all the core logic of the media player, from loading files to controlling playback and interacting with the VisioForge SDK.

## 5. User Interface (Views)

The user interface is defined using Avalonia XAML (`.axaml` files).

### 5.1. `MainView.axaml` - The Player Interface

This `UserControl` defines the layout and controls for the media player.

**Key UI Elements:**

- **`avalonia:VideoView`:** This is the VisioForge control responsible for rendering video. It's placed in the main area of the grid and set to stretch.

  ```
  <avalonia:VideoView x:Name="videoView1" Margin="0,0,0,0" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Background="#0C0C0C"  />
  ```
- **Seeking Slider (`Slider Name="slSeeking"`):**
- `Maximum="{Binding SeekingMaximum}"`: Binds to the `SeekingMaximum` property in `MainViewModel`.
- `Value="{Binding SeekingValue}"`: Binds two-way to the `SeekingValue` property in `MainViewModel`. Changes to this slider by the user will update `SeekingValue`, triggering `OnSeekingValueChanged`. Updates to `SeekingValue` from the ViewModel (e.g., by the timer) will update the slider's position.
- **Time Display (`TextBlock`s for Position and Duration):**
- Bound to `Position` and `Duration` properties in `MainViewModel`.
- `TextBlock Text="{Binding Filename}"` displays the current file name.
- **Playback Control Buttons (`Button`s):**
- **Open File:** `Command="{Binding OpenFileCommand}"`
- **Play/Pause:** `Command="{Binding PlayPauseCommand}"`, `Content="{Binding PlayPauseText}"` (dynamically changes button text).
- **Stop:** `Command="{Binding StopCommand}"`
- **Volume and Speed Controls:**
- **Volume Slider:** `Value="{Binding VolumeValue}"` (binds to `VolumeValue` for volume control).
- **Speed Button:** `Command="{Binding SpeedCommand}"`, `Content="{Binding SpeedText}"`.

**Layout:** The view uses a `Grid` to arrange the `VideoView` and a `StackPanel` for the controls at the bottom. The controls themselves are organized using nested `StackPanel`s and `Grid`s for alignment.

```
<UserControl xmlns="https://github.com/avaloniaui"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:vm="clr-namespace:Simple_Player_MVVM.ViewModels"
             xmlns:avalonia="clr-namespace:VisioForge.Core.UI.Avalonia;assembly=VisioForge.Core.UI.Avalonia"
             x:Class="Simple_Player_MVVM.Views.MainView"
             x:DataType="vm:MainViewModel">
  <Design.DataContext>
    <vm:MainViewModel />
  </Design.DataContext>

  <Grid RowDefinitions="*,Auto" ColumnDefinitions="*">
    <!-- Video View Placeholder -->
    <Border Grid.Row="0" Background="Black" HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
      <avalonia:VideoView x:Name="videoView1" Margin="0,0,0,0" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Background="#0C0C0C"  />
    </Border>

    <!-- Controls -->
    <StackPanel Grid.Row="1" Background="#1e1e1e" Orientation="Vertical">
      <!-- Slider for seeking -->
      <Slider Name="slSeeking" Margin="16,16,16,0" VerticalAlignment="Center" Maximum="{Binding SeekingMaximum}" Value="{Binding SeekingValue}"/>

      <!-- Time and filename display -->
      <Grid Margin="0">
        <Grid.ColumnDefinitions>
          <ColumnDefinition Width="auto"/>
          <ColumnDefinition Width="*"/>
          <ColumnDefinition Width="auto"/>
        </Grid.ColumnDefinitions>
        <TextBlock Grid.Column="0" Text="{Binding Position}" Foreground="White" VerticalAlignment="Center" Margin="5,0,5,0"/>
        <TextBlock Grid.Column="1" Text="{Binding Filename}" Foreground="White" HorizontalAlignment="Center" />
        <TextBlock Grid.Column="2" Text="{Binding Duration}" Foreground="White" VerticalAlignment="Center" Margin="5,0,5,0"/>
      </Grid>

      <!-- Playback Controls -->
      <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" Margin="16,0,5,0">
        <Button Command="{Binding OpenFileCommand}" Content="OPEN FILE" Margin="5" VerticalAlignment="Center"/>
        <Button Name="btPlayPause" Command="{Binding PlayPauseCommand}" Content="{Binding PlayPauseText}" Margin="5"/>
        <Button Name="btStop" Command="{Binding StopCommand}" Content="STOP" Margin="5"/>
      </StackPanel>

      <!-- Volume and Speed Controls -->
      <StackPanel Orientation="Horizontal" HorizontalAlignment="Left" Margin="16,0,5,5">
        <TextBlock Text="Volume" Foreground="White" VerticalAlignment="Center"/>
        <Slider Value="{Binding VolumeValue}" Minimum="0" Maximum="100" Width="150" Margin="15,0,5,0" VerticalAlignment="Center"/>
        <Button Command="{Binding SpeedCommand}" Content="{Binding SpeedText}" Margin="5"/>
      </StackPanel>
    </StackPanel>
  </Grid>
</UserControl>
```

The `x:DataType="vm:MainViewModel"` directive enables compiled bindings, providing better performance and compile-time checking of binding paths. The `Design.DataContext` is used to provide data for the XAML previewer in IDEs.

### 5.2. `MainView.axaml.cs` - Code-Behind

The code-behind for `MainView` is minimal. Its primary purpose is to provide a way for the application setup code (in `App.axaml.cs`) to access the `VideoView` control instance.

```
using Avalonia.Controls;
using VisioForge.Core.Types;

namespace Simple_Player_MVVM.Views
{
    public partial class MainView : UserControl
    {
        // Provides access to the VideoView control instance
        public IVideoView GetVideoView()
        {
            return videoView1; // videoView1 is the x:Name of the VideoView in XAML
        }

        public MainView()
        {
            InitializeComponent(); // Standard Avalonia control initialization
        }
    }
}
```

This `GetVideoView()` method is called during application startup to pass the `VideoView` reference to the `MainViewModel`.

### 5.3. `MainWindow.axaml` - The Main Application Window (Desktop)

For desktop platforms, `MainWindow.axaml` serves as the top-level window that hosts the `MainView`.

```
<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:vm="using:Simple_Player_MVVM.ViewModels"
        xmlns:views="clr-namespace:Simple_Player_MVVM.Views"
        mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
        x:Class="Simple_Player_MVVM.Views.MainWindow"
        Icon="/Assets/avalonia-logo.ico"
        Title="Simple_Player_MVVM">
  <views:MainView />
</Window>
```

It simply embeds the `MainView` control. The `DataContext` (which will be an instance of `MainViewModel`) is typically set in `App.axaml.cs` when the `MainWindow` is created.

### 5.4. `MainWindow.axaml.cs` - Main Window Code-Behind

The code-behind for `MainWindow` primarily handles two things:

1. Provides a way to get the `VideoView` from the contained `MainView`.
2. Hooks into the `Closing` event of the window to trigger the `WindowClosingCommand` in the `MainViewModel` for resource cleanup.

```
using Avalonia.Controls;
using Simple_Player_MVVM.ViewModels;
using System;
using VisioForge.Core.Types;

namespace Simple_Player_MVVM.Views
{
    public partial class MainWindow : Window
    {
        // Helper to get VideoView from the MainView content
        public IVideoView GetVideoView()
        {
            return (Content as MainView).GetVideoView();
        }

        public MainWindow()
        {
            InitializeComponent();

            // Handle the window closing event to trigger cleanup in ViewModel
            Closing += async (sender, e) =>
            {
                if (DataContext is MainViewModel viewModel)
                {
                    // Execute the command and handle potential errors or completion
                    viewModel.WindowClosingCommand.Execute()
                        .Subscribe(_ => { /* Optional: action on completion */ },
                                   ex => Console.WriteLine($"Error during closing: {ex.Message}"));
                }
            };
        }
    }
}
```

When the window closes, it checks if the `DataContext` is a `MainViewModel` and then executes its `WindowClosingCommand`. This ensures that the `MainViewModel` can perform necessary cleanup, such as disposing of the `MediaPlayerCoreX` instance and calling `VisioForgeX.DestroySDK()`.

## 6. Platform-Specific Implementation Details

While Avalonia and .NET provide a high degree of cross-platform compatibility, certain aspects like file system access and permissions require platform-specific handling.

### 6.1. Interfaces for Platform Services

To abstract platform-specific functionality, interfaces are defined in the core `SimplePlayerMVVM` project:

- **`IAndroidHelper.cs`:**

  ```
  namespace SimplePlayerMVVM
  {
      public interface IAndroidHelper
      {
  #if __ANDROID__
          global::Android.Content.Context GetContext();
  #endif
      }
  }
  ```

  This interface is used to get the Android `Context`, which is needed for operations like converting content URIs to file paths.
- **`IDocumentPickerService.cs`:**

  ```
  using System.Threading.Tasks;

  namespace SimplePlayerMVVM;

  public interface IDocumentPickerService
  {
      Task<object?> PickVideoAsync();
  }
  ```

  This interface abstracts the file picking mechanism, specifically for iOS where a native document picker is preferred.

### 6.2. Android Implementation (`SimplePlayerMVVM.Android` project)

- **`MainActivity.cs`:**
- Inherits from `AvaloniaMainActivity<App>` and implements `IAndroidHelper`.
- **`CustomizeAppBuilder`:** Standard Avalonia Android setup.
- **Permissions:** In `OnCreate`, it calls `RequestPermissionsAsync` to request necessary permissions like `Manifest.Permission.Internet`, `Manifest.Permission.ReadExternalStorage`, and `Manifest.Permission.ReadMediaVideo` (for newer Android versions).

  ```
  ```csharp
  // In MainActivity.cs
  protected override void OnCreate(Bundle savedInstanceState)
  {
      base.OnCreate(savedInstanceState);
      MainViewModel.AndroidHelper = this; // Provide IAndroidHelper implementation to ViewModel
      RequestPermissionsAsync();
  }

  private async void RequestPermissionsAsync()
  {
      RequestPermissions(
          new String[]{
                  Manifest.Permission.Internet,
                  Manifest.Permission.ReadExternalStorage,
                  Manifest.Permission.ReadMediaVideo}, 1004);
  }

  public Context GetContext() // IAndroidHelper implementation
  {
      return this;
  }
  ```
  ```
- The `MainViewModel.AndroidHelper = this;` line makes the `MainActivity` instance (which implements `IAndroidHelper`) available to the `MainViewModel` for getting the Android context.
- The Android Manifest (`AndroidManifest.xml`, not explicitly shown in the provided files but essential) must also declare these permissions.
- **File Path Handling:** As seen in `MainViewModel.OpenFileAsync`, the `FileDialogHelper.GetFilePathFromUri` method uses the context obtained via `IAndroidHelper` to resolve file paths from content URIs, which is common when using Android's file picker.
- **Project File (`SimplePlayerMVVM.Android.csproj`):** Configures the Android-specific build, target SDK versions, and includes necessary VisioForge Android libraries.

### 6.3. iOS Implementation (`SimplePlayerMVVM.iOS` project)

- **`AppDelegate.cs`:**
- Inherits from `AvaloniaAppDelegate<App>`.
- **`CustomizeAppBuilder`:** Registers the `IOSDocumentPickerService` with the Splat dependency resolver (`Locator.CurrentMutable.RegisterConstant`). This makes the `IDocumentPickerService` available for injection or service location in the `MainViewModel`.

  ```
  ```csharp
  // In AppDelegate.cs
  protected override AppBuilder CustomizeAppBuilder(AppBuilder builder)
  {
      Locator.CurrentMutable.RegisterConstant(new IOSDocumentPickerService(), typeof(IDocumentPickerService));

      return base.CustomizeAppBuilder(builder)
          .WithInterFont()
          .UseReactiveUI();
  }
  ```
  ```
- **`IOSDocumentPickerService.cs`:**
- Implements `IDocumentPickerService`.
- Uses `UIDocumentPickerViewController` to present the native iOS file picker for video files (`UTType.Video`, `UTType.Movie`).
- Handles the `DidPickDocumentAtUrls` and `WasCancelled` events from the picker.
- Returns the selected file URL (`NSUrl`) via a `TaskCompletionSource`.
- Includes utility code (`GetTopViewController`) to find the topmost view controller to present the picker from.

  ```
  // Snippet from IOSDocumentPickerService.cs
  public Task<object?> PickVideoAsync()
  {
      _tcs = new TaskCompletionSource<object?>();
      string[] allowedUTIs = { UTType.Video, UTType.Movie };
      var picker = new UIDocumentPickerViewController(allowedUTIs, UIDocumentPickerMode.Import);
      // ... event subscriptions and presentation ...
      return _tcs.Task;
  }

  private void OnDocumentPicked(object sender, UIDocumentPickedAtUrlsEventArgs e)
  {
      // ... handles picked URL, resolves _tcs ...
      NSUrl fileUrl = e.Urls[0];
      _tcs?.TrySetResult(fileUrl);
  }
  ```
- **`Info.plist`:**
- This file is crucial for iOS apps. It must include keys like `NSPhotoLibraryUsageDescription` if accessing the photo library, or other relevant permissions depending on where files are stored/accessed. The provided `Info.plist` includes:

  ```
  ```xml
  <key>NSPhotoLibraryUsageDescription</key>
  <string>Photo library used to play files</string>
  ```
  ```
- It also defines bundle identifiers, version numbers, supported orientations, etc.
- **Project File (`SimplePlayerMVVM.iOS.csproj`):** Configures the iOS-specific build, target OS version, and includes VisioForge iOS libraries.

### 6.4. Desktop Implementation (`SimplePlayerMVVM.Desktop` project)

- **`Program.cs`:**
- Contains the `Main` entry point for desktop applications.
- Uses `BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);` to initialize and run the Avalonia application for desktop.
- `BuildAvaloniaApp()` configures Avalonia with platform detection, fonts, ReactiveUI, and logging.

  ```
  internal sealed class Program
  {
      [STAThread]
      public static void Main(string[] args) => BuildAvaloniaApp()
          .StartWithClassicDesktopLifetime(args);

      public static AppBuilder BuildAvaloniaApp()
          => AppBuilder.Configure<App>()
              .UsePlatformDetect()
              .WithInterFont()
              .UseReactiveUI()
              .LogToTrace();
  }
  ```
- **File Access:** On desktop, file access is generally more straightforward. The `MainViewModel` uses `TopLevel.StorageProvider.OpenFilePickerAsync` which works across Windows, macOS, and Linux without specific helper services like those for Android or iOS URI/permission complexities.
- **Project File (`SimplePlayerMVVM.Desktop.csproj`):**
- Targets specific desktop frameworks (e.g., `net10.0-windows`, `net10.0-macos`, `net10.0` for Linux).
- Includes `Avalonia.Desktop`.
- Includes platform-specific VisioForge native libraries for Windows (x64) and macOS through `PackageReference` conditions.

  ```
  ```xml
  <ItemGroup Condition="$([MSBuild]::IsOsPlatform('Windows'))">
    <PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
    <PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64.UPX" Version="2026.4.29" />
  </ItemGroup>
  <ItemGroup Condition="$([MSBuild]::IsOsPlatform('OSX'))">
    <PackageReference Include="VisioForge.CrossPlatform.Core.macOS" Version="2026.8.5" />
  </ItemGroup>
  ```
  ```
- **Windows Manifest (`app.manifest`):** Used on Windows for application settings, such as compatibility with specific Windows versions.
- **macOS Info (`Info.plist` in Desktop project):** Provides bundle information for macOS applications.

These platform-specific projects and configurations ensure that the shared core logic in `SimplePlayerMVVM` can interact correctly with the native features and requirements of each operating system.

## 7. Key VisioForge SDK Components Used

This application leverages several key components from the VisioForge Media Player SDK X:

- **`VisioForge.Core.MediaPlayerX.MediaPlayerCoreX`:**
- The central engine for media playback. It handles opening media sources, controlling playback (play, pause, stop, seek, rate), managing audio and video, and providing status information (position, duration).
- Initialized in `MainViewModel` and linked to the `VideoViewIntf`.
- **`VisioForge.Core.UI.Avalonia.VideoView`:**
- An Avalonia control that serves as the rendering surface for video. It is declared in `MainView.axaml` and its reference (`IVideoView`) is passed to `MediaPlayerCoreX`.
- **`VisioForge.Core.Types.X.Sources.UniversalSourceSettings`:**
- Used to configure the media source. `UniversalSourceSettings.CreateAsync(filename)` automatically determines the best way to open a given file or URL.
- **`VisioForge.Core.VisioForgeX` static class:**
- **`InitSDK()`:** Initializes the VisioForge SDK. This must be called once at application startup (done in `MainViewModel` constructor in this example, but can also be done in `App.axaml.cs`).
- **`DestroySDK()`:** Releases all SDK resources. This must be called when the application is closing to prevent resource leaks (done in `MainViewModel.OnWindowClosing`).
- **Platform-Specific Libraries:**
- As detailed in the project setup and platform-specific sections, various NuGet packages like `VisioForge.CrossPlatform.Core.Windows.x64`, `VisioForge.CrossPlatform.Core.macOS`, `VisioForge.CrossPlatform.Core.Android`, and `VisioForge.CrossPlatform.Core.iOS` provide the necessary native binaries and bindings for each platform.
- **`VisioForge.Core.UI.Android.FileDialogHelper` (for Android):**
- Contains helper methods like `GetFilePathFromUri` to work with Android's file system and content URIs.

Understanding these components is crucial for working with the VisioForge SDK and extending the player's functionality.

## 8. Building and Running the Application

1. **Clone/Download the Source Code:** Obtain the `SimplePlayerMVVM` example project.
2. **Restore NuGet Packages:** Open the solution in your IDE and ensure all NuGet packages are restored for all projects.
3. **Select Startup Project and Target:**
   - **Desktop:** Set `SimplePlayerMVVM.Desktop` as the startup project. You can then run it directly on Windows, macOS, or Linux (ensure you have the .NET runtime for your OS).
   - **Android:** Set `SimplePlayerMVVM.Android` as the startup project. Select an Android emulator or connected device. Build and deploy.
     - Ensure Android SDK and emulators/devices are correctly configured in your IDE.
     - You might need to accept permission prompts on the device/emulator upon first launch.
   - **iOS:** Set `SimplePlayerMVVM.iOS` as the startup project. Select an iOS simulator or connected device (requires a macOS build machine and appropriate Apple Developer provisioning).
     - Ensure Xcode and developer tools are correctly configured.
     - You might need to trust the developer certificate on the device.
4. **Build and Run:** Build the selected startup project and run it.

## 9. Conclusion

This guide has demonstrated how to build a cross-platform media player using Avalonia UI with the MVVM pattern and the VisioForge Media Player SDK X. By leveraging a shared core project for ViewModels and Views, and handling platform-specifics in dedicated head projects, we can create a maintainable application that runs on a wide range of devices.

Key takeaways:

- The MVVM pattern helps separate concerns and improves testability.
- ReactiveUI simplifies implementing MVVM with Avalonia.
- VisioForge Media Player SDK X provides powerful media playback capabilities, with `MediaPlayerCoreX` as the core engine and `VideoView` for Avalonia UI integration.
- Platform-specific considerations, especially for file access and permissions, are handled through interfaces and platform-specific implementations.
- Proper initialization (`VisioForgeX.InitSDK()`) and cleanup (`VisioForgeX.DestroySDK()`) of the VisioForge SDK are essential.

You can extend this example by adding more features like playlist support, network streaming, video effects, or more advanced UI controls.

## Frequently Asked Questions

### Which platforms does the Avalonia video player support?

The Avalonia player runs on Windows, macOS, Linux, Android, and iOS from a single shared codebase. Each platform uses a dedicated head project (`SimplePlayerMVVM.Desktop`, `.Android`, `.iOS`) with platform-specific NuGet packages for the native GStreamer runtime. The core playback API (`MediaPlayerCoreX`) and `VideoView` control are identical across all targets.

### Is the MVVM pattern required to use the VisioForge SDK with Avalonia?

No. The SDK works with any architecture pattern including code-behind. This guide uses ReactiveUI for MVVM because it pairs well with Avalonia's binding system and improves testability. The core classes — `MediaPlayerCoreX` for playback and `VideoView` for rendering — have no dependency on ReactiveUI or any MVVM framework. You can also use CommunityToolkit.Mvvm or Prism instead.

### How do I deploy the Avalonia video player to Linux?

Publish with `dotnet publish -r linux-x64` (or `linux-arm64` for ARM). On the target machine, install the GStreamer runtime (`libgstreamer1.0-0` and plugin packages on Ubuntu/Debian, or the equivalent on your distribution). The VisioForge NuGet packages include the native bindings, but GStreamer itself must be present on the system. No X11 or Wayland-specific configuration is needed — Avalonia handles display server selection automatically.

### Does the Avalonia player support GPU-accelerated video rendering?

Yes. `VideoView` uses platform-native GPU rendering: Direct3D on Windows, OpenGL or Vulkan on Linux, and Metal on macOS and iOS. The GStreamer engine also supports hardware-accelerated video decoding through VA-API on Linux, DXVA/D3D11 on Windows, and VideoToolbox on macOS/iOS. Hardware acceleration is enabled by default when a compatible GPU is available.

### How do I handle file access and storage permissions on Android and iOS?

Implement a platform-specific `IFilePickerService` interface as shown in section 6 of this guide. On Android, use `Intent` with `ActionOpenDocument` and declare `READ_EXTERNAL_STORAGE` permission in `AndroidManifest.xml`. On iOS, use `UIDocumentPickerViewController` to present the system file picker. On desktop, use Avalonia's built-in `StorageProvider.OpenFilePickerAsync()`. The SDK accepts any readable file path or stream regardless of how the file was selected.

## See Also

- [Build a Video Player in C#](../video-player-csharp/) — WinForms and WPF player with simpler single-project setup
- [.NET MAUI Player](../maui-player/) — mobile + desktop (iOS, Android, macOS, Windows) from one C# codebase
- [Build a Video Player in VB.NET](../video-player-vb-net/) — VB.NET media player for WinForms
- [Loop Mode and Position Range](../loop-and-position-range/) — configure looping, A-B repeat, and segment playback
- [Code Samples](../../code-samples/) — frame extraction, playlists, and additional playback examples
- [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) — product page and downloads

---END OF PAGE---


## Advanced Video Playback Guides and Tutorials in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/guides/
**Description:** Master loop playback, position range, and platform-specific features with VisioForge Media Player SDK .NET guides, code samples, and tutorials.
**Tags:** Media Player SDK, .NET, DirectShow, Windows, macOS, Linux, Android, iOS, Playback, Editing
**API:** MediaPlayerCoreX, VideoView

# Advanced Media Player SDK .Net Guides & Tutorials

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

## Overview

Explore advanced implementation techniques, specialized usage guides, and tutorials for the Media Player SDK .Net. These resources address specific development scenarios that require custom approaches, including loop playback, position range control, platform-specific implementations, and more.

## Available Guides

This curated collection of guides addresses specific advanced functionalities within the Media Player SDK .Net. Each guide provides practical instructions and insights to help you implement complex features effectively.

### Getting Started Guides

- [**Build a Video Player in C# (WinForms / WPF)**](video-player-csharp/) - Step-by-step guide to building a Windows desktop video player in C# with file playback, timeline seeking, pause/resume, volume control, and playback speed adjustment using MediaPlayerCoreX.
- [**Avalonia Cross-Platform Player**](avalonia-player/) - Full MVVM video player for Windows, macOS, and Linux from one Avalonia codebase.
- [**.NET MAUI Video Player**](maui-player/) - Ship one C# codebase to iOS, Android, macOS, and Windows using the MAUI `VideoView` control and `MediaPlayerCoreX`.
- [**Build a Video Player in VB.NET**](video-player-vb-net/) - Complete VB.NET guide for building a video player application with playback controls, timeline seeking, volume adjustment, and speed control with full Visual Basic code examples.

### Playback Control & Features

Explore specialized guides on controlling media playback with advanced features.

- [**Loop Mode and Position Range Playback**](loop-and-position-range/) - Master loop playback and custom start-stop position (segment playback) features for both MediaPlayerCore (DirectShow) and MediaPlayerCoreX (GStreamer) engines. This comprehensive guide covers automatic restart when media reaches the end, playing specific segments between start and stop positions, and combining both for continuous segment loops. Learn how to implement video loops for kiosks or displays, create preview playback windows, test specific portions of media files, and build seamless background video loops. The guide includes detailed property references, events, code examples, best practices, troubleshooting tips, and a comparison table between both engines to help you choose the right approach for your application.

### Platform-Specific Implementation

Learn how to implement Media Player SDK .Net across different platforms and UI frameworks.

- [**Avalonia Player Implementation**](avalonia-player/) - Comprehensive guide for implementing media playback in cross-platform Avalonia applications. Covers setup, integration, and platform-specific considerations for Windows, Linux, and macOS. Includes complete code examples and best practices for building professional media player applications with Avalonia UI framework.
- [**Android Player Implementation**](android-player/) - Step-by-step guide for integrating media playback in Android applications using MediaPlayerCoreX. Learn how to set up video rendering, handle Android lifecycle events, manage permissions, and implement player controls in Android native and MAUI applications.

## Additional Resources

Beyond the specific guides listed above, we offer a wealth of supplementary materials to support your development journey with the Media Player SDK .Net.

### Code Samples

Our extensive [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) contains practical implementation examples. These samples demonstrate various SDK capabilities across different .NET frameworks including WPF, WinForms, WinUI, Avalonia, MAUI, Android, and iOS.

### Technical Support

If you encounter challenges during implementation, our technical documentation provides detailed solutions for common development questions.

---END OF PAGE---


## Loop Video Playback and Position Range in C# .NET SDK
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/guides/loop-and-position-range/
**Description:** Implement loop playback and position range control with VisioForge Media Player SDK .NET. DirectShow and GStreamer engine examples included.
**Tags:** Media Player SDK, .NET, DirectShow, MediaPlayerCoreX, MediaBlocksPipeline, Windows, macOS, Linux, Android, iOS, GStreamer, Playback, Streaming, MP4, C#
**API:** MediaPlayerCoreX, MediaPlayerCore, UniversalSourceSettings, MediaBlocksPipeline

# Loop Mode and Position Range Playback

This guide explains how to use loop mode and custom start-stop position (position range) features in the Media Player SDK for both MediaPlayerCore (DirectShow engine) and MediaPlayerCoreX (GStreamer engine).

## Overview

Both Media Player engines support:

- **Loop Mode**: Automatically restart playback when media reaches the end
- **Position Range**: Play only a specific segment of media between start and stop positions
- **Combined Mode**: Loop a specific segment of media continuously

These features are useful for:

- Creating video loops for kiosks or displays
- Preview playback of specific segments
- Testing specific portions of media files
- Creating seamless background video loops
- Educational applications showing repeated content

## MediaPlayerCore (DirectShow Engine)

MediaPlayerCore is the Windows-only DirectShow-based media player engine.

### Loop Mode Properties

#### `Loop` Property

Enables or disables automatic loop playback.

```
// Enable loop mode
mediaPlayer.Loop = true;

// Disable loop mode
mediaPlayer.Loop = false;
```

**Default value**: `false`

**Behavior**: - When enabled, playback automatically restarts from the beginning when the end is reached - The `OnLoop` event fires each time playback restarts - For playlists, loops the entire playlist, not individual files

#### `Loop_DoNotSeekToBeginning` Property

Controls whether to seek to the beginning when loop restarts.

```
// Restart without seeking to beginning (seamless loop)
mediaPlayer.Loop_DoNotSeekToBeginning = true;

// Seek to beginning before restarting (default)
mediaPlayer.Loop_DoNotSeekToBeginning = false;
```

**Default value**: `false`

**Behavior**: - Only affects behavior when `Loop` is `true` - When `true`, restarts from current position without seeking - Improves performance and avoids visual glitches during loop transitions - Useful for seamless looping of content

### Position Range Properties

#### `Selection_Active` Property

Enables or disables playback range selection.

```
// Enable position range playback
mediaPlayer.Selection_Active = true;

// Disable position range playback (play entire file)
mediaPlayer.Selection_Active = false;
```

**Default value**: `false`

**Behavior**: - When active, playback is constrained between `Selection_Start` and `Selection_Stop` - The player automatically stops or loops when reaching `Selection_Stop` - Useful for playing specific segments or creating clip previews

#### `Selection_Start` Property

Sets the start position for range-based playback.

```
// Start playback at 30 seconds
mediaPlayer.Selection_Start = TimeSpan.FromSeconds(30);

// Start playback at 2 minutes 15 seconds
mediaPlayer.Selection_Start = new TimeSpan(0, 2, 15);
```

**Type**: `TimeSpan`

**Requirements**: - Only used when `Selection_Active` is `true` - Must be less than `Selection_Stop` - Must be within media duration - The player automatically seeks to this position when starting

#### `Selection_Stop` Property

Sets the end position for range-based playback.

```
// Stop playback at 1 minute
mediaPlayer.Selection_Stop = TimeSpan.FromSeconds(60);

// Play to the end of file
mediaPlayer.Selection_Stop = TimeSpan.Zero;
```

**Type**: `TimeSpan`

**Requirements**: - Only used when `Selection_Active` is `true` - Must be greater than `Selection_Start` - Use `TimeSpan.Zero` to play to the end of the media file - When playback reaches this position, it stops (or loops if `Loop` is enabled)

### MediaPlayerCore Events

#### `OnLoop` Event

Fires each time playback restarts in loop mode.

```
mediaPlayer.OnLoop += (sender, e) =>
{
    Console.WriteLine("Playback looped!");
    // Update loop counter, perform actions at loop point, etc.
};
```

**When it fires**: - Only when `Loop` property is `true` - Each time playback cycles from end to beginning - After seeking to the beginning (if applicable)

**Use cases**: - Track loop iterations - Update loop counters in UI - Perform actions at each loop point - Log playback statistics

### Code Examples for MediaPlayerCore

#### Example 1: Basic Loop Mode

```
using VisioForge.Core.MediaPlayer;
using VisioForge.Core.Types;

// Create media player instance
var player = new MediaPlayerCore();

// Enable loop mode
player.Loop = true;

// Subscribe to loop event
player.OnLoop += (sender, e) =>
{
    Console.WriteLine($"Loop iteration at {DateTime.Now}");
};

// Set source and play
player.Playlist_Clear();
player.Playlist_Add(@"C:\Videos\sample.mp4");
await player.PlayAsync();
```

#### Example 2: Seamless Loop Without Seeking

```
using VisioForge.Core.MediaPlayer;

var player = new MediaPlayerCore();

// Enable seamless loop (no seeking to beginning)
player.Loop = true;
player.Loop_DoNotSeekToBeginning = true;

player.Playlist_Clear();
player.Playlist_Add(@"C:\Videos\background.mp4");
await player.PlayAsync();
```

#### Example 3: Play Specific Segment

```
using VisioForge.Core.MediaPlayer;

var player = new MediaPlayerCore();

// Enable position range
player.Selection_Active = true;

// Play from 1 minute to 2 minutes
player.Selection_Start = TimeSpan.FromMinutes(1);
player.Selection_Stop = TimeSpan.FromMinutes(2);

player.Playlist_Clear();
player.Playlist_Add(@"C:\Videos\long-video.mp4");
await player.PlayAsync();
```

#### Example 4: Loop Specific Segment

```
using VisioForge.Core.MediaPlayer;

var player = new MediaPlayerCore();

// Enable both loop and position range
player.Loop = true;
player.Selection_Active = true;

// Loop segment from 30 to 45 seconds
player.Selection_Start = TimeSpan.FromSeconds(30);
player.Selection_Stop = TimeSpan.FromSeconds(45);

// Track loop count
int loopCount = 0;
player.OnLoop += (sender, e) =>
{
    loopCount++;
    Console.WriteLine($"Segment loop #{loopCount}");
};

player.Playlist_Clear();
player.Playlist_Add(@"C:\Videos\video.mp4");
await player.PlayAsync();
```

#### Example 5: Dynamic Position Range Update

```
using VisioForge.Core.MediaPlayer;

var player = new MediaPlayerCore();

player.Selection_Active = true;
player.Selection_Start = TimeSpan.FromSeconds(10);
player.Selection_Stop = TimeSpan.FromSeconds(20);

player.Playlist_Clear();
player.Playlist_Add(@"C:\Videos\video.mp4");
await player.PlayAsync();

// Later, during playback, update the range
await Task.Delay(5000);

// Change to different segment
player.Selection_Start = TimeSpan.FromSeconds(30);
player.Selection_Stop = TimeSpan.FromSeconds(40);

// Seek to new start position
player.Position_Set_Time(player.Selection_Start);
```

## MediaPlayerCoreX (GStreamer Engine)

MediaPlayerCoreX is the cross-platform GStreamer-based media player engine, supporting Windows, Linux, macOS, Android, and iOS.

### Loop Mode Property

#### `Loop` Property

Enables or disables automatic loop playback.

```
// Enable loop mode
mediaPlayer.Loop = true;

// Disable loop mode
mediaPlayer.Loop = false;
```

**Default value**: `false`

**Behavior**: - When enabled, playback automatically restarts when end-of-stream (EOS) is reached - The underlying `MediaBlocksPipeline` handles the loop logic - The `OnLoop` event fires each time playback restarts - Seamlessly restarts playback without seeking overhead

### Position Range Properties

#### `Segment_Start` Property

Sets the start position for segment playback.

```
// Start playback at 45 seconds
mediaPlayer.Segment_Start = TimeSpan.FromSeconds(45);

// Start playback at 3 minutes
mediaPlayer.Segment_Start = TimeSpan.FromMinutes(3);
```

**Type**: `TimeSpan`

**Default value**: `TimeSpan.Zero`

**Behavior**: - Defines where playback should begin - The player automatically seeks to this position when starting - Used in combination with `Segment_Stop` to define playback range - Applied through the underlying `MediaBlocksPipeline.StartPosition` property

#### `Segment_Stop` Property

Sets the end position for segment playback.

```
// Stop playback at 2 minutes
mediaPlayer.Segment_Stop = TimeSpan.FromMinutes(2);

// Play to the end (no stop position)
mediaPlayer.Segment_Stop = TimeSpan.Zero;
```

**Type**: `TimeSpan`

**Default value**: `TimeSpan.Zero`

**Behavior**: - Defines where playback should end - When playback reaches this position, end-of-stream (EOS) is triggered - If `Loop` is enabled, playback restarts from `Segment_Start` - Use `TimeSpan.Zero` for no stop position (play to end) - Applied through the underlying `MediaBlocksPipeline.StopPosition` property

### MediaPlayerCoreX Events

#### `OnLoop` Event

Fires each time playback restarts in loop mode.

```
mediaPlayer.OnLoop += (sender, e) =>
{
    Console.WriteLine("Playback looped!");
};
```

**When it fires**: - Only when `Loop` property is `true` - When end-of-stream (EOS) is reached - Before playback restarts

### Code Examples for MediaPlayerCoreX

#### Example 1: Basic Loop Mode

```
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types.X.Sources;

// Create media player instance
var player = new MediaPlayerCoreX();

// Enable loop mode
player.Loop = true;

// Subscribe to loop event
player.OnLoop += (sender, e) =>
{
    Console.WriteLine($"Loop iteration at {DateTime.Now}");
};

// Set source and play
var source = await UniversalSourceSettings.CreateAsync(new Uri(@"C:\Videos\sample.mp4"));

await player.OpenAsync(source);
await player.PlayAsync();
```

#### Example 2: Play Specific Segment

```
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types.X.Sources;

var player = new MediaPlayerCoreX();

// Set segment range: play from 30s to 90s
player.Segment_Start = TimeSpan.FromSeconds(30);
player.Segment_Stop = TimeSpan.FromSeconds(90);

var source = await UniversalSourceSettings.CreateAsync(new Uri(@"C:\Videos\long-video.mp4"));

await player.OpenAsync(source);
await player.PlayAsync();
```

#### Example 3: Loop Specific Segment

```
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types.X.Sources;

var player = new MediaPlayerCoreX();

// Enable loop and set segment
player.Loop = true;
player.Segment_Start = TimeSpan.FromMinutes(1);
player.Segment_Stop = TimeSpan.FromMinutes(2);

// Track loop count
int loopCount = 0;
player.OnLoop += (sender, e) =>
{
    loopCount++;
    Console.WriteLine($"Segment loop #{loopCount}");
};

var source = await UniversalSourceSettings.CreateAsync(new Uri(@"C:\Videos\video.mp4"));

await player.OpenAsync(source);
await player.PlayAsync();
```

#### Example 4: Cross-Platform Looping Video

```
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types.X.Sources;

var player = new MediaPlayerCoreX();

// Enable seamless loop
player.Loop = true;

// For cross-platform video file path
string videoPath;
#if ANDROID
    videoPath = "/storage/emulated/0/Movies/background.mp4";
#elif IOS
    videoPath = Path.Combine(NSBundle.MainBundle.BundlePath, "background.mp4");
#else
    videoPath = Path.Combine(Environment.GetFolderPath(
        Environment.SpecialFolder.MyVideos), "background.mp4");
#endif

var source = await UniversalSourceSettings.CreateAsync(new Uri(videoPath));

await player.OpenAsync(source);
await player.PlayAsync();
```

#### Example 5: Segment Preview with UI Update

```
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types.X.Sources;

var player = new MediaPlayerCoreX();

// Preview mode: show 10 second clips
TimeSpan clipDuration = TimeSpan.FromSeconds(10);

async Task PreviewSegment(TimeSpan startTime)
{
    player.Segment_Start = startTime;
    player.Segment_Stop = startTime + clipDuration;

    // Seek to start position
    await player.Position_SetAsync(startTime);

    Console.WriteLine($"Previewing segment: {startTime} to {startTime + clipDuration}");
}

var source = await UniversalSourceSettings.CreateAsync(new Uri(@"C:\Videos\movie.mp4"));

await player.OpenAsync(source);
await player.PlayAsync();

// Preview first segment
await PreviewSegment(TimeSpan.FromSeconds(0));

// Preview segment starting at 30 seconds
await Task.Delay(11000);
await PreviewSegment(TimeSpan.FromSeconds(30));
```

#### Example 6: Loop with Pause-on-Stop

```
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types.X.Sources;

var player = new MediaPlayerCoreX();

// Loop mode with pause instead of stop at end
player.Loop = true;
player.PauseOnStop = true; // Pause instead of stop at EOS

player.OnLoop += (sender, e) =>
{
    Console.WriteLine("Reached end, pausing briefly before loop...");

    // Wait before resuming (if needed)
    Task.Delay(1000).ContinueWith(_ =>
    {
        // Playback will restart automatically due to Loop = true
    });
};

var source = await UniversalSourceSettings.CreateAsync(new Uri(@"C:\Videos\video.mp4"));

await player.OpenAsync(source);
await player.PlayAsync();
```

## Best Practices

### Performance Considerations

1. **Seamless Looping (MediaPlayerCore)**:
2. Use `Loop_DoNotSeekToBeginning = true` for seamless loops without visual glitches
3. Test with your specific media format for best results
4. **Short Segments**:
5. For very short segments (< 1 second), ensure media is properly indexed
6. Some formats may not support frame-accurate seeking
7. **Cross-Platform (MediaPlayerCoreX)**:
8. Test on all target platforms as GStreamer behavior may vary slightly
9. Use appropriate video codecs that support seeking (H.264, H.265)

### Common Use Cases

#### Kiosk Video Loop

```
// MediaPlayerCore (Windows)
player.Loop = true;
player.Loop_DoNotSeekToBeginning = true;

// MediaPlayerCoreX (Cross-platform)
player.Loop = true;
```

#### Preview Window

```
// MediaPlayerCore
player.Selection_Active = true;
player.Selection_Start = previewStart;
player.Selection_Stop = previewEnd;

// MediaPlayerCoreX
player.Segment_Start = previewStart;
player.Segment_Stop = previewEnd;
```

#### Continuous Segment Loop

```
// MediaPlayerCore
player.Loop = true;
player.Selection_Active = true;
player.Selection_Start = segmentStart;
player.Selection_Stop = segmentEnd;

// MediaPlayerCoreX
player.Loop = true;
player.Segment_Start = segmentStart;
player.Segment_Stop = segmentEnd;
```

### Troubleshooting

#### Loop Not Working

**MediaPlayerCore**: - Ensure `Loop` property is set before calling `PlayAsync()` - Check that `OnStop` event is not calling `Stop()` method - Verify media file is not corrupted

**MediaPlayerCoreX**: - Ensure `Loop` property is set before calling `PlayAsync()` - Check GStreamer is properly initialized - Verify the pipeline is not being disposed prematurely

#### Position Range Not Accurate

**MediaPlayerCore**: - Ensure `Selection_Active` is set to `true` - Verify `Selection_Start` < `Selection_Stop` - Some media formats may not support frame-accurate seeking

**MediaPlayerCoreX**: - Verify `Segment_Start` and `Segment_Stop` are valid - Use seekable media formats (MP4, MKV with proper indexing) - Check that the media file supports seeking (not all streaming sources do)

#### Segment Playback Starts at Wrong Position

**Both Engines**: - Ensure positions are set before calling `PlayAsync()` - Wait for media to be fully loaded before setting positions - Use keyframe-based seeking for better accuracy

## Property Comparison Table

| Feature | MediaPlayerCore | MediaPlayerCoreX |
| --- | --- | --- |
| **Loop Mode** | `Loop` (bool) | `Loop` (bool) |
| **Seamless Loop** | `Loop_DoNotSeekToBeginning` (bool) | Built-in (no extra property) |
| **Range Active** | `Selection_Active` (bool) | Implicit (when Segment properties set) |
| **Start Position** | `Selection_Start` (TimeSpan) | `Segment_Start` (TimeSpan) |
| **Stop Position** | `Selection_Stop` (TimeSpan) | `Segment_Stop` (TimeSpan) |
| **Loop Event** | `OnLoop` | `OnLoop` |
| **Platform** | Windows only | Cross-platform |
| **Engine** | DirectShow | GStreamer |

## Frequently Asked Questions

### How do I create a seamless video loop without glitches in C#?

For the DirectShow engine (MediaPlayerCore), set `Loop = true` and `Loop_DoNotSeekToBeginning = true` to avoid a visible seek-back between iterations. For the cross-platform GStreamer engine (MediaPlayerCoreX), seamless restart is built in — simply set `Loop = true`. In both cases, use well-indexed formats like MP4 with H.264 or H.265 encoding for the smoothest transitions.

### Does the Media Player SDK support frame-accurate seeking for segment playback?

Seeking accuracy depends on the media container and codec. MP4 and MKV files with proper keyframe indexing provide the best results. For very short segments (under one second), the player may land on the nearest keyframe rather than the exact requested position. If frame-level precision is critical, encode your source with a short GOP (Group of Pictures) length to increase keyframe density.

### Can I loop a specific time range instead of the entire video file?

Yes. In MediaPlayerCore, enable `Loop` and `Selection_Active`, then set `Selection_Start` and `Selection_Stop` to define the segment. In MediaPlayerCoreX, enable `Loop` and set `Segment_Start` and `Segment_Stop`. The player will continuously repeat only the specified range. See the "Loop Specific Segment" code examples above for both engines.

## See Also

- [Build a Video Player in C#](../video-player-csharp/) — full player implementation with playback controls and seeking
- [.NET MAUI Player](../maui-player/) — iOS, Android, macOS, and Windows from one C# codebase
- [Avalonia Media Player](../avalonia-player/) — cross-platform player with MVVM pattern
- [Build a Video Player in VB.NET](../video-player-vb-net/) — VB.NET player with seeking and volume control
- [Code Samples](../../code-samples/) — frame extraction, playlists, and reverse playback examples
- [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) — product page and downloads

---END OF PAGE---


## .NET MAUI Video Player in C# — iOS, Android, Windows
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/guides/maui-player/
**Description:** Build a .NET MAUI video player in C# that runs on iOS, Android, macOS, and Windows from one codebase using VisioForge Media Player SDK's VideoView control.
**Tags:** Media Player SDK, .NET, MediaPlayerCoreX, Windows, macOS, Android, iOS, MAUI, Playback, Streaming, MPEG-DASH, C#, NuGet, Entitlements
**API:** VideoView, MediaPlayerCoreX, UniversalSourceSettings, IVideoView, ValueChangedEventArgs

# Build a .NET MAUI Video Player in C

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

.NET MAUI lets you ship one C# codebase to **iOS, Android, macOS, and Windows**. This guide wires up the VisioForge `VideoView` control with `MediaPlayerCoreX` to play local files and network streams — a focused starter that mirrors the [Simple Player MAUI demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK%20X/MAUI/SimplePlayer).

> **Choosing a framework?** Avalonia (desktop-first, includes Linux) → [Avalonia Player Guide](../avalonia-player/). WinForms / WPF (Windows desktop) → [Build a Video Player in C#](../video-player-csharp/). Android-only (no MAUI) → [Android Player Guide](../android-player/).

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Prerequisites

- .NET 8 SDK (or newer) with MAUI workload: `dotnet workload install maui`
- Platform toolchains for the targets you ship to (Xcode for iOS/macCatalyst, Android SDK for Android)
- See the [MAUI installation guide](../../../install/maui/) for full platform setup details

## NuGet Packages

```
<PackageReference Include="VisioForge.DotNet.MediaPlayer" Version="2026.8.16" />
<PackageReference Include="VisioForge.DotNet.Core.UI.MAUI" Version="2026.8.16" />

<!-- Platform redists — include only the targets you build for -->
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29"
                  Condition="$(TargetFramework.Contains('windows'))" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29"
                  Condition="$(TargetFramework.Contains('windows'))" />
<PackageReference Include="VisioForge.CrossPlatform.Core.macCatalyst" Version="2026.8.5"
                  Condition="$(TargetFramework.Contains('maccatalyst'))" />
<PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.7.27"
                  Condition="$(TargetFramework.Contains('android'))" />
<PackageReference Include="VisioForge.CrossPlatform.Core.iOS" Version="2025.12.0"
                  Condition="$(TargetFramework.Contains('ios'))" />
```

## MauiProgram.cs

Register the VisioForge handlers so MAUI can resolve the `VideoView` control:

```
using VisioForge.Core.UI.MAUI;

public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .UseSkiaSharp()
        .ConfigureMauiHandlers(handlers => handlers.AddVisioForgeHandlers());

    return builder.Build();
}
```

## XAML Layout

Drop a `VideoView` into your page alongside a seek slider and playback buttons:

```
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:my="clr-namespace:VisioForge.Core.UI.MAUI;assembly=VisioForge.Core.UI.MAUI"
             x:Class="MauiPlayerDemo.MainPage">

    <Grid RowDefinitions="*,Auto" RowSpacing="0">
        <my:VideoView Grid.Row="0" x:Name="videoView"
                      HorizontalOptions="FillAndExpand"
                      VerticalOptions="FillAndExpand"
                      Background="Black" />

        <VerticalStackLayout Grid.Row="1" Spacing="4" Padding="12,8">
            <Slider x:Name="slSeeking" ValueChanged="slSeeking_ValueChanged" />

            <Grid ColumnDefinitions="*,*,*" ColumnSpacing="8">
                <Button Grid.Column="0" x:Name="btOpen"
                        Text="OPEN" Clicked="btOpen_Clicked" />
                <Button Grid.Column="1" x:Name="btPlayPause"
                        Text="PLAY" Clicked="btPlayPause_Clicked" />
                <Button Grid.Column="2" x:Name="btStop"
                        Text="STOP" Clicked="btStop_Clicked" />
            </Grid>

            <Slider x:Name="slVolume" Minimum="0" Maximum="100" Value="50"
                    ValueChanged="slVolume_ValueChanged" />
        </VerticalStackLayout>
    </Grid>
</ContentPage>
```

## Code-Behind: Player Setup

`VideoView.GetVideoView()` returns an `IVideoView` bridge that `MediaPlayerCoreX` consumes identically on every MAUI target (WinUI, macCatalyst, AndroidX, UIKit):

```
using VisioForge.Core;
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.AudioRenderers;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.UI.MAUI;

public partial class MainPage : ContentPage
{
    private MediaPlayerCoreX _player;
    private System.Timers.Timer _positionTimer = new(500);
    private string _filename;
    private volatile bool _isTimerUpdate;

    public MainPage()
    {
        InitializeComponent();
        Loaded += MainPage_Loaded;
        _positionTimer.Elapsed += PositionTimer_Elapsed;
    }

    private async void MainPage_Loaded(object sender, EventArgs e)
    {
        // Loads the native GStreamer stack. It has to run before the first MediaPlayerCoreX
        // is constructed, otherwise the constructor throws DllNotFoundException.
        await VisioForgeX.InitSDKAsync();

        IVideoView vv = videoView.GetVideoView();
        _player = new MediaPlayerCoreX(vv);

        _player.OnError += (_, args) => Debug.WriteLine(args.Message);
        _player.OnStop  += Player_OnStop;

        // iOS does not enumerate audio output devices — skip the picker there.
#if !__IOS__ || __MACCATALYST__
        var outputs = await _player.Audio_OutputDevicesAsync();
        if (outputs.Length > 0)
            _player.Audio_OutputDevice = new AudioRendererSettings(outputs[0]);
#endif

        Window.Destroying += async (_, _) =>
        {
            if (_player != null)
            {
                await _player.StopAsync();
                await _player.DisposeAsync();
                _player = null;
            }
            VisioForgeX.DestroySDK();
        };
    }
}
```

## Open a File with `FilePicker`

```
private async void btOpen_Clicked(object sender, EventArgs e)
{
    var result = await FilePicker.Default.PickAsync();
    if (result == null) return;

    _filename = result.FullPath;

    var source = await UniversalSourceSettings.CreateAsync(new Uri(_filename));
    await _player.OpenAsync(source);
    await _player.PlayAsync();

    _positionTimer.Start();
    btPlayPause.Text = "PAUSE";
}
```

You can pass any supported URI (HTTP, HLS, RTSP) to `UniversalSourceSettings.CreateAsync` — the same code path plays network streams on mobile.

## Play / Pause / Stop

`MediaPlayerCoreX.State` exposes the current `PlaybackState` so one button can cover the full lifecycle:

```
private async void btPlayPause_Clicked(object sender, EventArgs e)
{
    if (_player == null || string.IsNullOrEmpty(_filename)) return;

    switch (_player.State)
    {
        case PlaybackState.Play:
            await _player.PauseAsync();
            btPlayPause.Text = "PLAY";
            break;
        case PlaybackState.Pause:
            await _player.ResumeAsync();
            btPlayPause.Text = "PAUSE";
            break;
        case PlaybackState.Free:
            var source = await UniversalSourceSettings.CreateAsync(new Uri(_filename));
            await _player.OpenAsync(source);
            await _player.PlayAsync();
            _positionTimer.Start();
            btPlayPause.Text = "PAUSE";
            break;
    }
}

private async void btStop_Clicked(object sender, EventArgs e)
{
    _positionTimer.Stop();
    if (_player != null) await _player.StopAsync();
    btPlayPause.Text = "PLAY";
}
```

## Seeking and Volume

The seek slider and volume slider both route through the timer flag so timer-driven position updates do not fight user drags:

```
private async void PositionTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
    if (_player == null) return;

    var position = await _player.Position_GetAsync();
    var duration = await _player.DurationAsync();

    await MainThread.InvokeOnMainThreadAsync(() =>
    {
        _isTimerUpdate = true;
        slSeeking.Maximum = duration.TotalMilliseconds;
        slSeeking.Value   = Math.Min(position.TotalMilliseconds, slSeeking.Maximum);
        _isTimerUpdate = false;
    });
}

private async void slSeeking_ValueChanged(object sender, ValueChangedEventArgs e)
{
    if (!_isTimerUpdate && _player != null)
        await _player.Position_SetAsync(TimeSpan.FromMilliseconds(e.NewValue));
}

private void slVolume_ValueChanged(object sender, ValueChangedEventArgs e)
{
    if (_player != null)
        _player.Audio_OutputDevice_Volume = e.NewValue / 100.0;
}

private void Player_OnStop(object sender, StopEventArgs e)
    => MainThread.BeginInvokeOnMainThread(() =>
    {
        btPlayPause.Text = "PLAY";
        slSeeking.Value  = 0;
    });
```

## Platform Notes

- **iOS** — add the [App Transport Security](../../../install/maui/) exceptions for HTTP (non-HTTPS) streams and the microphone/photo-library usage descriptions you need. `_player.Audio_OutputDevicesAsync()` is not available on iOS — the renderer picks the active output automatically.
- **Android** — declare `INTERNET` permission for network streams; for local-file playback on API 33+ you need `READ_MEDIA_VIDEO` or a user-granted `FilePicker` URI.
- **macCatalyst** — use `VisioForge.CrossPlatform.Core.macCatalyst`; hardware decoding runs through `VideoToolbox`.
- **Windows (WinUI)** — use the `Windows.x64` + `Libav.Windows.x64` redists; hardware decoding goes through `d3d11va` / `nvdec` / `qsv` depending on the GPU.

Full platform-specific wiring (entitlements, manifests, provisioning) lives in the [MAUI installation guide](../../../install/maui/).

## Supported Formats

| Category | Formats |
| --- | --- |
| Containers | MP4, MOV, MKV, WebM, AVI, TS, FLV |
| Video codecs | H.264, H.265/HEVC, VP8, VP9, AV1, MPEG-2 |
| Audio codecs | AAC, MP3, Opus, Vorbis, FLAC, AC-3 |
| Streaming | HTTP, HLS, RTSP, MPEG-DASH |

## Sample Applications

- [MAUI SimplePlayer (Media Player SDK X)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK%20X/MAUI/SimplePlayer) — the full working source behind this tutorial
- [MAUI SimplePlayer (Media Blocks SDK)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/MAUI/SimplePlayer) — the same app built on the pipeline API, if you need custom processing

## See Also

- [Avalonia Cross-Platform Player](../avalonia-player/) — desktop-first cross-platform (includes Linux)
- [Build a Video Player in C#](../video-player-csharp/) — WinForms/WPF on Windows
- [Android Player Guide](../android-player/) — Android-specific setup and deployment
- [Media Blocks Pipeline Player](../../../mediablocks/GettingStarted/player/) — block-based alternative with explicit video/audio renderers
- [MAUI Installation Guide](../../../install/maui/) — platform entitlements, workloads, and redist packaging

---END OF PAGE---


## C# Video Player for WinForms & WPF — Seek & Volume Controls
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/guides/video-player-csharp/
**Description:** Build a C# video player for Windows WinForms or WPF desktop apps with VisioForge Media Player SDK .Net — seeking, volume, speed, and subtitle support.
**Tags:** Media Player SDK, .NET, MediaPlayerCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Playback, Streaming, Editing, RTSP, MPEG-DASH, MP4, MKV, WebM, AVI, MOV, WMV, H.265, C#, NuGet
**API:** MediaPlayerCoreX, VideoView, UniversalSourceSettings, AudioRendererSettings, ErrorsEventArgs

# Build a C# Video Player for WinForms & WPF

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

This guide shows you how to build a full-featured **Windows desktop** video player in C# using [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) with the high-level `MediaPlayerCoreX` engine. You will wire up file playback, timeline seeking, pause/resume, volume, and playback speed against a WinForms or WPF `VideoView` control.

Choose your approach

This page is for **Windows desktop apps** (WinForms or WPF) using Media Player SDK .Net.

- **Cross-platform desktop (includes Linux)** → [Avalonia Player Guide](../avalonia-player/)
- **Mobile + desktop from one codebase (iOS, Android, macOS, Windows)** → [.NET MAUI Player Guide](../maui-player/)
- **Android only** → [Android Player Guide](../android-player/)
- **Visual Basic .NET** → [VB.NET Video Player Guide](../video-player-vb-net/)
- **Pipeline-based (block graph with explicit renderers)** → [Media Blocks SDK Player](../../../mediablocks/GettingStarted/player/)

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## MediaPlayerCoreX Approach

`MediaPlayerCoreX` is the simplest way to build a video player in C# with full playback control.

### Required NuGet Packages

```
<PackageReference Include="VisioForge.DotNet.MediaPlayer" Version="2026.2.19" />
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />
```

### Complete C# Video Player Implementation

```
using VisioForge.Core;
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.AudioRenderers;
using VisioForge.Core.Types.X.Sources;

public partial class Form1 : Form
{
    private MediaPlayerCoreX _player;
    private System.Timers.Timer _timer;
    private bool _timerFlag;

    private async void Form1_Load(object sender, EventArgs e)
    {
        // Initialize the SDK
        await VisioForgeX.InitSDKAsync();

        _timer = new System.Timers.Timer(500);
        _timer.Elapsed += Timer_Elapsed;

        // Create the player engine with the VideoView control
        _player = new MediaPlayerCoreX(VideoView1);
        _player.OnError += Player_OnError;
        _player.OnStop += Player_OnStop;

        // Populate audio output devices
        foreach (var device in await _player.Audio_OutputDevicesAsync(
            AudioOutputDeviceAPI.DirectSound))
        {
            cbAudioOutput.Items.Add(device.Name);
        }

        if (cbAudioOutput.Items.Count > 0)
            cbAudioOutput.SelectedIndex = 0;
    }
```

### Opening and Playing a Video File

```
    private void btOpenFile_Click(object sender, EventArgs e)
    {
        var ofd = new OpenFileDialog
        {
            Filter = "Video Files|*.mp4;*.avi;*.mkv;*.wmv;*.webm;*.mov;*.ts" +
                     "|Audio Files|*.mp3;*.aac;*.wav;*.wma|All Files|*.*"
        };

        if (ofd.ShowDialog() == DialogResult.OK)
            edFilename.Text = ofd.FileName;
    }

    private async void btStart_Click(object sender, EventArgs e)
    {
        // Set audio output device
        var devices = await _player.Audio_OutputDevicesAsync(
            AudioOutputDeviceAPI.DirectSound);
        var audioDevice = devices.First(x => x.Name == cbAudioOutput.Text);
        _player.Audio_OutputDevice = new AudioRendererSettings(audioDevice);

        // Open the media file
        var source = await UniversalSourceSettings.CreateAsync(
            new Uri(edFilename.Text));
        await _player.OpenAsync(source);

        // Start playback
        await _player.PlayAsync();

        _timer.Start();
    }
```

### Pause, Resume, and Stop

```
    private async void btPause_Click(object sender, EventArgs e)
    {
        await _player.PauseAsync();
    }

    private async void btResume_Click(object sender, EventArgs e)
    {
        await _player.ResumeAsync();
    }

    private async void btStop_Click(object sender, EventArgs e)
    {
        _timer.Stop();

        if (_player != null)
        {
            await _player.StopAsync();
        }

        tbTimeline.Value = 0;
    }
```

### Timeline Seeking

```
    private async void Timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
        _timerFlag = true;

        if (_player == null) return;

        var position = await _player.Position_GetAsync();
        var duration = await _player.DurationAsync();

        Invoke(() =>
        {
            tbTimeline.Maximum = (int)duration.TotalSeconds;
            lbTime.Text = $"{position:hh\\:mm\\:ss} / {duration:hh\\:mm\\:ss}";

            if (tbTimeline.Maximum >= position.TotalSeconds)
                tbTimeline.Value = (int)position.TotalSeconds;
        });

        _timerFlag = false;
    }

    private async void tbTimeline_Scroll(object sender, EventArgs e)
    {
        if (!_timerFlag && _player != null)
        {
            await _player.Position_SetAsync(
                TimeSpan.FromSeconds(tbTimeline.Value));
        }
    }
```

### Volume and Speed Control

```
    private void tbVolume_Scroll(object sender, EventArgs e)
    {
        if (_player != null)
            _player.Audio_OutputDevice_Volume = tbVolume.Value / 100.0;
    }

    private async void tbSpeed_Scroll(object sender, EventArgs e)
    {
        await _player.Rate_SetAsync(tbSpeed.Value / 10.0);
    }
```

### Error Handling and Cleanup

```
    private void Player_OnError(object sender, ErrorsEventArgs e)
    {
        Invoke(() => edLog.Text += e.Message + Environment.NewLine);
    }

    private void Player_OnStop(object sender, StopEventArgs e)
    {
        Invoke(() => tbTimeline.Value = 0);
    }

    private async void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        _timer.Stop();

        if (_player != null)
        {
            _player.OnError -= Player_OnError;
            _player.OnStop -= Player_OnStop;
            await _player.DisposeAsync();
        }

        VisioForgeX.DestroySDK();
    }
}
```

## Alternative: Media Blocks SDK Pipeline

If you need the extra flexibility of a block graph (custom processing, multiple sinks, overlays), the [Media Blocks SDK Player Guide](../../../mediablocks/GettingStarted/player/) builds an equivalent pipeline with `UniversalSourceBlock` + `VideoRendererBlock` + `AudioRendererBlock`. The code above uses Media Player SDK because it is purpose-built for this scenario — one `MediaPlayerCoreX` instance replaces the block wiring.

## Supported Formats

| Category | Formats |
| --- | --- |
| Video | MP4, AVI, MKV, WMV, WebM, MOV, TS, MTS, FLV |
| Audio | MP3, AAC, WAV, WMA, FLAC, OGG, Vorbis |
| Codecs | H.264, H.265/HEVC, VP8, VP9, AV1, MPEG-2 |
| Streaming | RTSP, HTTP, HLS, MPEG-DASH |

## Sample Applications

- [Simple Player Demo WPF (C#)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK%20X/WPF/Simple%20Player%20Demo)
- [Media Player Code Snippet (C#)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/_CodeSnippets/media-player)
- [WinForms Main Demo (C#)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK%20X/WinForms/Main%20Demo)

## Frequently Asked Questions

### What video formats does the .NET video player support?

The SDK supports all major video formats including MP4, AVI, MKV, WMV, WebM, MOV, TS, and FLV. Codec support includes H.264, H.265/HEVC, VP8, VP9, AV1, and MPEG-2 through the bundled GStreamer-based engine. Audio formats such as MP3, AAC, WAV, FLAC, and OGG are also supported for playback.

### Can I play RTSP streams or network video in my C# application?

Yes. The `UniversalSourceSettings.CreateAsync` method accepts URIs for RTSP, HTTP, HLS, and MPEG-DASH streams. Pass the stream URL as a `Uri` object just as you would a local file path. For RTSP sources that require authentication, include the credentials directly in the URI (e.g., `rtsp://user:password@host:554/stream`).

### How do I control playback speed in the video player?

Call `Rate_SetAsync(double rate)` on the player instance. A rate of 1.0 is normal speed, 2.0 is double speed, and 0.5 is half speed. The supported range depends on the media format, but most files support rates between 0.25x and 4.0x. The rate can be changed during playback without stopping the video.

### Does the SDK support subtitle rendering?

Yes. The SDK can render embedded subtitles from MKV and MP4 containers as well as external SRT and ASS subtitle files. Subtitle tracks are detected automatically when a file is opened, and you can select which track to display through the player API.

### Can I build a cross-platform video player with this SDK?

Yes. The SDK runs on Windows, macOS, Linux, Android, and iOS. For cross-platform desktop applications, use the [Avalonia UI framework](../avalonia-player/) with the same `MediaPlayerCoreX` API. The core playback engine is identical across platforms — only the video rendering surface and NuGet packages differ.

## See Also

- [Build a Video Player in VB.NET](../video-player-vb-net/) — same tutorial using VB.NET syntax
- [Avalonia Cross-Platform Player](../avalonia-player/) — build a video player for Windows, macOS, and Linux with Avalonia UI
- [.NET MAUI Player Guide](../maui-player/) — one C# codebase for iOS, Android, macOS, and Windows
- [Android Player Guide](../android-player/) — Android-specific player configuration and deployment
- [Loop Mode and Position Range](../loop-and-position-range/) — configure looping, A-B repeat, and segment playback
- [Media Blocks SDK Player](../../../mediablocks/GettingStarted/player/) — pipeline-based alternative with explicit renderers
- [Media Player SDK .Net Product Page](https://www.visioforge.com/media-player-sdk-net)

---END OF PAGE---


## VB.NET Video Player with Playback Controls and Seeking
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/guides/video-player-vb-net/
**Description:** Build a video player in VB.NET with playback controls, seeking, and volume adjustment. Complete code examples using VisioForge Media Player SDK .NET.
**Tags:** Media Player SDK, .NET, DirectShow, MediaPlayerCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Playback, Streaming, Editing, Webcam, MPEG-DASH, MP4, MKV, WebM, AVI, MOV, WMV, H.265, AAC, MP3, FLAC, WAV, WMA, VB.NET, NuGet
**API:** MediaPlayerCoreX, MediaPlayerCore

# Build a Video Player in VB.NET

This guide walks you through building a full-featured video player application in VB.NET (Visual Basic .NET) using [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net). The player supports MP4, AVI, MKV, WMV, WebM, and many other formats with playback controls, timeline seeking, and volume adjustment.

## Why Use Media Player SDK .Net for VB.NET

[Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) provides robust VB.NET video playback with:

- Support for all major video formats (MP4, AVI, MKV, WMV, WebM, MOV, TS)
- Audio format support (MP3, AAC, WAV, WMA, FLAC)
- Hardware-accelerated video decoding
- Timeline seeking and position tracking
- Volume and playback speed control
- WinForms and WPF UI integration

## Required NuGet Packages

```
<PackageReference Include="VisioForge.DotNet.MediaPlayer" Version="2026.2.19" />
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />
```

## Complete VB.NET Video Player Example

### SDK Initialization and Engine Setup

Initialize the SDK and create the player engine when the form loads:

```
Imports VisioForge.Core
Imports VisioForge.Core.MediaPlayerX
Imports VisioForge.Core.Types.Events
Imports VisioForge.Core.Types.X.AudioRenderers
Imports VisioForge.Core.Types.X.Sources

Public Class Form1
    Private WithEvents _timer As System.Timers.Timer
    Private _timerFlag As Boolean
    Private _player As MediaPlayerCoreX

    Private Async Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        ' Initialize the SDK
        Await VisioForgeX.InitSDKAsync()

        ' Set up a timer for timeline updates
        _timer = New System.Timers.Timer(500)
        AddHandler _timer.Elapsed, AddressOf _timer_Elapsed

        ' Create the player engine with the VideoView control
        CreateEngine()

        ' Enumerate audio output devices
        For Each device In Await _player.Audio_OutputDevicesAsync(AudioOutputDeviceAPI.DirectSound)
            cbAudioOutput.Items.Add(device.Name)
        Next

        If cbAudioOutput.Items.Count > 0 Then
            cbAudioOutput.SelectedIndex = 0
        End If
    End Sub

    Private Sub CreateEngine()
        _player = New MediaPlayerCoreX(VideoView1)
        AddHandler _player.OnError, AddressOf Player_OnError
        AddHandler _player.OnStop, AddressOf Player_OnStop
    End Sub
```

### Opening and Playing a Video File

Select a file and start playback:

```
    Private Sub btSelectFile_Click(sender As Object, e As EventArgs) Handles btSelectFile.Click
        Dim ofd As New OpenFileDialog()
        ofd.Filter = "Video Files|*.mp4;*.ts;*.mts;*.mov;*.avi;*.mkv;*.wmv;*.webm" &
                     "|Audio Files|*.mp3;*.aac;*.wav;*.wma|All Files|*.*"
        If ofd.ShowDialog() = DialogResult.OK Then
            edFilename.Text = ofd.FileName
        End If
    End Sub

    Private Async Sub btStart_Click(sender As Object, e As EventArgs) Handles btStart.Click
        edLog.Clear()

        ' Destroy previous engine instance if exists
        Await DestroyEngineAsync()
        CreateEngine()

        ' Set audio output device
        Dim audioOutputDevice = (Await _player.Audio_OutputDevicesAsync(
            AudioOutputDeviceAPI.DirectSound)).First(
            Function(x) x.Name = cbAudioOutput.Text)
        _player.Audio_OutputDevice = New AudioRendererSettings(audioOutputDevice)

        ' Open and play the file
        Dim source = Await UniversalSourceSettings.CreateAsync(New Uri(edFilename.Text))
        Await _player.OpenAsync(source)
        Await _player.PlayAsync()

        _timer.Start()
    End Sub
```

### Playback Controls (Pause, Resume, Stop)

Implement standard media player controls:

```
    Private Async Sub btPause_Click(sender As Object, e As EventArgs) Handles btPause.Click
        Await _player.PauseAsync()
    End Sub

    Private Async Sub btResume_Click(sender As Object, e As EventArgs) Handles btResume.Click
        Await _player.ResumeAsync()
    End Sub

    Private Async Sub btStop_Click(sender As Object, e As EventArgs) Handles btStop.Click
        _timer.Stop()

        If _player IsNot Nothing Then
            Await _player.StopAsync()
            Await DestroyEngineAsync()
            _player = Nothing
        End If

        tbTimeline.Value = 0
    End Sub
```

### Timeline Seeking and Position Tracking

Update the timeline slider as the video plays and allow seeking:

```
    Private Async Sub _timer_Elapsed(sender As Object, e As System.Timers.ElapsedEventArgs)
        _timerFlag = True

        If _player Is Nothing Then Return

        Dim position = Await _player.Position_GetAsync()
        Dim duration = Await _player.DurationAsync()

        Invoke(Sub()
                   tbTimeline.Maximum = CInt(duration.TotalSeconds)
                   lbTime.Text = position.ToString("hh\:mm\:ss") & " | " &
                                 duration.ToString("hh\:mm\:ss")

                   If tbTimeline.Maximum >= position.TotalSeconds Then
                       tbTimeline.Value = CInt(position.TotalSeconds)
                   End If
               End Sub)

        _timerFlag = False
    End Sub

    Private Async Sub tbTimeline_Scroll(sender As Object, e As EventArgs) Handles tbTimeline.Scroll
        If Not _timerFlag AndAlso _player IsNot Nothing Then
            Await _player.Position_SetAsync(TimeSpan.FromSeconds(tbTimeline.Value))
        End If
    End Sub
```

### Volume and Playback Speed Control

```
    Private Sub tbVolume1_Scroll(sender As Object, e As EventArgs) Handles tbVolume1.Scroll
        If _player IsNot Nothing Then
            _player.Audio_OutputDevice_Volume = tbVolume1.Value / 100.0
        End If
    End Sub

    Private Async Sub tbSpeed_Scroll(sender As Object, e As EventArgs) Handles tbSpeed.Scroll
        Await _player.Rate_SetAsync(tbSpeed.Value / 10.0)
    End Sub
```

### Error Handling and Cleanup

```
    Private Sub Player_OnError(sender As Object, e As ErrorsEventArgs)
        Invoke(Sub()
                   edLog.Text = edLog.Text + e.Message + Environment.NewLine
               End Sub)
    End Sub

    Private Sub Player_OnStop(sender As Object, e As StopEventArgs)
        Invoke(Sub()
                   tbTimeline.Value = 0
               End Sub)
    End Sub

    Private Async Function DestroyEngineAsync() As Task
        If _player IsNot Nothing Then
            RemoveHandler _player.OnError, AddressOf Player_OnError
            RemoveHandler _player.OnStop, AddressOf Player_OnStop
            Await _player.DisposeAsync()
            _player = Nothing
        End If
    End Function

    Private Async Sub Form1_Closing(sender As Object, e As CancelEventArgs) Handles Me.Closing
        _timer.Stop()
        Await DestroyEngineAsync()
        VisioForgeX.DestroySDK()
    End Sub
End Class
```

## Supported Video and Audio Formats

The VB.NET video player supports all major formats:

| Category | Formats |
| --- | --- |
| Video containers | MP4, AVI, MKV, WMV, WebM, MOV, TS, MTS |
| Video codecs | H.264, H.265/HEVC, VP8, VP9, AV1, MPEG-2 |
| Audio containers | MP3, AAC, WAV, WMA, FLAC, OGG |
| Streaming | RTSP, HTTP, HLS |

## Sample Applications

Complete VB.NET video player demos:

- [Simple Player Demo VB.NET (WinForms)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Player%20SDK%20X/WinForms/Simple%20Player%20Demo%20X%20VB) — full-featured video player with all playback controls

## Frequently Asked Questions

### What license do I need for a VB.NET video player application?

Media Player SDK .Net requires a license for development and distribution. A Developer license removes the evaluation watermark and unlocks all features during development. A Release license is required when distributing your application to end users. The SDK is available in Premium edition which includes all supported formats, hardware acceleration, and both DirectShow and GStreamer engines. You can evaluate the SDK without a license — playback works fully but includes a watermark overlay. Visit the [product page](https://www.visioforge.com/media-player-sdk-net) for pricing and license options.

### Which video and audio formats does the VB.NET player support?

The player supports all formats listed in the table above, including MP4, AVI, MKV, WMV, WebM, MOV, and TS containers with H.264, H.265/HEVC, VP8, VP9, AV1, and MPEG-2 video codecs. Audio formats include MP3, AAC, WAV, WMA, FLAC, and OGG. Network streaming protocols such as RTSP, HTTP, HLS, and MPEG-DASH are also supported. Format support is identical to the C# version because both languages use the same GStreamer-based playback engine.

### Should I use DirectShow or GStreamer engine for my VB.NET video player?

The `MediaPlayerCoreX` API shown in this guide uses the GStreamer engine and is the recommended choice for new cross-platform projects (Windows, macOS, Linux, iOS, Android), with the broadest format coverage and hardware-accelerated decoding. The DirectShow engine (`MediaPlayerCore`) is Windows-only but is a fully supported, first-class engine — pick it when your application is Windows-only and you want the lower per-frame overhead and the mature DirectShow filter ecosystem. Both engines work identically from VB.NET code; for new cross-platform work start with `MediaPlayerCoreX`, and for Windows-only deployments either engine is a good fit.

### How do I deploy a VB.NET video player application?

Include the NuGet redist packages listed in the NuGet reference section above — these bundle the native GStreamer libraries your application needs. Use `dotnet publish` with a self-contained deployment to avoid requiring a separate runtime install on the target machine. The `VisioForge.CrossPlatform.Core.Windows.x64` package contains the GStreamer runtime, so no separate GStreamer installation is needed. For WPF projects, the same deployment approach works — just reference the WPF-specific VideoView control instead of the WinForms one.

## See Also

- [Build a Video Player in C#](../video-player-csharp/) — WinForms and WPF player with DirectShow and GStreamer engines
- [.NET MAUI Video Player](../maui-player/) — iOS, Android, macOS, and Windows from one C# codebase
- [Avalonia Player Guide](../avalonia-player/) — complete MVVM implementation with file dialogs and platform setup
- [Loop Mode & Position Range](../loop-and-position-range/) — loop playback and segment selection for both engines
- [Record Webcam Video in VB.NET](../../../videocapture/guides/record-webcam-vb-net/) — webcam capture application in Visual Basic .NET
- [Code Samples](../../code-samples/) — frame extraction, playlists, and reverse playback examples
- [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net) — product page and downloads

---END OF PAGE---


## Video Player API for C# .NET — Play, Stream, Embed
**URL:** https://www.visioforge.com/help/docs/dotnet/mediaplayer/
**Description:** Embed video and audio playback into your app with VisioForge Media Player SDK .NET. Supports MP4, MKV, RTSP, HLS across Windows, macOS, Linux, and mobile.
**Tags:** Media Player SDK, .NET, DirectShow, Windows, macOS, Linux, Android, iOS, Playback, Streaming
**API:** UniversalSourceSettings, MediaPlayerCoreX, VideoView

# Media Player SDK for C# .NET — Video Player, Audio Player, and Streaming API

[Media Player SDK .NET](https://www.visioforge.com/media-player-sdk-net)

## Introduction

The Media Player SDK for .NET is a C# video player API that lets you play video and audio files, network streams (RTSP, HLS, MPEG-DASH), and special content like 360-degree videos in your .NET applications. It replaces low-level DirectShow playback code and Windows Media Player SDK integration with a modern async API — open a file, start playback, and control seeking and volume in a few lines of C#.

The SDK uses GStreamer-based decoding with hardware acceleration and runs on Windows, macOS, Linux, Android, and iOS. Whether you need to build a desktop video player, embed media playback in a kiosk app, or stream RTSP feeds from IP cameras, the API covers it.

## Quick Start

### 1. Install NuGet Packages

```
dotnet add package VisioForge.DotNet.MediaPlayer
```

Add platform-specific native dependencies:

```
<!-- Windows x64 -->
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />

<!-- macOS -->
<PackageReference Include="VisioForge.CrossPlatform.Core.macOS" Version="2026.8.5" />

<!-- Linux x64 (needs system GStreamer 1.22+) -->
<PackageReference Include="VisioForge.CrossPlatform.Core.Linux.x64" Version="2025.9.0" />
```

For the full list of packages and UI framework support (WinForms, WPF, MAUI, Avalonia), see the [Installation Guide](../install/).

### 2. Initialize the SDK

Call `InitSDKAsync()` once at application startup before using any playback functionality:

```
using VisioForge.Core;

await VisioForgeX.InitSDKAsync();
```

### 3. Play Video in C# (Minimal Example)

```
using VisioForge.Core;
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types.X.Sources;

// Create player instance linked to a VideoView control
var player = new MediaPlayerCoreX(videoView);

// Open a video file
var source = await UniversalSourceSettings.CreateAsync(
    "C:\\Videos\\sample.mp4");
await player.OpenAsync(source);

// Start playback
await player.PlayAsync();

// ... when done:
await player.StopAsync();
await player.DisposeAsync();
```

### 4. Cleanup at Shutdown

```
VisioForgeX.DestroySDK();
```

## Core Workflow

Every media player application follows the same pattern:

1. **Initialize SDK** — `VisioForgeX.InitSDKAsync()` (once per app lifetime)
2. **Create player** — `new MediaPlayerCoreX(videoView)` for video, or without a view for audio-only
3. **Open media** — `await player.OpenAsync(source)` with a file path or stream URL
4. **Play** — `await player.PlayAsync()`
5. **Control playback** — seek with `Position_SetAsync()`, pause with `PauseAsync()`, adjust volume
6. **Stop** — `await player.StopAsync()`
7. **Dispose** — `await player.DisposeAsync()` releases all resources
8. **Destroy SDK** — `VisioForgeX.DestroySDK()` at application shutdown

## Common C# Video Player Scenarios

### Play Video File in C# (MP4, AVI, MKV)

Open and play any supported video file with automatic codec detection:

```
var source = await UniversalSourceSettings.CreateAsync(
    "movie.mp4");
await player.OpenAsync(source);
await player.PlayAsync();
```

See the full tutorial: [Build a Video Player in C#](guides/video-player-csharp/)

### Play RTSP Stream in C

Play live video from IP cameras and RTSP sources. Supports RTSP, HTTP, HLS, and MPEG-DASH:

```
var source = await UniversalSourceSettings.CreateAsync(
    new Uri("rtsp://admin:password@192.168.1.100:554/stream"));
await player.OpenAsync(source);
await player.PlayAsync();
```

### Audio-Only Playback

Play audio files (MP3, AAC, FLAC, WAV) without a video view:

```
var player = new MediaPlayerCoreX(); // no VideoView needed
var source = await UniversalSourceSettings.CreateAsync(
    "music.mp3");
await player.OpenAsync(source);
await player.PlayAsync();
```

### Extract Frame from Video

Grab a still image from the current playback position:

```
// Save the current frame directly to disk — the simplest path.
bool saved = await player.Snapshot_SaveAsync("screenshot.jpg", SkiaSharp.SKEncodedImageFormat.Jpeg, quality: 85);

// Or grab the raw VideoFrameX for in-memory processing (caller owns the pixel buffer).
var frame = await player.Snapshot_GetAsync();
if (frame != null)
{
    // frame.Data (IntPtr), frame.DataSize, frame.Width, frame.Height, frame.Stride, frame.Format.
    // Free the unmanaged buffer when done:
    frame.Free();
}
```

See: [Get a Specific Frame from a Video File](code-samples/get-frame-from-video-file/)

### Seeking, Volume, and Speed Control

```
// Seek to a specific position
await player.Position_SetAsync(TimeSpan.FromSeconds(30));

// Get current position and duration
var position = await player.Position_GetAsync();
var duration = await player.DurationAsync();

// Adjust volume (0.0 to 1.0)
player.Audio_OutputDevice_Volume = 0.8;

// Change playback speed (0.25x to 4.0x)
await player.Rate_SetAsync(1.5);
```

### Loop Playback and Segment Play

Play a specific segment of a file or loop continuously:

```
// Enable loop mode
player.Loop = true;

// Play a specific time range
player.Segment_Start = TimeSpan.FromSeconds(10);
player.Segment_Stop = TimeSpan.FromSeconds(60);
```

See: [Loop Mode and Position Range Playback](guides/loop-and-position-range/)

## Supported Formats

| Category | Formats |
| --- | --- |
| Video Containers | MP4, AVI, MKV, WMV, WebM, MOV, TS, MTS, FLV |
| Audio Formats | MP3, AAC, WAV, WMA, FLAC, OGG, Vorbis |
| Video Codecs | H.264, H.265/HEVC, VP8, VP9, AV1, MPEG-2 |
| Streaming Protocols | RTSP, HTTP, HLS, MPEG-DASH |

## Platform Support

| Platform | UI Frameworks | Notes |
| --- | --- | --- |
| Windows x64 | WinForms, WPF, WinUI, MAUI, Avalonia, Console | Full feature set including DirectShow engine |
| macOS | MAUI, Avalonia, Console | AVFoundation-based rendering |
| Linux x64 | Avalonia, Console | GStreamer-based decoding |
| Android | MAUI | Via MAUI integration |
| iOS | MAUI | Via MAUI integration |

For cross-platform implementations, see the [Avalonia Player Guide](guides/avalonia-player/) (desktop, includes Linux) or the [.NET MAUI Player Guide](guides/maui-player/) (mobile + desktop).

## Developer Documentation

### Guides

- [Build a Video Player in C# (WinForms / WPF)](guides/video-player-csharp/)
- [Build a Video Player in VB.NET](guides/video-player-vb-net/)
- [Avalonia Player Implementation](guides/avalonia-player/)
- [.NET MAUI Player](guides/maui-player/)
- [Android Player Implementation](guides/android-player/)
- [Loop Mode and Position Range](guides/loop-and-position-range/)
- [All Guides](guides/)

### Code Examples

- [Get a Frame from a Video File](code-samples/get-frame-from-video-file/)
- [Play a Fragment of a File](code-samples/play-fragment-file/)
- [Show the First Frame](code-samples/show-first-frame/)
- [Memory Playback](code-samples/memory-playback/)
- [Playlist API](code-samples/playlist-api/)
- [Reverse Video Playback](code-samples/reverse-video-playback/)
- [All Code Examples](code-samples/)

### Deployment

- [Deployment Guide](deployment/)

## Developer Resources

- [Code Samples on GitHub](https://github.com/visioforge/.Net-SDK-s-samples/)
- [API Reference](https://api.visioforge.org/dotnet/api/index.html)
- [Changelog](../changelog/)
- [End User License Agreement](../../eula/)
- [Licensing Information](https://www.visioforge.com/licensing)

---END OF PAGE---


## Migration Guide — Upgrade VisioForge .NET SDK v15 to v2026
**URL:** https://www.visioforge.com/help/docs/dotnet/migration-from-v15/
**Description:** Step-by-step guide for upgrading from VisioForge .NET SDK v15 to v2026, covering both DirectShow and cross-platform X-engine migration paths.
**Tags:** Video Capture SDK, Media Player SDK, Video Edit SDK, .NET, DirectShow, Windows, macOS, Linux, Android, iOS, Capture, Playback, Streaming, Editing
**API:** MP4Output, DeviceEnumerator, VideoCaptureCore, VideoEditCore, MediaPlayerCore

# Migration Guide: v15 to v2026

This guide helps you upgrade your application from VisioForge .NET SDK v15.x to v2026.x. The v2026 SDK contains **two engine types**, and you can choose the migration path that best fits your needs:

- **Path A: Stay on DirectShow** — Minimal code changes, same Windows-only architecture. Best for production applications that need a quick, low-risk upgrade.
- **Path B: Migrate to X-engines** — Significant API changes, but you gain cross-platform support, modern codecs, and new features. Best for applications planning a major update.

> **Important:** The legacy DirectShow classes (`VideoCaptureCore`, `VideoEditCore`, `MediaPlayerCore`) are **still fully supported and actively updated** in v2026. You do not need to migrate to X-engines immediately. We recommend Path A first, then migrate to X-engines when your schedule allows.

## Target framework changes

The following table shows supported target frameworks in v2026:

| Framework | DirectShow engines | X-engines |
| --- | --- | --- |
| .NET Framework 4.6.1+ | Supported | Supported |
| .NET Core 3.1 | Supported | Supported |
| .NET 5.0 / 6.0 / 7.0 | Supported | Supported |
| .NET 8.0 | Supported | Supported |
| .NET 9.0 | Supported | Supported |
| .NET 10.0 | Supported | Supported |

> **Note:** DirectShow classes require a Windows TFM (e.g., `net10.0-windows`) or .NET Framework. For X-engines, platform-specific TFMs control the target: `net10.0-windows` for Windows, `net10.0-macos` for macOS, `net10.0-ios` for iOS, `net10.0-android` for Android. Plain `net10.0` (no platform suffix) targets Linux only.

---

## Path A: DirectShow v15 → v2026 DirectShow (Minimal Impact)

This path keeps your existing DirectShow-based code with minimal changes.

### NuGet package changes

| v15 Package | v2026 Package |
| --- | --- |
| `VisioForge.DotNet.Core` | `VisioForge.DotNet.Core` (same name, new version) |

Product-specific packages are also available:

- `VisioForge.DotNet.VideoCapture`
- `VisioForge.DotNet.VideoEdit`
- `VisioForge.DotNet.MediaPlayer`

### Namespace changes

**No namespace changes required.** All DirectShow namespaces remain the same:

| Namespace | Status |
| --- | --- |
| `VisioForge.Core.VideoCapture` | Unchanged |
| `VisioForge.Core.VideoEdit` | Unchanged |
| `VisioForge.Core.MediaPlayer` | Unchanged |
| `VisioForge.Core.Types` | Unchanged |
| `VisioForge.Core.Types.VideoCapture` | Unchanged |
| `VisioForge.Core.Types.Output` | Unchanged |
| `VisioForge.Core.Types.VideoEffects` | Unchanged |
| `VisioForge.Core.Types.AudioEffects` | Unchanged |
| `VisioForge.Core.Types.Events` | Unchanged |
| `VisioForge.Core.Types.MediaPlayer` | Unchanged |
| `VisioForge.Core.Types.VideoEdit` | Unchanged |

### API changes

The DirectShow API is largely unchanged from v15 to v2026:

- **No SDK initialization required** (same as v15)
- Same class names: `VideoCaptureCore`, `VideoEditCore`, `MediaPlayerCore`
- Same creation patterns: `new VideoCaptureCore(videoView)`, `new MediaPlayerCore(videoView)`, `new VideoEditCore(videoView)`
- Same device enumeration: `VideoCapture1.Video_CaptureDevices()`, `.Audio_CaptureDevices()`
- Same output configuration: `VideoCapture1.Output_Format = mp4Output;`
- Same mode setting: `VideoCapture1.Mode = VideoCaptureMode.VideoCapture;`
- Same event names: `OnError`, `OnStop`, etc.

### Troubleshooting

| Problem | Solution |
| --- | --- |
| `VisioForge.Core.Types` namespace not found | Verify the correct NuGet package is installed (`VisioForge.DotNet.Core` or product-specific package) |
| Types or classes missing | For .NET 8+, ensure your TFM includes `-windows` (e.g., `net8.0-windows`, not `net8.0`). For .NET Framework, use `net461` or `net472`. |
| WPF `VideoView` not found | Project must target a Windows TFM (e.g., `net8.0-windows`) with `<UseWPF>true</UseWPF>` |

---

## Path B: Migrate to X-Engines (Cross-Platform)

This path migrates from DirectShow classes to the new cross-platform X-engine classes. This is a more significant change but provides major benefits.

### Why migrate to X-engines?

- **Cross-platform**: Windows, macOS, Linux, iOS, Android
- **Modern codecs**: AV1, HEVC with hardware encoding (NVIDIA NVENC, AMD AMF, Intel QSV)
- **Multiple simultaneous outputs**: Record to MP4 + stream to RTMP at the same time
- **New streaming protocols**: SRT, RIST, WebRTC WHIP, HLS, DASH
- **Async-first API**: Full async/await support throughout
- **MediaBlocks pipeline**: Build custom media processing pipelines with composable blocks

### NuGet packages

You need additional packages for X-engines:

```
<!-- Core SDK -->
<PackageReference Include="VisioForge.DotNet.Core" Version="2026.*" />

<!-- Platform runtime (required for X-engines) -->
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.*" />

<!-- UI package - only for MAUI, Avalonia, WinUI and Uno; choose one -->
<PackageReference Include="VisioForge.DotNet.Core.UI.MAUI" Version="2026.*" />
<!-- OR -->
<PackageReference Include="VisioForge.DotNet.Core.UI.Avalonia" Version="2026.*" />
<!-- OR -->
<PackageReference Include="VisioForge.DotNet.Core.UI.WinUI" Version="2026.*" />
<!-- OR -->
<PackageReference Include="VisioForge.DotNet.Core.UI.Uno" Version="2026.*" />
```

WPF and WinForms need no UI package at all — their `VideoView` controls were merged into `VisioForge.DotNet.Core`. The namespaces are unchanged, so only the `<PackageReference>` goes away.

### SDK initialization (required for X-engines)

X-engines require explicit initialization at application startup and cleanup at shutdown. **This is not required for legacy DirectShow classes.**

```
// At application startup (e.g., Window_Loaded, OnStartup)
await VisioForgeX.InitSDKAsync();

// At application shutdown (e.g., Window_Closing, OnExit)
VisioForgeX.DestroySDK();
```

> **Warning:** If the SDK is not properly deinitialized, the application may hang on exit.

### Namespace migration

| v15 (DirectShow) Namespace | v2026 (X-Engine) Namespace |
| --- | --- |
| `VisioForge.Core.VideoCapture` | `VisioForge.Core.VideoCaptureX` |
| `VisioForge.Core.VideoEdit` | `VisioForge.Core.VideoEditX` |
| `VisioForge.Core.MediaPlayer` | `VisioForge.Core.MediaPlayerX` |
| `VisioForge.Core.Types.VideoCapture` | `VisioForge.Core.Types.X.Sources` + `VisioForge.Core.Types.X.VideoCapture` |
| `VisioForge.Core.Types.Output` | `VisioForge.Core.Types.X.Output` |
| `VisioForge.Core.Types.VideoEffects` | `VisioForge.Core.Types.X.VideoEffects` |
| `VisioForge.Core.Types.AudioEffects` | `VisioForge.Core.Types.X.AudioEffects` |
| `VisioForge.Core.Types.Events` | `VisioForge.Core.Types.Events` (unchanged) |
| `VisioForge.Core.Types.MediaPlayer` | `VisioForge.Core.Types.X.Sources` |
| `VisioForge.Core.Types.VideoEdit` | `VisioForge.Core.Types.X.VideoEdit` |
| — (new) | `VisioForge.Core.Types.X.AudioRenderers` |
| — (new) | `VisioForge.Core.Types.X.VideoEncoders` |
| — (new) | `VisioForge.Core.Types.X.AudioEncoders` |
| — (new) | `VisioForge.Core.Types.X.Sinks` |
| — (new) | `VisioForge.Core.MediaBlocks` |

### Class migration

| v15 (DirectShow) | v2026 (X-Engine) | Notes |
| --- | --- | --- |
| `VideoCaptureCore` | `VideoCaptureCoreX` | Direct constructor instead of factory |
| `VideoEditCore` | `VideoEditCoreX` |  |
| `MediaPlayerCore` | `MediaPlayerCoreX` |  |
| `VideoCaptureSource` | `VideoCaptureDeviceSourceSettings` | Strongly typed |
| `AudioCaptureSource` | via `device.CreateSourceSettingsVC()` | Device-based creation |
| `MP4Output` | `MP4Output` | Same name, different namespace |
| `MP4HWOutput` | `MP4Output` with HW encoder | See encoder section |
| `AVIOutput` | `AVIOutput` | Same name, different namespace |
| `WMVOutput` | `WMVOutput` | Same name, different namespace |
| `MOVOutput` | `MOVOutput` | Same name, different namespace |
| `MPEGTSOutput` | `MPEGTSOutput` | Same name, different namespace |
| `WebMOutput` | `WebMOutput` | Same name, different namespace |
| `VideoCaptureMode` | Not needed | Preview is default; add outputs for recording |

---

### Video Capture: Side-by-side migration

#### Engine creation

```
// v15 (DirectShow)
using VisioForge.Core.VideoCapture;

VideoCaptureCore VideoCapture1;
VideoCapture1 = await VideoCaptureCore.CreateAsync(VideoView1 as IVideoView);

// v2026 (X-Engine)
using VisioForge.Core.VideoCaptureX;

VideoCaptureCoreX VideoCapture1;
await VisioForgeX.InitSDKAsync();  // One-time at app startup
VideoCapture1 = new VideoCaptureCoreX(VideoView1 as IVideoView);
```

#### Device enumeration

```
// v15 (DirectShow) — synchronous, instance method
foreach (var device in VideoCapture1.Video_CaptureDevices())
{
    cbVideoInputDevice.Items.Add(device.Name);
}

foreach (var device in VideoCapture1.Audio_CaptureDevices())
{
    cbAudioInputDevice.Items.Add(device.Name);
}

foreach (string device in VideoCapture1.Audio_OutputDevices())
{
    cbAudioOutputDevice.Items.Add(device);
}
```

```
// v2026 (X-Engine) — async, shared singleton
using VisioForge.Core.MediaBlocks;

// Option 1: One-time enumeration
var videoDevices = await DeviceEnumerator.Shared.VideoSourcesAsync();
foreach (var device in videoDevices)
{
    cbVideoInputDevice.Items.Add(device.DisplayName);  // Note: DisplayName, not Name
}

var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync();
foreach (var device in audioDevices)
{
    cbAudioInputDevice.Items.Add(device.DisplayName);
}

var audioOutputs = await DeviceEnumerator.Shared.AudioOutputsAsync();
foreach (var device in audioOutputs)
{
    cbAudioOutputDevice.Items.Add(device.DisplayName);
}

// Option 2: Hot-plug monitoring (new feature)
DeviceEnumerator.Shared.OnVideoSourceAdded += (sender, device) =>
{
    cbVideoInputDevice.Items.Add(device.DisplayName);
};
await DeviceEnumerator.Shared.StartVideoSourceMonitorAsync();
```

#### Video source configuration

```
// v15 (DirectShow)
using VisioForge.Core.Types.VideoCapture;

VideoCapture1.Video_CaptureDevice = new VideoCaptureSource(cbVideoInputDevice.Text);
VideoCapture1.Video_CaptureDevice.Format = cbVideoInputFormat.Text;
VideoCapture1.Video_CaptureDevice.Format_UseBest = cbUseBestFormat.IsChecked == true;
VideoCapture1.Video_CaptureDevice.FrameRate = new VideoFrameRate(30.0);
```

```
// v2026 (X-Engine)
using VisioForge.Core.Types.X.Sources;

var devices = await DeviceEnumerator.Shared.VideoSourcesAsync();
var deviceItem = devices.FirstOrDefault(d => d.DisplayName == cbVideoInputDevice.Text);

var videoSourceSettings = new VideoCaptureDeviceSourceSettings(deviceItem);

// Set format (typed, not string-based)
var formatItem = deviceItem.VideoFormats
    .FirstOrDefault(f => f.Name == cbVideoInputFormat.Text);
if (formatItem != null)
{
    videoSourceSettings.Format = formatItem.ToFormat();
    videoSourceSettings.Format.FrameRate = new VideoFrameRate(30.0);
}

VideoCapture1.Video_Source = videoSourceSettings;
```

#### Audio source configuration

```
// v15 (DirectShow)
using VisioForge.Core.Types.VideoCapture;

VideoCapture1.Audio_CaptureDevice = new AudioCaptureSource(cbAudioInputDevice.Text);
VideoCapture1.Audio_CaptureDevice.Format = cbAudioInputFormat.Text;
VideoCapture1.Audio_CaptureDevice.Format_UseBest = cbUseBestFormat.IsChecked == true;
VideoCapture1.Audio_OutputDevice = cbAudioOutputDevice.Text;
```

```
// v2026 (X-Engine)
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.AudioRenderers;

var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync();
var deviceItem = audioDevices.FirstOrDefault(d => d.DisplayName == cbAudioInputDevice.Text);

var formatItem = deviceItem.Formats
    .FirstOrDefault(f => f.Name == cbAudioInputFormat.Text);
IVideoCaptureBaseAudioSourceSettings audioSource = deviceItem.CreateSourceSettingsVC(formatItem?.ToFormat());
VideoCapture1.Audio_Source = audioSource;

// Audio output device
var audioOutputs = await DeviceEnumerator.Shared.AudioOutputsAsync();
var outputDevice = audioOutputs.FirstOrDefault(d => d.DisplayName == cbAudioOutputDevice.Text);
VideoCapture1.Audio_OutputDevice = new AudioRendererSettings(outputDevice);
```

#### Output and recording

```
// v15 (DirectShow) — single output
using VisioForge.Core.Types.Output;
using VisioForge.Core.Types.VideoCapture;

VideoCapture1.Mode = VideoCaptureMode.VideoCapture;
VideoCapture1.Output_Filename = "output.mp4";

var mp4Output = new MP4Output();
// configure mp4Output...
VideoCapture1.Output_Format = mp4Output;

await VideoCapture1.StartAsync();
```

```
// v2026 (X-Engine) — multiple simultaneous outputs
using VisioForge.Core.Types.X.Output;

// No Mode property needed — preview is default
// Add output(s) for recording
VideoCapture1.Outputs_Add(new MP4Output("output.mp4"), false);

// You can add multiple outputs simultaneously:
// VideoCapture1.Outputs_Add(new WebMOutput("output.webm"), false);

await VideoCapture1.StartAsync();
```

#### Preview only (no recording)

```
// v15 (DirectShow)
VideoCapture1.Mode = VideoCaptureMode.VideoPreview;
await VideoCapture1.StartAsync();

// v2026 (X-Engine) — just don't add any outputs
await VideoCapture1.StartAsync();
```

#### Hardware-accelerated encoding

```
// v15 (DirectShow)
using VisioForge.Core.Types.Output;

var mp4Output = new MP4HWOutput();
VideoCapture1.Output_Format = mp4Output;
```

```
// v2026 (X-Engine)
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.VideoEncoders;

var mp4Output = new MP4Output("output.mp4");
mp4Output.Video = new NVENCH264EncoderSettings();  // NVIDIA
// or: mp4Output.Video = new QSVH264EncoderSettings();  // Intel
// or: mp4Output.Video = new AMFH264EncoderSettings();  // AMD
VideoCapture1.Outputs_Add(mp4Output, false);
```

#### Volume control

```
// v15 (DirectShow)
VideoCapture1.Audio_OutputDevice_Volume_Set(70);
VideoCapture1.Audio_OutputDevice_Balance_Set(0);

// v2026 (X-Engine)
VideoCapture1.Audio_OutputDevice_Volume = 0.7;  // 0.0 to 1.0 (double)
```

#### Cleanup

```
// v15 (DirectShow)
VideoCapture1.Dispose();

// v2026 (X-Engine)
await VideoCapture1.DisposeAsync();
VisioForgeX.DestroySDK();  // At app shutdown
```

---

### Media Player: Side-by-side migration

#### Engine creation and playback

```
// v15 (DirectShow)
using VisioForge.Core.MediaPlayer;

MediaPlayerCore _player;
_player = new MediaPlayerCore(VideoView1 as IVideoView);
_player.Audio_OutputDevice = cbAudioOutput.Text;
_player.Playlist_Clear();
_player.Playlist_Add("video.mp4");
await _player.PlayAsync();
```

```
// v2026 (X-Engine)
using VisioForge.Core.MediaPlayerX;
using VisioForge.Core.Types.X.Sources;

await VisioForgeX.InitSDKAsync();  // One-time at app startup

MediaPlayerCoreX _player;
_player = new MediaPlayerCoreX(VideoView1);

var source = await UniversalSourceSettingsV2.CreateAsync("video.mp4");
await _player.OpenAsync(source);
await _player.PlayAsync();
```

#### Key differences

| Feature | v15 (DirectShow) | v2026 (X-Engine) |
| --- | --- | --- |
| Source setup | `Playlist_Add("file.mp4")` | `OpenAsync(UniversalSourceSettingsV2)` |
| Position | `_player.Position_Get_Time()` (method, ms) | `await _player.Position_GetAsync()` |
| Duration | `_player.Duration_Time()` (method, ms) | `await _player.DurationAsync()` |
| Version | `_player.SDK_Version()` (instance) | `MediaPlayerCoreX.SDK_Version` (static) |
| Loop | `_player.Loop` | `_player.Loop` (same name) |

---

### Video Edit: Side-by-side migration

#### Engine creation

```
// v15 (DirectShow)
using VisioForge.Core.VideoEdit;
using VisioForge.Core.Types.Output;

VideoEditCore VideoEdit1;
VideoEdit1 = new VideoEditCore(VideoView1 as IVideoView);
VideoEdit1.Input_AddVideoFile("input.mp4");
VideoEdit1.Output_Filename = "output.mp4";
VideoEdit1.Output_Format = new MP4Output();
await VideoEdit1.StartAsync();
```

```
// v2026 (X-Engine)
using VisioForge.Core.VideoEditX;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.VideoEdit;

await VisioForgeX.InitSDKAsync();  // One-time at app startup

VideoEditCoreX VideoEdit1;
VideoEdit1 = new VideoEditCoreX(VideoView1 as IVideoView);
VideoEdit1.Input_AddVideoFile("input.mp4");
VideoEdit1.Output_Format = new MP4Output("output.mp4");
await VideoEdit1.StartAsync();
```

#### Key differences

| Feature | v15 (DirectShow) | v2026 (X-Engine) |
| --- | --- | --- |
| Namespace | `VisioForge.Core.VideoEdit` | `VisioForge.Core.VideoEditX` |
| Output types | `VisioForge.Core.Types.Output` | `VisioForge.Core.Types.X.Output` |
| Output filename | Separate `Output_Filename` property | Included in output constructor: `new MP4Output("path")` |
| Effects | `VisioForge.Core.Types.VideoEffects` | `VisioForge.Core.Types.X.VideoEffects` |
| Video size | `VisioForge.Core.Types.Size` | `VisioForge.Core.Types.Size` (unchanged) |

---

### Events

Most events keep the same names across both engines:

| Event | v15 | v2026 X-Engine | Notes |
| --- | --- | --- | --- |
| `OnError` | Yes | Yes | `ErrorsEventArgs` (same) |
| `OnStop` | Yes | Yes |  |
| `OnStart` | Yes | Yes |  |
| `OnAudioVUMeter` | — | Yes | New in X-engine |
| `OnOutputStarted` | — | Yes | New — per-output events |
| `OnOutputStopped` | — | Yes | New — per-output events |
| `OnBarcodeDetected` | — | Yes | New |
| `OnFaceDetected` | — | Yes | New |
| `OnMotionDetection` | Yes | Yes |  |
| `OnVideoFrameBuffer` | Yes | Yes |  |

---

## FAQ

### "VisioForge.Core.Types namespace is no more available"

This depends on which engine you're using:

- **DirectShow classes**: `VisioForge.Core.Types` still exists. Make sure you have the correct NuGet package installed. For .NET 8+, ensure your TFM includes `-windows`.
- **X-engine classes**: Use `VisioForge.Core.Types.X.*` sub-namespaces (e.g., `VisioForge.Core.Types.X.Output`, `VisioForge.Core.Types.X.Sources`).

### "Can I keep using DirectShow classes (VideoCaptureCore, etc.)?"

Yes. DirectShow classes are fully supported and actively updated in v2026. You can upgrade the NuGet package and keep your existing code with minimal changes.

### "MP4HWOutput is not found"

In X-engines, `MP4HWOutput` is replaced by `MP4Output` with a specific hardware encoder:

```
var mp4 = new MP4Output("output.mp4");
mp4.Video = new NVENCH264EncoderSettings();  // or QSVH264, AMFH264, etc.
```

### "VideoCaptureMode is not found"

X-engines don't use a `Mode` property. Preview is the default behavior. To record, add outputs with `Outputs_Add()`.

### "Audio\_CaptureDevices() method is not found"

In X-engines, device enumeration uses a shared async singleton:

```
var devices = await DeviceEnumerator.Shared.AudioSourcesAsync();
```

### "What is the recommended migration strategy for production applications?"

1. **First**: Upgrade to v2026 keeping DirectShow classes (Path A) — low risk, minimal code changes
2. **Test**: Verify your application works correctly with the new package version
3. **Then**: When ready, migrate to X-engines (Path B) — module by module if needed
4. **Both engines can coexist** in the same application during the transition period

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Cross-Platform Codec and Device Support Matrix for .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/platform-matrix/
**Description:** VisioForge .NET SDK cross-platform support matrix for video/audio codecs, hardware acceleration, and capture devices on Windows, Linux, macOS, Android, iOS.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS

# .NET SDK: Supported Features and Platforms

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

Discover the comprehensive feature set and broad platform compatibility of VisioForge .NET SDKs. The tables below detail supported input/output formats, video/audio codecs, hardware acceleration, capture devices, and network protocols across Windows, Linux, macOS, Android, and iOS.

## Input and output file formats

| Output formats | Windows | Linux | MacOS | Android | iOS |
| --- | --- | --- | --- | --- | --- |
| MP4 | ✔ | ✔ | ✔ | ✔ | ✔ |
| WebM | ✔ | ✔ | ✔ | ✔ | ✔ |
| MKV | ✔ | ✔ | ✔ | ✔ | ✔ |
| AVI | ✔ | ✔ | ✔ | ✔ | ✔ |
| ASF (WMV/WMA) | ✔ | ✔ | ✔ | ✔ | ✔ |
| MPEG-PS | ✔ | ✔ | ✔ | ✔ | ✔ |
| MPEG-TS | ✔ | ✔ | ✔ | ✔ | ✔ |
| MOV | ✔ | ✔ | ✔ | ✔ | ✔ |
| MXF | ✔ | ✔ | ✔ | ✔ | ✔ |
| WMA | ✔ | ✔ | ✔ | ✔ | ✔ |
| WAV | ✔ | ✔ | ✔ | ✔ | ✔ |
| MP3 | ✔ | ✔ | ✔ | ✔ | ✔ |
| OGG | ✔ | ✔ | ✔ | ✔ | ✔ |

Also, cross-platform engines support all formats supported by FFMPEG and GStreamer.

## Video encoders and decoders

SDK supports the following video codecs:

| Encoders | Windows | Linux | MacOS | Android | iOS |
| --- | --- | --- | --- | --- | --- |
| H264 | ✔ | ✔ | ✔ | ✔ | ✔ |
| H264/HEVC | ✔ | ✔ | ✔ | ✔ | ✔ |
| VP8/VP9 | ✔ | ✔ | ✔ | ✔ | ✔ |
| AV1 | ✔ | ✔ | ✔ | ✔ | ✘ (\*) |
| MJPEG | ✔ | ✔ | ✔ | ✔ | ✔ |
| WMV | ✔ | ✔ | ✔ | ✔ | ✔ |
| MPEG-4 ASP | ✔ | ✔ | ✔ | ✔ | ✔ |
| GIF | ✔ | ✔ | ✔ | ✔ | ✔ |
| MPEG-1 | ✔ | ✔ | ✔ | ✔ | ✔ |
| MPEG-2 | ✔ | ✔ | ✔ | ✔ | ✔ |
| Theora | ✔ | ✔ | ✔ | ✔ | ✔ |
| DNxHD | ✔ | ✔ | ✔ | ✔ | ✔ |
| DV | ✔ | ✔ | ✔ | ✔ | ✔ |

(*) AV1* decoding *is available on iOS - through VideoToolbox on A17 Pro and later, and through the software `dav1d` decoder everywhere else. AV1* encoding\* is not: Apple ships no AV1 hardware encoder on any chip, and the software AV1 encoders are not part of the iOS redist.

### GPU-accelerated encoding and decoding

The table below shows the support for hardware-accelerated encoding and decoding for each codec and platform.

| Codec | Hardware | Windows | Linux | MacOS | Android | iOS |
| --- | --- | --- | --- | --- | --- | --- |
| H264/HEVC | Intel | D / E | D / E | D / E | ✘ | ✘ |
| H264/HEVC | Nvidia | D / E | D / E | D / E | ✘ | ✘ |
| H264/HEVC | AMD | D / E | D / E | D / E | ✘ | ✘ |
| H264/HEVC | Apple | ✘ | ✘ | D / E | ✘ | D / E |
| H264/HEVC | Android (1) | ✘ | ✘ | ✘ | D / E | ✘ |
| AV1 | Intel | D / E | D / E | D / E | ✘ | ✘ |
| AV1 | Nvidia | D / E | D / E | D / E | ✘ | ✘ |
| AV1 | AMD | D / E | D / E | D / E | ✘ | ✘ |
| AV1 | Apple | ✘ | ✘ | D | ✘ | D |
| AV1 | Android (1) | ✘ | ✘ | ✘ | D | ✘ |
| VP9 | Intel | D / E | D / E | D / E | ✘ | ✘ |
| VP9 | Nvidia | D / E | D / E | D / E | ✘ | ✘ |
| VP9 | AMD | D / E | D / E | D / E | ✘ | ✘ |
| VP9 | Apple | ✘ | ✘ | D (2) | ✘ | ✘ |
| VP9 | Android (1) | ✘ | ✘ | ✘ | D / E | ✘ |

(1) - MediaCodec compatible encoders and decoders, if supported by hardware

(2) - only on Apple Silicon

## Audio encoders and decoders

The table below shows the support for audio codecs for each platform.

| Encoders | Windows | Linux | MacOS | Android | iOS |
| --- | --- | --- | --- | --- | --- |
| AAC | ✔ | ✔ | ✔ | ✔ | ✔ |
| MP3 | ✔ | ✔ | ✔ | ✔ | ✔ |
| Vorbis | ✔ | ✔ | ✔ | ✔ | ✔ |
| OPUS | ✔ | ✔ | ✔ | ✔ | ✔ |
| Speex | ✔ | ✔ | ✔ | ✔ | ✔ |
| FLAC | ✔ | ✔ | ✔ | ✔ | ✔ |
| MP2 | ✔ | ✔ | ✔ | ✔ | ✔ |
| WMA | ✔ | ✔ | ✔ | ✔ | ✔ |
| OPUS | ✔ | ✔ | ✔ | ✔ | ✔ |
| Wavpack | ✔ | ✔ | ✔ | ✔ | ✔ |

Also, you can use any other audio or video encoder available in FFMPEG or GStreamer.

## Devices

The table below shows the support for capture devices for each platform.

| Devices | Windows | Linux | MacOS | Android | iOS |
| --- | --- | --- | --- | --- | --- |
| Webcams and other local capture sources | ✔ | ✔ | ✔ | ✔ | ✔ |
| IP cameras and NVR (including ONVIF) | ✔ | ✔ | ✔ | ✔ | ✔ |
| Screen | ✔ | ✔ | ✔ | ✔ | ✔ |
| Blackmagic Decklink (input and output) | ✔ | ✔ | ✔ | ✘ | ✘ |
| Camcorders | ✔ | ✔ | ✔ | ✘ | ✘ |
| GenICam-supported USB3/GigE cameras | ✔ | ✔ | ✔ | ✘ | ✘ |
| Teledyne/FLIR GigE/USB3 cameras | ✔ | ✘ | ✘ | ✘ | ✘ |
| Basler GigE/USB3 cameras | ✔ | ✘ | ✘ | ✘ | ✘ |
| Allied Vision GigE/USB3 cameras | ✔ | ✘ | ✘ | ✘ | ✘ |

## Network protocols

The table below shows the support for network protocols for each platform.

| Protocols | Windows | Linux | MacOS | Android | iOS |
| --- | --- | --- | --- | --- | --- |
| RTP/RTSP | ✔ | ✔ | ✔ | ✔ | ✔ |
| RTMP (YouTube, Facebook Live) | ✔ | ✔ | ✔ | ✔ | ✔ |
| SRT | ✔ | ✔ | ✔ | ✔ | ✔ |
| UDP | ✔ | ✔ | ✔ | ✔ | ✔ |
| TCP | ✔ | ✔ | ✔ | ✔ | ✔ |
| HTTP | ✔ | ✔ | ✔ | ✔ | ✔ |
| NDI | ✔ | ✔ | ✔ | ✔ | ✔ |
| VNC (source) | ✔ | ✔ | ✔ | ✔ | ✔ |
| GenICam (source) | ✔ | ✔ | ✔ | ✔ | ✔ |
| AWS S3 | ✔ | ✔ | ✔ | ✔ | ✔ |

---END OF PAGE---


## .NET SDKs — System Requirements & Platform Support
**URL:** https://www.visioforge.com/help/docs/dotnet/system-requirements/
**Description:** Windows 10/11, macOS 12+, Ubuntu 22.04+, iOS 12+, Android 9+. .NET 6–9, ARM64 support, 4K memory guidelines. WPF, WinForms, MAUI, and Avalonia compatible.
**Tags:** Video Capture SDK, Media Player SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS

# System Requirements for .NET SDKs

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net) [Media Player SDK .Net](https://www.visioforge.com/media-player-sdk-net)

This guide details the system requirements and platform compatibility for VisioForge's suite of .NET SDKs, designed for high-performance video processing and playback applications.

## Overview

Unlock powerful cross-platform video capabilities with VisioForge .NET SDKs, fully compatible with Windows, Linux, macOS, Android, and iOS. Our SDKs provide robust support for .NET Framework, .NET Core, and modern .NET 5+ (including .NET 8 LTS & .NET 9), enabling seamless integration with WinForms, WPF, WinUI 3, Avalonia, .NET MAUI, and Xamarin. Develop high-performance video applications with familiar C# paradigms across all major operating systems and UI frameworks.

> **Important Note**: While Windows users benefit from our dedicated installer package, developers working on other platforms should utilize the NuGet package distribution method for implementation.

## Development Environment Requirements

The following sections outline the specific requirements for setting up your development environment when working with our SDKs.

### Operating Systems for Development

Development of applications using our SDKs is supported on the following platforms:

#### Windows

- Windows 10 (all editions)
- Windows 11 (all editions)
- Recommended: Latest feature update with current security patches

#### Linux

- Ubuntu 22.04 LTS or newer
- Debian 11 or newer
- Other distributions with equivalent libraries may work but are not officially supported

#### macOS

- macOS 12 (Monterey) or newer
- Apple Silicon (M1/M2/M3) and Intel processors supported

### Hardware Requirements

For optimal development experience, we recommend:

- Processor: 4+ cores, 2.5 GHz or faster
- RAM: 8 GB minimum, 16 GB recommended for complex projects
- Storage: SSD with at least 10 GB free space
- Graphics: DirectX 11 compatible GPU (Windows) or Metal-compatible GPU (macOS)

## Target Deployment Platforms

Our SDKs can be deployed to a variety of platforms, enabling wide-reaching distribution of your applications.

### Desktop Platforms

#### Windows

- Windows 10 (version 1809 or newer)
- Windows 11 (all versions)
- Both x86 and x64 architectures supported
- ARM64 support for Windows on ARM devices

#### Linux

- Ubuntu 22.04 LTS or newer
- Other distributions require equivalent libraries and dependencies
- x64 and ARM64 architectures supported

#### macOS

- macOS 12 (Monterey) or newer
- Both Intel and Apple Silicon architectures supported natively
- Rosetta 2 not required for Apple Silicon devices

### Mobile Platforms

#### Android

- Android 9 (API level 28) or newer
- ARM, ARM64, and x86 architectures supported
- Google Play Store compatible
- Hardware-accelerated rendering recommended

#### iOS

- iOS 12 or newer versions
- Compatible with iPhone, iPad, and iPod Touch
- Supports both ARMv7 and ARM64 architectures
- App Store distribution compatible

## .NET Framework Compatibility

Our SDKs provide extensive compatibility with various .NET implementations:

### .NET Framework

- .NET Framework 4.6.1
- .NET Framework 4.7.x
- .NET Framework 4.8
- .NET Framework 4.8.1

### Modern .NET

- .NET Core 3.1 (LTS)
- .NET 5.0
- .NET 6.0 (LTS)
- .NET 7.0
- .NET 8.0 (LTS)
- .NET 9.0

### Xamarin (Legacy)

- Xamarin.iOS 12.0+
- Xamarin.Android 9.0+
- Xamarin.Mac 5.0+

## UI Framework Integration

The SDKs integrate with a wide array of UI frameworks, enabling flexible application development:

### Windows-Specific Frameworks

- Windows Forms (WinForms)
- .NET Framework 4.6.1+ and .NET Core 3.1+
- High-performance rendering options
- Supports designer integration
- Windows Presentation Foundation (WPF)
- .NET Framework 4.6.1+ and .NET Core 3.1+
- Hardware-accelerated rendering
- XAML-based layout with binding support
- Windows UI Library 3 (WinUI 3)
- Desktop applications only
- Modern Fluent Design components
- Windows App SDK integration

### Cross-Platform Frameworks

- .NET MAUI
- Unified development for Windows, macOS, iOS, and Android
- Shared UI code across platforms
- Native performance with shared codebase
- Avalonia UI
- Truly cross-platform UI framework
- XAML-based with familiar paradigms
- Windows, Linux, macOS compatible

### Mobile-Specific Frameworks

- iOS Native UI
- UIKit integration
- SwiftUI compatibility layer
- Storyboard and XIB support
- macOS / Mac Catalyst
- AppKit and UIKit integration
- Mac Catalyst for iPad app adaptation
- Native macOS UI elements
- Android Native UI
- Integration with Android UI toolkit
- Support for Activities and Fragments
- Material Design components compatibility

## Distribution Methods

### NuGet Packages

Our SDKs are available as NuGet packages, simplifying integration with your development workflow.

### Windows Setup

For Windows developers, we offer a dedicated installer package that includes:

- SDK binaries and dependencies
- Documentation and example projects
- Visual Studio integration components
- Developer tools and utilities

## Performance Considerations

### Memory Requirements

- Base memory footprint: ~50MB
- Video processing: Additional 100-500MB depending on resolution and complexity
- 4K video processing: 1GB+ recommended

### CPU Utilization

- Video capture: 10-30% on a modern quad-core CPU
- Real-time effects: Additional 10-40% depending on complexity
- Hardware acceleration recommended for production environments

### Storage Requirements

- SDK installation: ~250MB
- Runtime cache: ~100MB
- Temporary processing files: Up to several GB depending on workload

## Licensing and Deployment

Check out our [Licensing](https://www.visioforge.com/licensing) page for more information on the different licensing options available for our SDKs.

## Technical Support Resources

We provide extensive resources to ensure successful implementation:

- API documentation with code examples
- Implementation guides for various platforms
- Troubleshooting and optimization tips
- Direct support channels for licensed developers

## Code Samples and Examples

Visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) for an extensive collection of code samples demonstrating SDK features and implementation patterns across supported platforms.

## Updates and Maintenance

- Regular SDK updates with new features and optimizations
- Security patches and bug fixes
- Backward compatibility considerations
- Migration guides for version transitions

---

This technical specification document outlines the system requirements and compatibility matrix for our Video Capture SDK .Net and related products. For specific implementation details or custom integration scenarios, please contact our developer support team.

---END OF PAGE---


## Stream to FFmpeg from C# .NET — Pipe Live Video via Stdin
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/3rd-party-software/ffmpeg-streaming/
**Description:** Pipe live video from VisioForge Video Capture SDK to FFmpeg CLI in C# / .NET. Configure codecs, muxers, streaming protocols (RTMP, SRT, HLS). Samples.
**Tags:** Video Capture SDK, .NET, DirectShow, Windows, Capture, Streaming, Encoding, HLS, RTMP, SRT, MP4, WebM

# FFMPEG Streaming Integration with .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Introduction to FFMPEG Streaming

The Video Capture SDK offers powerful capabilities for streaming video from multiple sources directly into FFMPEG, which runs as an external process. This integration provides developers with exceptional flexibility, allowing you to use GPL/LGPL FFMPEG builds with any configuration of video/audio codecs and muxers according to your project requirements.

With this integration, you can:

- Capture video from various sources
- Stream the captured content to FFMPEG
- Configure FFMPEG to save streams to files
- Stream content to remote servers
- Process video in real-time
- Apply filters and transformations

This approach combines the robustness of the .NET SDK with the versatility of FFMPEG, creating a powerful solution for video capture and streaming applications.

## Getting Started with FFMPEG Streaming

Before diving into implementation details, it's important to understand the basic workflow:

1. Configure your video source (capture device, screen, file, etc.)
2. Enable the Virtual Camera output
3. Start the video streaming process
4. Configure and launch FFMPEG with appropriate parameters
5. Process or save the stream as needed

Let's explore each step in detail.

## Basic Implementation

### Step 1: Configure Your Video Source

The first step involves setting up your video source. This can be done either programmatically or through the UI if you're using the Main Demo application. Here's a simple code example to enable the Virtual Camera output:

```
VideoCapture1.Virtual_Camera_Output_Enabled = true;
```

This single line of code activates the Virtual Camera output feature, making the video stream available to FFMPEG.

### Step 2: Start Video Streaming

Once the Virtual Camera output is enabled, you need to initiate the video streaming process. This can be done by calling the appropriate method on your VideoCapture instance:

```
// Configure your video sources
// ...

// Enable the Virtual Camera output
VideoCapture1.Virtual_Camera_Output_Enabled = true;

// Start the streaming process
VideoCapture1.Start();
```

### Step 3: Configure and Launch FFMPEG

Now that your video is streaming and being sent to the Virtual Camera output, you need to configure FFMPEG to receive and process this stream. FFMPEG is launched as an external process with specific command-line arguments:

```
ffmpeg -f dshow -i video="VisioForge Virtual Camera" -c:v libopenh264 output.mp4
```

This command tells FFMPEG to:

- Use DirectShow (`-f dshow`) as the input format
- Capture video from the "VisioForge Virtual Camera" source (`-i video="VisioForge Virtual Camera"`)
- Encode the video using the libopenh264 codec (`-c:v libopenh264`)
- Save the output to a file named "output.mp4"

## Advanced FFMPEG Configuration Options

### Adding Audio to Your Stream

If you want to include audio in your stream, you can use the Virtual Audio Card provided with the SDK:

```
ffmpeg -f dshow -i video="VisioForge Virtual Camera" -f dshow -i audio="VisioForge Virtual Audio Card" -c:v libopenh264 -c:a aac -b:a 128k output.mp4
```

This command adds:

- Audio capture from the Virtual Audio Card
- AAC audio encoding with a bitrate of 128 kbps

### Streaming to RTMP Servers

For live streaming to platforms like YouTube, Twitch, or Facebook, you can use RTMP:

```
ffmpeg -f dshow -i video="VisioForge Virtual Camera" -f dshow -i audio="VisioForge Virtual Audio Card" -c:v libx264 -preset veryfast -tune zerolatency -c:a aac -b:a 128k -f flv rtmp://your-streaming-server/app/key
```

This configuration:

- Uses the x264 codec for video encoding
- Sets the encoding preset to "veryfast" for reduced CPU usage
- Enables zero-latency tuning for live streaming
- Outputs to the FLV format
- Sends the stream to your RTMP server URL

### HLS Streaming

HTTP Live Streaming (HLS) is another popular option, especially for web and mobile viewers:

```
ffmpeg -f dshow -i video="VisioForge Virtual Camera" -c:v libx264 -c:a aac -b:a 128k -f hls -hls_time 4 -hls_playlist_type event stream.m3u8
```

This command:

- Creates HLS segments of 4 seconds each
- Sets the playlist type to "event"
- Generates an m3u8 playlist file and TS segment files

## Performance Optimization

When working with FFMPEG streaming, several factors can affect performance:

### Hardware Acceleration

Enabling hardware acceleration can significantly reduce CPU usage and improve performance:

```
ffmpeg -f dshow -i video="VisioForge Virtual Camera" -c:v h264_nvenc -preset llhq -b:v 5M output.mp4
```

This example uses NVIDIA's NVENC encoder for H.264 encoding, which offloads encoding work to the GPU.

### Buffer Size Configuration

Adjusting buffer sizes can help with stability, especially for high-resolution streams:

```
ffmpeg -f dshow -video_size 1920x1080 -framerate 30 -i video="VisioForge Virtual Camera" -c:v libx264 -bufsize 5M -maxrate 5M output.mp4
```

### Multi-threading Options

Controlling how FFMPEG utilizes CPU threads can optimize performance:

```
ffmpeg -f dshow -i video="VisioForge Virtual Camera" -c:v libx264 -threads 4 output.mp4
```

## Common Use Cases

### Recording Surveillance Video

FFMPEG is excellent for surveillance applications, supporting features like timestamp overlays:

```
ffmpeg -f dshow -i video="VisioForge Virtual Camera" -vf "drawtext=text='%{localtime}':fontcolor=white:fontsize=24:box=1:boxcolor=black@0.5:x=10:y=10" -c:v libx264 surveillance.mp4
```

### Creating Time-lapse Videos

You can configure FFMPEG to create time-lapse videos from your streams:

```
ffmpeg -f dshow -i video="VisioForge Virtual Camera" -vf "setpts=0.1*PTS" -c:v libx264 timelapse.mp4
```

### Multiple Output Formats Simultaneously

FFMPEG can generate multiple outputs from a single input stream:

```
ffmpeg -f dshow -i video="VisioForge Virtual Camera" -c:v libx264 -f mp4 output.mp4 -c:v libvpx -f webm output.webm
```

## Deployment Requirements

To successfully deploy applications using this streaming approach, ensure you include:

- Base SDK redistributables
- SDK-specific redistributables
- Virtual Camera SDK redistributables

For detailed information about deployment requirements, refer to the [Deployment](../../deployment/) page in the documentation.

## Troubleshooting Common Issues

### Stream Not Appearing in FFMPEG

If FFMPEG doesn't recognize the Virtual Camera:

- Ensure the Virtual Camera driver is properly installed
- Verify that the Virtual Camera output is enabled in your code
- Check that the video streaming has successfully started

### Video Quality Issues

If the video quality is poor:

- Increase the bitrate in your FFMPEG command
- Adjust the encoding preset (slower presets generally produce better quality)
- Check your source video resolution and frame rate

### High CPU Usage

To address high CPU utilization:

- Enable hardware acceleration if available
- Use a faster encoding preset
- Reduce the output resolution or frame rate

## Conclusion

Integrating FFMPEG streaming with the Video Capture SDK provides a powerful and flexible solution for video processing and streaming needs. By following the guidelines and examples in this documentation, you can create sophisticated video applications that leverage the strengths of both technologies.

Whether you're building a streaming application, a surveillance system, or a video processing tool, this integration offers the performance and flexibility needed for professional-grade solutions.

---

For more code samples and examples, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Stream to OBS, FFmpeg, and Zoom via Virtual Camera in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/3rd-party-software/
**Description:** Stream video to OBS and FFMPEG from VisioForge Video Capture SDK. DirectShow virtual camera setup for WinForms, WPF, and Console apps with code examples.
**Tags:** Video Capture SDK, .NET, DirectShow, Streaming

# Integrating Third-Party Software with Video Capture SDK

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Overview

The Video Capture SDK .NET provides robust capabilities for integrating with various third-party software applications. This integration expands the functionality of your applications and allows for greater flexibility in video processing workflows.

## How Integration Works

The SDK uses Virtual Camera SDK as a bridge between our Video Capture SDK and third-party applications. This bridge creates a virtual camera device that can be detected and used by any DirectShow-compatible application in your development environment.

### Video Bridge

The virtual camera technology allows captured video streams to be seamlessly passed to external applications without quality loss or significant performance impact.

### Audio Bridge

In addition to video, an audio bridge is also provided, enabling complete audio-visual integration with external software.

## Compatible Applications

The virtual camera works with numerous DirectShow-compatible applications, including:

- OBS (Open Broadcaster Software)
- FFMPEG
- VLC Media Player
- Zoom, Teams, and other conferencing software
- Custom DirectShow applications

## Detailed Tutorials

Our step-by-step tutorials guide you through the integration process with popular applications:

- [FFMPEG Streaming Integration](ffmpeg-streaming/) - Learn how to use FFMPEG with the SDK for powerful streaming capabilities
- [OBS Streaming Setup](obs-streaming/) - Detailed guide for integrating with Open Broadcaster Software

## Development Resources

We provide extensive documentation and examples to help you implement these integrations in your software projects. The integration works across all supported platforms:

- WinForms applications
- WPF (Windows Presentation Foundation) applications
- Console applications

---

For additional implementation examples and code samples, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Send Live Video and Audio to OBS Studio from C# .NET App
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/3rd-party-software/obs-streaming/
**Description:** Send live video and audio to OBS Studio from VisioForge Video Capture SDK. Virtual camera setup, codec configuration, and broadcast pipeline examples.
**Tags:** Video Capture SDK, .NET, DirectShow, VideoCaptureCore, Windows, Capture, Streaming, Webcam, C#
**API:** VideoCaptureCore

# Integrating OBS Streaming in Video Capture SDK .Net

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Introduction to OBS Integration

Open Broadcaster Software (OBS) has become the industry standard for live streaming and video recording. The Video Capture SDK .Net provides robust capabilities to stream video and audio from multiple sources directly into OBS, creating a powerful pipeline for broadcast-quality content creation.

This integration allows developers to build applications that can:

- Capture from multiple camera devices simultaneously
- Process and enhance video streams in real-time
- Mix various content sources before sending to OBS
- Create professional broadcasting solutions with minimal setup

Whether you're developing applications for WinForms, WPF, or console environments, the SDK provides a consistent API for OBS integration.

## How OBS Integration Works

The SDK leverages DirectShow Virtual Camera technology to create a bridge between your application and OBS. This approach offers several advantages:

1. **Zero-latency streaming**: Direct memory transfer minimizes delay
2. **Format flexibility**: Support for various resolutions and frame rates
3. **Minimal configuration**: OBS recognizes the virtual device automatically
4. **Audio synchronization**: Combined audio-video streaming capabilities

The virtual camera appears to OBS as a standard webcam device, making it immediately usable within any OBS scene.

## Implementation Guide

### Required Components

Before implementing OBS streaming, ensure you have the following components installed:

- Video Capture SDK .Net (latest version recommended)
- DirectShow Virtual Camera components
- OBS Studio (version 27.0 or higher recommended)
- .NET Framework 4.6.2 or higher (for full compatibility)

### Basic Implementation

The following code demonstrates how to enable virtual camera output in your application:

```
// Initialize the video capture component
var videoCapture = new VideoCaptureCore();

// Configure basic capture settings
// ...

// Enable virtual camera output
videoCapture.Virtual_Camera_Output_Enabled = true;

// Start capture
videoCapture.Start();
```

This minimal implementation will send the camera feed to the virtual device that OBS can use as an input source.

## Configuring OBS for SDK Integration

### Adding the Virtual Camera Source

1. Launch OBS Studio
2. In your scene, click the "+" button under Sources
3. Select "Video Capture Device" from the list
4. Name your source (e.g., "Virtual Camera SDK")
5. In the Properties dialog, select "VisioForge Virtual Camera" from the Device dropdown
6. Configure resolution and FPS to match your SDK settings
7. Click "OK" to add the source

### Audio Configuration

For audio streaming, enable the virtual camera output together with audio recording on the `VideoCaptureCore` engine — the "VisioForge Virtual Audio Card" is routed automatically when both flags are on. Then select that device in OBS:

```
// Enable the virtual camera output on the VideoCaptureCore engine.
// When combined with Audio_RecordAudio = true, audio is automatically
// routed to the virtual audio card — no separate flag.
VideoCapture1.Virtual_Camera_Output_Enabled = true;

// Configure your audio source as usual.
VideoCapture1.Audio_CaptureDevice  = new AudioCaptureSource("Microphone");
VideoCapture1.Audio_PlayAudio      = false;
VideoCapture1.Audio_RecordAudio    = true;

await VideoCapture1.StartAsync();
```

Then on the OBS side:

1. Add an "Audio Input Capture" source
2. Select "VisioForge Virtual Audio Card" as the device
3. Adjust audio levels and filters as needed

This creates a complete audio-visual pipeline from your application to OBS.

## Performance Considerations

When streaming to OBS, consider these performance tips:

1. **Resolution matching**: Set the same resolution in both SDK and OBS
2. **Frame rate consistency**: Maintain consistent FPS throughout the pipeline
3. **CPU usage**: Monitor processor load, especially when using frame processing
4. **Memory management**: Dispose of unneeded resources promptly
5. **Buffer size**: Adjust buffer sizes based on available system memory

For optimal performance, we recommend using a dedicated GPU for video processing tasks.

## Required Redistributables

Ensure the following components are included in your application deployment:

- Base redistributable package
- SDK redistributable components
- Virtual Camera SDK redistributable files

Review the full [Deployment](../../deployment/) documentation for detailed instructions.

## Troubleshooting Common Issues

If you encounter issues with OBS integration:

1. **Virtual camera not appearing in OBS**: Verify that the virtual camera driver is properly installed
2. **Poor performance**: Check resolution and frame rate settings in both SDK and OBS
3. **Audio sync issues**: Ensure audio and video streams use the same timing mechanism
4. **Video quality problems**: Verify encoding settings and buffer configurations
5. **Application crashes**: Check for proper initialization and shutdown of SDK components

## Conclusion

Integrating OBS streaming capabilities into your .NET applications using the Video Capture SDK provides a powerful foundation for building professional broadcasting solutions. The DirectShow Virtual Camera approach ensures compatibility with OBS while maintaining high performance and quality.

By following the implementation guide and best practices outlined in this document, developers can create sophisticated streaming applications that leverage the combined strengths of the SDK and OBS.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Capture System Audio and Record Microphone in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/audio-capture/
**Description:** Record microphone audio and capture system sound (speaker/loopback) in C# with VisioForge SDK. Complete code examples for audio-only recording to MP3, M4A, WAV.
**Tags:** Video Capture SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming
**API:** DeviceEnumerator, VideoCaptureCoreX, LoopbackAudioCaptureDeviceSourceSettings, SystemAudioSourceBlock, MediaBlocksPipeline

# Audio Capture and System Sound Recording in C# .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Introduction

The VisioForge Video Capture SDK provides audio capture capabilities for .NET developers, covering microphone recording, system audio (loopback/speaker) capture, and combined audio recording. Whether you're building a podcast recorder, screen recording tool with audio, or a voice capture application, the SDK handles device enumeration, format negotiation, and encoding.

This guide provides complete, runnable code examples for the most common audio capture scenarios using both the **Video Capture SDK X** and **Media Blocks SDK** APIs.

## Supported Audio Sources

- **Physical microphones** — Desktop, USB, and Bluetooth microphones
- **Line-in ports** — External mixers or instruments
- **System audio (loopback)** — Record what's playing through your speakers or headphones
- **Virtual audio devices** — Capture audio from other applications
- **Network streams** — Audio from RTSP, HTTP, and other streaming sources

For detailed source configuration, see [Audio Sources](../audio-sources/).

## Audio Format Support

### Lossy Formats

- [MP3](../../general/audio-encoders/mp3/) — Industry standard, adjustable bitrates from 8 kbps to 320 kbps
- [M4A (AAC)](../../general/audio-encoders/aac/) — Excellent quality-to-size ratio
- [Windows Media Audio](../../general/audio-encoders/wma/) — Good compression with Windows integration
- [Ogg Vorbis](../../general/audio-encoders/vorbis/) — Open-source, excellent quality at lower bitrates
- [Speex](../../general/audio-encoders/speex/) — Optimized for speech

### Lossless Formats

- [WAV](../../general/audio-encoders/wav/) — Uncompressed, perfect quality
- [FLAC](../../general/audio-encoders/flac/) — Lossless compression without quality loss

## Record Microphone Audio to MP3

This console application records audio from the default microphone and saves it as an MP3 file.

### Required NuGet Packages

```
dotnet add package VisioForge.DotNet.Core
dotnet add package VisioForge.DotNet.VideoCapture
```

Add the [redist package](../../deployment-x/) for your platform (e.g., `VisioForge.DotNet.Core.Redist.Base.x64`).

The same packages are used for the 30-day trial and licensed applications. See the [VisioForge licensing page](https://www.visioforge.com/licensing) for trial terms and `.vflicense` activation.

### Complete Example

```
using System;
using System.IO;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.VideoCaptureX;

class Program
{
    static async Task Main(string[] args)
    {
        // Initialize SDK
        await VisioForgeX.InitSDKAsync();

        var videoCapture = new VideoCaptureCoreX();

        try
        {
            // Enumerate audio capture devices
            var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync(
                AudioCaptureDeviceAPI.DirectSound);

            if (audioDevices.Length == 0)
            {
                Console.WriteLine("No audio capture device found.");
                return;
            }

            // Display available devices
            Console.WriteLine("Available audio devices:");
            for (int i = 0; i < audioDevices.Length; i++)
            {
                Console.WriteLine($"  {i + 1}. {audioDevices[i].DisplayName}");
            }

            // Select first device (default microphone)
            var selectedDevice = audioDevices[0];
            var audioFormat = selectedDevice.GetDefaultFormat();
            var audioSource = selectedDevice.CreateSourceSettingsVC(audioFormat);

            // Configure audio-only capture
            videoCapture.Audio_Source = audioSource;
            videoCapture.Video_Source = null;
            videoCapture.Video_Play = false;
            videoCapture.Audio_Play = false;
            videoCapture.Audio_Record = true;

            // Configure MP3 output
            string outputPath = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.MyMusic),
                $"mic_recording_{DateTime.Now:yyyyMMdd_HHmmss}.mp3");

            var mp3Output = new MP3Output(outputPath);
            videoCapture.Outputs_Add(mp3Output, autostart: true);

            // Start recording
            await videoCapture.StartAsync();
            Console.WriteLine($"Recording to: {outputPath}");
            Console.WriteLine("Press ENTER to stop...");
            Console.ReadLine();

            // Stop and save
            await videoCapture.StopAsync();
            Console.WriteLine("Recording saved.");
        }
        finally
        {
            await videoCapture.DisposeAsync();
            VisioForgeX.DestroySDK();
        }
    }
}
```

## Capture System Audio (Speaker / Loopback)

System audio capture (also called loopback or speaker capture) records any sound playing through your computer's output device. This is commonly used for screen recording with audio, capturing conference calls, or recording streaming audio.

On Windows, loopback capture uses the **WASAPI2** API to access output devices.

### Complete Example — Video Capture SDK X

```
using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.VideoCaptureX;

class Program
{
    static async Task Main(string[] args)
    {
        // Initialize SDK
        await VisioForgeX.InitSDKAsync();

        var videoCapture = new VideoCaptureCoreX();

        try
        {
            // Enumerate WASAPI2 audio output devices (speakers/headphones)
            var audioOutputs = await DeviceEnumerator.Shared.AudioOutputsAsync(
                AudioOutputDeviceAPI.WASAPI2);

            if (audioOutputs.Length == 0)
            {
                Console.WriteLine("No WASAPI2 audio output device found.");
                return;
            }

            // Display available loopback sources
            Console.WriteLine("Available loopback devices:");
            for (int i = 0; i < audioOutputs.Length; i++)
            {
                Console.WriteLine($"  {i + 1}. {audioOutputs[i].Name}");
            }

            // Select the first device
            var outputDevice = audioOutputs[0];

            // Create loopback source settings
            var audioSource = new LoopbackAudioCaptureDeviceSourceSettings(outputDevice);
            videoCapture.Audio_Source = audioSource;

            // Configure for audio-only capture
            videoCapture.Audio_Play = false;
            videoCapture.Audio_Record = true;
            videoCapture.Video_Play = false;

            // Configure M4A (AAC) output
            string outputPath = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.MyMusic),
                $"system_audio_{DateTime.Now:yyyyMMdd_HHmmss}.m4a");

            var m4aOutput = new M4AOutput(outputPath);
            videoCapture.Outputs_Add(m4aOutput, autostart: true);

            // Start capturing system audio
            await videoCapture.StartAsync();
            Console.WriteLine($"Capturing system audio to: {outputPath}");
            Console.WriteLine("Play some audio on your computer, then press ENTER to stop...");
            Console.ReadLine();

            // Stop and save
            await videoCapture.StopAsync();
            Console.WriteLine("Recording saved.");
        }
        finally
        {
            await videoCapture.DisposeAsync();
            VisioForgeX.DestroySDK();
        }
    }
}
```

### Complete Example — Media Blocks SDK

The Media Blocks SDK uses a pipeline approach where you connect source, processing, and output blocks. This example captures system audio using `SystemAudioSourceBlock` and saves it to an M4A file.

```
using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.Types.X.Sources;

class Program
{
    static async Task Main(string[] args)
    {
        // Initialize SDK
        await VisioForgeX.InitSDKAsync();

        MediaBlocksPipeline pipeline = null;

        try
        {
            // Get the first WASAPI2 output device for loopback capture
            var audioOutputs = await DeviceEnumerator.Shared.AudioOutputsAsync(
                AudioOutputDeviceAPI.WASAPI2);

            if (audioOutputs.Length == 0)
            {
                Console.WriteLine("No WASAPI2 audio output device found.");
                return;
            }

            var outputDevice = audioOutputs[0];
            Console.WriteLine($"Using loopback device: {outputDevice.Name}");

            // Create pipeline
            pipeline = new MediaBlocksPipeline();

            // Create loopback audio source
            var sourceSettings = new LoopbackAudioCaptureDeviceSourceSettings(outputDevice);
            var audioSource = new SystemAudioSourceBlock(sourceSettings);

            // Create M4A output
            string outputPath = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.MyMusic),
                $"system_audio_{DateTime.Now:yyyyMMdd_HHmmss}.m4a");

            var output = new M4AOutputBlock(outputPath);

            // Connect source to output
            pipeline.Connect(audioSource, output);

            // Start pipeline
            await pipeline.StartAsync();
            Console.WriteLine($"Capturing system audio to: {outputPath}");
            Console.WriteLine("Press ENTER to stop...");
            Console.ReadLine();

            // Stop pipeline
            await pipeline.StopAsync();
            Console.WriteLine("Recording saved.");
        }
        finally
        {
            if (pipeline != null)
            {
                await pipeline.DisposeAsync();
            }

            VisioForgeX.DestroySDK();
        }
    }
}
```

## Key Features

### Device Control

- Enumerate all available audio input and output devices
- Select specific input devices programmatically
- Set input volume levels and mute status
- Monitor audio levels in real-time with [VU meters](../../general/code-samples/vu-meters/)
- Auto-select default system devices

### Advanced Processing

- Real-time audio visualization with spectrum and waveform analysis
- Noise reduction and echo cancellation
- Gain control and normalization
- Voice activity detection (VAD)
- Stereo/mono channel management
- Sample rate conversion

### Recording Controls

- Start, pause, resume, and stop recording
- Buffer management for low-latency operation
- Timed recordings with automatic stop
- File splitting for large recordings
- Auto file naming with timestamps

## Cross-Platform Notes

| Platform | Microphone | System Audio (Loopback) |
| --- | --- | --- |
| Windows | DirectSound, WASAPI2 | WASAPI2 loopback |
| macOS | CoreAudio | Not available via SDK |
| Linux | PulseAudio, ALSA | PulseAudio monitor |

System audio loopback capture is primarily a Windows feature using the WASAPI2 API. On Linux, PulseAudio monitor devices may provide similar functionality.

## Best Practices

1. **Check device availability** before starting capture — devices can be disconnected at any time
2. **Monitor audio levels** during recording to detect silence or clipping
3. **Choose the right format** — MP3/M4A for compressed output, WAV for maximum quality, FLAC for lossless compression
4. **Use WASAPI2** for loopback capture on Windows — it provides the lowest latency and most reliable system audio capture
5. **Handle errors gracefully** — implement error handling for device disconnection events
6. **Test on target hardware** — audio device behavior varies across systems

## Sample Applications

Complete working examples are available on GitHub:

- [Speaker Capture — Media Blocks SDK](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/_CodeSnippets/speaker-capture)
- [Speaker Capture — Video Capture SDK X](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/_CodeSnippets/speaker-capture)
- [Audio Capture Demo — Video Capture SDK X](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X)

## Related Documentation

- [Audio Sources — Device Configuration](../audio-sources/)
- [Audio Rendering — Playback](../audio-rendering/)
- [WMA Recording and Editing](../../general/guides/wma-recording-editing/)
- [Screen Capture with Audio](../video-tutorials/screen-capture-mp4/)

---END OF PAGE---


## Audio Output Device Selection and Volume Control in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/audio-rendering/
**Description:** Configure audio output devices, adjust volume, and optimize playback in VisioForge Video Capture SDK. C# code examples for WinForms and WPF apps.
**Tags:** Video Capture SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture
**API:** AudioRendererSettings

# Audio Rendering in .NET Video Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [VideoCaptureCoreX](#) [VideoCaptureCore](#)

## Introduction to Audio Rendering

Audio rendering is a critical component of any video capture application. It enables your application to output captured or processed audio to various audio devices supported by the operating system. The Video Capture SDK .NET provides robust capabilities for audio rendering, allowing developers to create rich multimedia applications with high-quality audio output.

This guide walks through the essential aspects of implementing audio rendering in your .NET applications using our SDK, covering everything from device enumeration to volume control and optimization techniques.

## Key Features of Audio Rendering

- **Device Selection**: Enumerate and select from all available audio output devices
- **Volume Control**: Precise control over output volume levels
- **Real-time Adjustment**: Modify audio output parameters during runtime
- **Multi-device Support**: Route audio to different output devices simultaneously
- **Format Compatibility**: Support for various audio formats and sample rates

## Implementation Guide

### Enumerating Audio Output Devices

The first step in implementing audio rendering is to identify and list all available audio output devices. This allows users to select their preferred output device for audio playback.

VideoCaptureCoreXVideoCaptureCore

```
var audioSinks = await VideoCapture1.Audio_OutputsAsync();
foreach (var sink in audioSinks)
{
    // add to some combobox
    cbAudioOutputDevice.Items.Add(sink.DisplayName);
}
```

```
// Audio_OutputDevices() returns ObservableCollection<string> — the element IS the device name.
foreach (var deviceName in VideoCapture1.Audio_OutputDevices())
{
    // add to some combobox
    cbAudioOutputDevice.Items.Add(deviceName);
}
```

The above code demonstrates how to retrieve all available audio output devices and populate a selection control such as a ComboBox. This gives users the flexibility to choose their preferred audio output device.

### Setting the Audio Output Device

Once the user has selected an audio output device, you need to configure the SDK to use that device for audio playback.

VideoCaptureCoreXVideoCaptureCore

```
// VideoCaptureCoreX uses Audio_OutputsAsync() to enumerate AudioOutputDeviceInfo objects.
var audioOutputDevice = (await VideoCapture1.Audio_OutputsAsync())
    .First(device => device.DisplayName == cbAudioOutputDevice.Text);
VideoCapture1.Audio_OutputDevice = new AudioRendererSettings(audioOutputDevice);
```

```
VideoCapture1.Audio_PlayAudio = true;
VideoCapture1.Audio_OutputDevice = "Device name";
```

In VideoCaptureCoreX, we first retrieve the selected device object and then create an AudioRendererSettings instance to configure the output. In VideoCaptureCore, the process is simpler, requiring only the device name string and enabling audio playback.

### Controlling Audio Volume

Volume control is an essential feature for any audio application. The SDK provides straightforward methods to adjust the output volume during playback.

VideoCaptureCoreXVideoCaptureCore

```
VideoCapture1.Audio_OutputDevice_Volume = 0.75; // 75%
```

```
VideoCapture1.Audio_OutputDevice_Volume_Set(75); // 75%
```

Both implementations allow setting the volume as a percentage (0-100%). In VideoCaptureCoreX, the volume is set as a floating-point value between 0 and 1, while VideoCaptureCore uses an integer percentage.

## Troubleshooting Common Issues

### No Audio Output

If you're experiencing issues with audio output:

1. **Verify device availability**: Ensure the selected audio device is connected and functioning
2. **Check volume settings**: Confirm that the volume is set to an audible level
3. **Examine format compatibility**: Some devices might not support certain audio formats

### Audio Latency Problems

High audio latency can affect user experience:

1. **Reduce buffer size**: Smaller buffer sizes can reduce latency but may increase CPU usage
2. **Optimize processing pipeline**: Remove unnecessary audio processing steps
3. **Check hardware capabilities**: Some audio devices inherently have higher latency

### Audio Quality Issues

For optimal audio quality:

1. **Use appropriate sample rates**: Match the sample rate to your source material
2. **Consider bit depth**: Higher bit depths provide better quality but consume more resources
3. **Monitor CPU usage**: Audio dropouts can occur when the system is overloaded

## Conclusion

Audio rendering is a vital component of multimedia applications. The Video Capture SDK .NET provides powerful tools for implementing high-quality audio playback in your applications. By following the guidelines and examples in this document, you can create sophisticated audio rendering solutions that enhance your users' experience.

The SDK's flexible architecture accommodates both simple audio playback scenarios and complex multi-device setups, making it suitable for a wide range of applications from basic video players to professional multimedia production tools.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Audio Sources in C# .NET — Mic, Loopback, and IP Audio
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/audio-sources/
**Description:** Configure audio capture sources in C# .NET — microphone, system audio loopback, IP camera audio, and Decklink with code examples.
**Tags:** Video Capture SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming
**API:** IVideoCaptureBaseAudioSourceSettings, AudioCaptureSource, DeviceEnumerator, LoopbackAudioCaptureDeviceSourceSettings, AudioCaptureDeviceFormat

# Working with Audio Sources in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [VideoCaptureCoreX](#) [VideoCaptureCore](#)

## Available Audio Sources

When building media applications, you'll need to capture audio from various sources. This guide covers how to implement audio capture from multiple input types using our SDK:

- Audio capture devices (microphones, line-in)
- System audio (speakers/headphones via loopback)
- Network streams (IP cameras)
- Professional Decklink devices

Each source type requires different initialization methods and has unique capabilities. Let's explore how to work with each one.

## Implementing Audio Capture Devices

Audio capture devices include microphones, webcams with built-in mics, and other input hardware connected to your system. Working with these devices involves three key steps:

1. Enumerating available devices
2. Selecting appropriate audio formats
3. Configuring the selected device as your audio source

### Enumerating Available Audio Devices

First, you need to detect all audio input devices connected to the system:

VideoCaptureCoreXVideoCaptureCore

```
var audioSources = await core.Audio_SourcesAsync();
foreach (var source in audioSources)
{
    // add to some combobox
    cbAudioInputDevice.Items.Add(source.DisplayName);
}
```

```
foreach (var device in core.Audio_CaptureDevices())
{
    // add to some combobox
    cbAudioInputDevice.Items.Add(device.Name);
}
```

This code retrieves all audio input devices and can display them in a dropdown for user selection. The async approach in VideoCaptureCoreX provides better performance for systems with many connected devices.

### Discovering Supported Audio Formats

Once you've identified available devices, you'll need to determine which audio formats each device supports:

VideoCaptureCoreXVideoCaptureCore

```
// find the device by name
var deviceItem = (await VideoCapture1.Audio_SourcesAsync()).FirstOrDefault(device => device.DisplayName == "Some device name");
if (deviceItem == null)
{
    return;
}

// enumerate formats
foreach (var format in deviceItem.Formats)
{
    cbAudioInputFormat.Items.Add(format.Name);
}
```

```
// find the device by name
var deviceItem = VideoCapture1.Audio_CaptureDevices().FirstOrDefault(device => device.Name == "Some device name");

// enumerate formats
foreach (var format in deviceItem.Formats)
{
    cbAudioInputFormat.Items.Add(format);
}
```

Different audio devices support various formats with different bit depths, sample rates, and channel configurations. Enumerating these options allows you to select the most appropriate format for your application's needs.

### Setting Up the Audio Capture Device

After selecting a device and format, configure it as your audio source:

VideoCaptureCoreXVideoCaptureCore

```
// Enumerate audio capture devices asynchronously (Audio_SourcesAsync returns AudioCaptureDeviceInfo[]).
var devices = await VideoCapture1.Audio_SourcesAsync();
var deviceItem = devices.FirstOrDefault(d => d.Name == "Device name");
if (deviceItem == null)
{
    return;
}

// Pick the first reported format on that device.
AudioCaptureDeviceFormat format = deviceItem.Formats[0].ToFormat();

// Build source settings and assign.
IVideoCaptureBaseAudioSourceSettings audioSource = deviceItem.CreateSourceSettingsVC(format);
VideoCapture1.Audio_Source = audioSource;
```

```
// find the device by name
var deviceItem = VideoCapture1.Audio_CaptureDevices().FirstOrDefault(device => device.Name == "Some device name");
VideoCapture1.Audio_CaptureDevice = new AudioCaptureSource(deviceItem.Name);
VideoCapture1.Audio_CaptureDevice.Format = deviceItem.Formats[0].ToString(); // set the first format
```

This code configures your application to capture audio from the selected device using the specified format. The VideoCaptureCoreX API provides more granular control over format selection and device configuration.

## Capturing System Audio via Loopback

Audio loopback allows you to record any sound playing through your system's speakers or headphones. This is particularly useful for:

- Screen recording with audio
- Capturing application sounds
- Recording audio from web conferences or streaming services

Here's how to implement it:

VideoCaptureCoreXVideoCaptureCore

First, enumerate available loopback devices:

```
// Enumerate audio loopback devices
var audioSinks = await DeviceEnumerator.Shared.AudioOutputsAsync();
foreach (var sink in audioSinks)
{
    // Filter by WASAPI2 API
    if (sink.API == AudioOutputDeviceAPI.WASAPI2)
    {
        // Add to some combobox
        cbAudioLoopbackDevice.Items.Add(sink.Name);
    }
}
```

Next, create source settings for your selected output device:

```
// audio input
var deviceItem = (await DeviceEnumerator.Shared.AudioOutputsAsync(AudioOutputDeviceAPI.WASAPI2)).FirstOrDefault(device => device.Name == "Output device name");
if (deviceItem == null)
{
    return;
}

IVideoCaptureBaseAudioSourceSettings audioSource = new LoopbackAudioCaptureDeviceSourceSettings(deviceItem);

VideoCapture1.Audio_Source = audioSource;
```

The WASAPI2 API provides the most reliable loopback functionality on Windows systems, with lower latency and better performance compared to other options.

In VideoCaptureCore, loopback functionality is simplified with a dedicated virtual device:

```
VideoCapture1.Audio_CaptureDevice = new AudioCaptureSource("VisioForge What You Hear Source");
VideoCapture1.Audio_CaptureDevice.Format_UseBest = true;
```

This approach automatically selects the best available format for the loopback source, making implementation straightforward.

For complete, runnable speaker capture examples (including Media Blocks SDK pipeline approach), see the [Audio Capture guide](../audio-capture/#capture-system-audio-speaker-loopback).

## Working with Network Audio Sources

For IP cameras and other network streams, audio rides on the same transport as video — you don't usually construct a separate audio source. Create the IP source settings with `audioEnabled: true` and the SDK demuxes audio and video from the same URL:

```
// RTSP camera — audio comes along automatically when audioEnabled is true.
var rtsp = await RTSPSourceSettings.CreateAsync(
    uri: new Uri("rtsp://192.168.1.100:554/Streaming/Channels/101"),
    login: "admin",
    password: "password",
    audioEnabled: true);

VideoCapture1.Video_Source = rtsp;
VideoCapture1.Audio_Record = true;   // include the RTSP-side audio in the file output
```

Audio from network sources may come in various formats (AAC, MP3, PCM) depending on the device. The SDK converts and synchronises automatically.

## Implementing Decklink Audio Capture

Decklink devices deliver professional-grade audio (up to 192 kHz, multichannel, SDI-embedded). Use `DecklinkAudioSourceSettings` and wire it up alongside the Decklink video source:

```
// Enumerate Decklink audio inputs.
var devices = await DeviceEnumerator.Shared.DecklinkAudioSourcesAsync();
var dl = devices.First();

// Attach the audio source to VideoCaptureCoreX. The matching video source goes on Video_Source.
VideoCapture1.Audio_Source = new DecklinkAudioSourceSettings(dl);
VideoCapture1.Audio_Record = true;
```

Audio settings are largely driven by the device's current mode (sample rate, channel count are fixed by the incoming SDI signal) — you don't typically override them on the settings class.

## Best Practices for Audio Capture

To ensure high-quality audio capture in your applications:

1. **Sample rate selection**: Choose appropriate sample rates based on your target output. For most applications, 44.1kHz or 48kHz is sufficient.
2. **Buffer management**: Configure appropriate buffer sizes to balance between latency and stability. Smaller buffers reduce latency but may cause audio dropouts.
3. **Format handling**: Support multiple formats to accommodate various devices. Always have fallback options when specific formats aren't available.
4. **Level monitoring**: Implement audio level monitoring to detect silence or clipping, allowing your application to respond appropriately.
5. **Error handling**: Implement robust error handling for device disconnections or format negotiation failures.

## Conclusion

Implementing audio capture capabilities in your .NET application involves selecting the appropriate source, configuring formats, and managing the audio stream. Whether you're capturing from microphones, system audio, or network sources, our SDK provides the tools needed to build sophisticated audio applications.

By following the code examples and implementation patterns outlined in this guide, you'll be able to integrate powerful audio capture functionality into your projects efficiently.

## Sample Applications

Complete working examples are available on GitHub:

- [All Video Capture SDK X Samples](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X)

---END OF PAGE---


## VisioForge Video Capture SDK in C# .NET — Cheat Sheet
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/cheat-sheet/
**Description:** One-page Video Capture SDK reference with NuGet packages, VideoCaptureCoreX APIs, MP4 recording flow, platform support, and pitfalls.
**Tags:** Video Capture SDK, .NET, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, Avalonia, MAUI, WPF, WinForms, GStreamer, Capture, Recording, Streaming, Encoding, Webcam, IP Camera, Screen Capture, RTSP, MP4, H.264, H.265, AAC, C#, NuGet
**API:** VideoCaptureCoreX, VideoCaptureDeviceSourceSettings, DeviceEnumerator, VideoView, MP4Output

# VisioForge Video Capture SDK .Net — Cheat Sheet

Video Capture SDK .Net captures from webcams, IP cameras (RTSP/ONVIF), screens, Decklink, and GenICam/GigE Vision devices on all 5 .NET platforms (Windows, macOS, Linux, Android, iOS). `VideoCaptureCoreX` is the cross-platform engine; sources are configured via typed settings classes such as `VideoCaptureDeviceSourceSettings`, and devices are listed asynchronously with `DeviceEnumerator`.

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Platform support

- **Windows x64 / x86** — WinForms, WPF, MAUI, Avalonia, Console. Full DirectShow sources + NVENC / AMF / Intel Quick Sync hardware encoding.
- **macOS / macCatalyst** — MAUI, Avalonia, Console. AVFoundation camera sources + VideoToolbox hardware encoding.
- **Linux x64** — Avalonia, Console. V4L2 camera sources + NVENC / VA-API hardware encoding.
- **Android** — MAUI. Native camera sources + MediaCodec hardware encoding.
- **iOS** — MAUI. AVFoundation camera sources + VideoToolbox hardware encoding.

For the full codec × source × platform matrix see [platform-matrix.md](../../platform-matrix/).

## NuGet packages

Main SDK package (required, all platforms):

```
<PackageReference Include="VisioForge.DotNet.VideoCapture" Version="2026.*" />
```

Platform-specific native runtimes — add the ones you target:

```
<!-- Windows x64 -->
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />

<!-- Windows x86 -->
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x86" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x86" Version="2026.4.29" />

<!-- macOS / macCatalyst -->
<PackageReference Include="VisioForge.CrossPlatform.Core.macOS" Version="2026.8.5" />
<PackageReference Include="VisioForge.CrossPlatform.Core.macCatalyst" Version="2026.8.5" />

<!-- Linux x64 (needs system GStreamer 1.22+) -->
<PackageReference Include="VisioForge.CrossPlatform.Core.Linux.x64" Version="2025.9.0" />

<!-- Android / iOS -->
<PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.7.27" />
<PackageReference Include="VisioForge.CrossPlatform.Core.iOS" Version="2025.12.0" />
```

UI integration (pick the one that matches your UI stack):

```
<PackageReference Include="VisioForge.DotNet.Core.UI.MAUI" Version="2026.*" />
<PackageReference Include="VisioForge.DotNet.Core.UI.Avalonia" Version="2026.*" />
```

WinForms and WPF `VideoView` controls ship inside the main package. For the complete package list (including redistributables for the Windows-only `VideoCaptureCore` engine) see the [Installation Guide](../../install/).

## Primary API classes

| Class | Role | See also |
| --- | --- | --- |
| `VideoCaptureCoreX` | Cross-platform capture engine — owns the pipeline, source, outputs, preview | [Quick Start](../) |
| `VideoCaptureDeviceSourceSettings` | Configures a webcam / USB / DirectShow camera source | [Enumerate and select device](../video-sources/video-capture-devices/enumerate-and-select/) |
| `DeviceEnumerator` | Async enumeration of video sources, audio sources, and audio outputs via `DeviceEnumerator.Shared` | [Video sources overview](../video-sources/) |
| `VideoView` | WinForms / WPF / MAUI / Avalonia preview control bound to the capture engine | [Installation — video controls](../../install/) |
| `MP4Output` | Muxes captured streams to `.mp4` with H.264 / H.265 + AAC (GPU-accelerated when available) | [Webcam → MP4 tutorial](../video-tutorials/video-capture-webcam-mp4/) |

Additional source settings classes: `RTSPSourceSettings` (IP cameras — construct via `RTSPSourceSettings.CreateAsync(uri, login, password, audioEnabled)`, not `new`), `ScreenCaptureD3D11SourceSettings` / `ScreenCaptureGDISourceSettings` / `ScreenCaptureDX9SourceSettings` (Windows screen), `ScreenCaptureMacOSSourceSettings` (macOS), `ScreenCaptureXDisplaySourceSettings` (Linux), `DecklinkVideoSourceSettings`, `GenICamSourceSettings`, `NDISourceSettings`.

## Canonical minimum example

Record the first webcam + default microphone to `recording.mp4`:

```
using VisioForge.Core;
using VisioForge.Core.VideoCaptureX;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.Output;

// 1. Init SDK once at application startup.
await VisioForgeX.InitSDKAsync();

// 2. Enumerate connected devices (async — never block the UI thread).
var videoDevices = await DeviceEnumerator.Shared.VideoSourcesAsync();
var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync();

if (videoDevices.Length == 0)
    throw new InvalidOperationException("No video capture devices found.");

// 3. Create the capture engine, bound to a VideoView for live preview.
//    Pass null instead of videoView for headless recording.
var capture = new VideoCaptureCoreX(videoView);

// 4. Configure video + audio sources.
capture.Video_Source = new VideoCaptureDeviceSourceSettings(videoDevices[0]);
capture.Audio_Source = audioDevices[0].CreateSourceSettingsVC();
capture.Audio_Record = true;

// 5. Add the MP4 output BEFORE calling StartAsync.
capture.Outputs_Add(new MP4Output("recording.mp4"));

// 6. Start capture — preview renders into videoView immediately.
await capture.StartAsync();

// ... later, when the user clicks Stop:
await capture.StopAsync();     // Finalizes and closes the MP4 file.
await capture.DisposeAsync();  // Releases the pipeline.

// 7. On application shutdown:
VisioForgeX.DestroySDK();
```

Swap `VideoCaptureDeviceSourceSettings(...)` for `await RTSPSourceSettings.CreateAsync(new Uri("rtsp://..."), login, password, audioEnabled)` for IP cameras, or `new ScreenCaptureD3D11SourceSettings()` for desktop recording (Windows) — the rest of the pipeline is identical.

## Typical workflow

1. **Init** — `await VisioForgeX.InitSDKAsync()` (once per app).
2. **Enumerate** — `DeviceEnumerator.Shared.VideoSourcesAsync()` / `AudioSourcesAsync()`.
3. **Configure source** — pick a settings class (`VideoCaptureDeviceSourceSettings`, `RTSPSourceSettings`, `ScreenCaptureD3D11SourceSettings` / `ScreenCaptureMacOSSourceSettings` / `ScreenCaptureXDisplaySourceSettings`, `DecklinkVideoSourceSettings`, ...) and assign to `capture.Video_Source`.
4. **Create engine** — `new VideoCaptureCoreX(videoView)` for preview, or `new VideoCaptureCoreX(null)` for headless.
5. **Add outputs** — `capture.Outputs_Add(new MP4Output(path))`, or `MKVOutput` / `WebMOutput` / `AVIOutput` / `RTMPOutput` / `HLSOutput`.
6. **Run** — `StartAsync()` → `StopAsync()` → `DisposeAsync()`, then `VisioForgeX.DestroySDK()` on shutdown.

## Common pitfalls

- **Device enumeration is async.** Always `await DeviceEnumerator.Shared.VideoSourcesAsync()` — calling `.Result` or `.Wait()` on the UI thread can deadlock. Audio uses its own `AudioSourcesAsync()` / `AudioOutputsAsync()` calls; the video enumerator does not cover them.
- **Outputs must be added before `StartAsync`.** `Outputs_Add(...)` during an active capture is not supported — stop, add the output, and start again.
- **Virtual Camera needs extra registration.** The `VirtualCamera` redist package must be registered (see the [deployment guide](../deployment/)) before the virtual camera becomes visible to external applications like Zoom or Teams.
- **AnyCPU apps need both x86 and x64 redistributables.** On Windows, ship both architectures or force a specific one via `<PlatformTarget>` — partial deployment silently fails at source init time.
- **Mobile permissions must be granted before enumeration.** On Android and iOS, camera and microphone permissions must be requested and granted before `DeviceEnumerator` runs — otherwise the returned list is empty. See the [MAUI camera recording guide](../maui/camera-recording-maui/) for per-platform permission setup.

## See also

- **Video sources**
  - Webcam / USB camera → [Enumerate and select a device](../video-sources/video-capture-devices/enumerate-and-select/)
  - IP camera → [RTSP](../video-sources/ip-cameras/rtsp/), [ONVIF](../video-sources/ip-cameras/onvif/), [NDI](../video-sources/ip-cameras/ndi/)
  - Screen capture → [screen.md](../video-sources/screen/)
  - Decklink / GenICam → [decklink.md](../video-sources/decklink/), [USB3 Vision / GigE / GenICam](../video-sources/usb3v-gige-genicam/)
- **Outputs & streaming**
  - MP4 recording → [Webcam → MP4](../video-tutorials/video-capture-webcam-mp4/), [IP camera → MP4](../video-tutorials/ip-camera-capture-mp4/)
  - Network streaming (RTMP / RTSP / HLS / SRT / NDI) → [network-streaming](../network-streaming/)
- **Platform & deployment**
  - Windows / macOS / Ubuntu / Android / iOS → [../deployment-x/](../../deployment-x/)
  - Install & target frameworks → [../install/index.md](../../install/)
  - Full codec × source matrix → [../platform-matrix.md](../../platform-matrix/)
- **MAUI**
  - Cross-platform camera recording → [MAUI camera recording](../maui/camera-recording-maui/)

## FAQ

### How do I list connected cameras?

`var cams = await DeviceEnumerator.Shared.VideoSourcesAsync();` — returns a list of `VideoCaptureDeviceInfo` with friendly names, supported formats, and frame rates.

### Does this SDK support IP cameras?

Yes. Build settings via the async factory — `await RTSPSourceSettings.CreateAsync(new Uri("rtsp://..."), login, password, audioEnabled)` — and pass to `VideoCaptureCoreX.Video_Source`. The constructor is private, so `new RTSPSourceSettings(...)` will not compile. ONVIF and HTTP-JPEG cameras are also supported. See the [IP camera brands directory](../../camera-brands/) for vendor-specific URLs.

### What file formats can I record to?

MP4 (H.264 / H.265 + AAC), MKV, WebM (VP8 / VP9 / AV1 + Opus / Vorbis), AVI, GIF, plus live RTMP / RTSP / HLS / SRT / NDI streaming. See the output-format tables in [the SDK overview](../).

---END OF PAGE---


## Real-Time Face Detection in Live Video Stream in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/computer-vision/face-detection/
**Description:** Detect faces in real-time webcam and IP camera streams with VisioForge Video Capture SDK. Configuration options, optimization tips, and C# code examples.
**Tags:** Video Capture SDK, .NET, Windows, Computer Vision, Webcam, IP Camera, C#, NuGet
**API:** AFFaceDetectionEventArgs, FaceTrackingSettings

# Implementing Face Detection in .NET Video Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Introduction to Face Detection Technology

Face detection is a computer vision technology that identifies and locates human faces within digital images or video frames. Unlike facial recognition (which identifies specific individuals), face detection simply answers the question: "Is there a face in this image, and if so, where is it located?"

This technology serves as the foundation for numerous applications:

- Security and surveillance systems
- Photography applications (auto-focus, red-eye reduction)
- Social media (tagging suggestions, filters)
- Emotion analysis and user experience research
- Attendance tracking systems
- Video conferencing enhancements

For developers building .NET applications, implementing face detection can add significant value to video capture and processing applications. This guide provides a complete walkthrough of implementing face detection in your .NET projects.

## Getting Started with Face Detection in .NET

### Prerequisites

Before implementing face detection in your application, ensure you have:

- Visual Studio (2019 or newer recommended)
- .NET Framework 4.6.2+ or .NET Core 3.1+/.NET 5+
- Basic understanding of C# and event-driven programming
- NuGet package manager
- Required redistributables (detailed later in this document)

### Implementation Overview

The implementation process follows these key steps:

1. Configure your video source
2. Set up face tracking parameters
3. Create and register event handlers for face detection
4. Process detection results
5. Start the video stream

Let's break down each of these steps with detailed code examples.

## Step 1: Configure Your Video Source

Face tracking runs on whatever source the `VideoCaptureCore` instance is bound to. Pick one of the following configurations:

WebcamIP camera (RTSP/HTTP)Video file (Media Player SDK)

```
VideoCapture1.Mode = VideoCaptureMode.VideoPreview;
VideoCapture1.Video_CaptureDevice = new VideoCaptureSource("USB Camera");
VideoCapture1.Video_CaptureDevice.Format_UseBest = true;
```

```
VideoCapture1.Mode = VideoCaptureMode.IPPreview;
VideoCapture1.IP_Camera_Source = new IPCameraSourceSettings
{
    URL = new Uri("rtsp://camera.local:554/stream"),
    Type = IPSourceEngine.Auto_VLC,
    Login = "admin",
    Password = "password"
};
```

For offline file-based face detection, use `MediaPlayerCore` from the Media Player SDK — the `Face_Tracking` property behaves the same across engines. The rest of this guide (Steps 2–5) still applies; replace `VideoCapture1` with your `MediaPlayer1` instance.

Pick one pattern and continue with Step 2 to enable face tracking on that source.

## Step 2: Configure Face Tracking Settings

With your video source configured, the next step is to set up the face detection parameters. These settings determine how the SDK identifies and tracks faces:

```
VideoCapture1.Face_Tracking = new FaceTrackingSettings
{
    // Color mode determines how colors are processed for detection
    ColorMode = CamshiftMode.RGB,

    // Highlight detected faces in the preview
    Highlight = true,

    // Minimum size (in pixels) of face to detect
    MinimumWindowSize = 25,

    // Scanning approach - how the algorithm scales through the image
    ScalingMode = ObjectDetectorScalingMode.GreaterToSmaller,

    // Single or multiple face detection
    SearchMode = ObjectDetectorSearchMode.Single,

    // Scale factor used to walk the pyramid (1.0 < factor <= 2.0)
    ScaleFactor = 1.2f
};
```

### Understanding the Face Tracking Parameters

- **ColorMode** (`CamshiftMode`): Determines how the algorithm processes colors for detection
- RGB: Standard RGB color processing
- HSL: Hue-Saturation-Lightness color space, can be more robust in varying lighting
- Mixed: Combines RGB and HSL channels
- **ScalingMode**: Controls how the algorithm searches through different scales
- GreaterToSmaller: Starts with larger potential faces and works down
- SmallerToGreater: Starts with smaller potential faces and works up
- **SearchMode**: Determines whether to look for single or multiple faces
- Single: Optimized for finding one face (faster)
- Multiple: Designed to find all faces in frame (more processing intensive)
- **MinimumWindowSize**: The smallest face size (in pixels) that will be detected
- Smaller values catch distant faces but increase false positives
- Larger values are more reliable but may miss smaller/distant faces

## Step 3: Set Up Face Detection Event Handling

To respond to detected faces, you need to create an event handler and register it with the SDK:

```
// OnFaceDetected is a standard EventHandler<AFFaceDetectionEventArgs>.
// e.FaceRectangles is a Rectangle[] — use .Length, not .Count.
private void OnFaceDetectedHandler(object sender, AFFaceDetectionEventArgs e)
{
    // Clear previous text
    edFaceTrackingFaces.Text = string.Empty;

    // Process each detected face
    foreach (var faceRectangle in e.FaceRectangles)
    {
        // Display face coordinates and dimensions
        edFaceTrackingFaces.Text +=
            $"Position: ({faceRectangle.Left}, {faceRectangle.Top}), " +
            $"Size: ({faceRectangle.Width}, {faceRectangle.Height}){Environment.NewLine}";

        // You can also calculate center point
        int centerX = faceRectangle.Left + (faceRectangle.Width / 2);
        int centerY = faceRectangle.Top + (faceRectangle.Height / 2);
        edFaceTrackingFaces.Text += $"Center: ({centerX}, {centerY}){Environment.NewLine}";

        // Optional: add timestamp for tracking
        edFaceTrackingFaces.Text += $"Time: {DateTime.Now:HH:mm:ss.fff}{Environment.NewLine}{Environment.NewLine}";
    }

    // Update face count (Rectangle[] — Length, not Count)
    lblFaceCount.Text = $"Faces detected: {e.FaceRectangles.Length}";
}

// Register the event handler
VideoCapture1.OnFaceDetected += OnFaceDetectedHandler;
```

This event handler provides real-time updates whenever faces are detected. The handler receives face coordinates that you can use for:

- Displaying visual indicators
- Tracking face movement over time
- Triggering actions based on face position
- Logging detection data

## Step 4: Processing Detection Results

With the event handler in place, you can process the detection results. Some common processing tasks include:

### Visualizing Detected Faces

Beyond the built-in highlighting, you might want to implement custom visualizations:

```
// Custom visualization - draw face rectangles on an overlay
private void DrawFacesOnOverlay(Rectangle[] faceRectangles, PictureBox overlay)
{
    // Create bitmap for overlay
    Bitmap overlayBitmap = new Bitmap(overlay.Width, overlay.Height);

    using (Graphics g = Graphics.FromImage(overlayBitmap))
    {
        g.Clear(Color.Transparent);

        // Draw each face
        foreach (var face in faceRectangles)
        {
            // Draw rectangle
            g.DrawRectangle(new Pen(Color.GreenYellow, 2), face);

            // Optional: Draw crosshair at center
            int centerX = face.Left + (face.Width / 2);
            int centerY = face.Top + (face.Height / 2);
            g.DrawLine(new Pen(Color.Red, 1), centerX - 10, centerY, centerX + 10, centerY);
            g.DrawLine(new Pen(Color.Red, 1), centerX, centerY - 10, centerX, centerY + 10);
        }
    }

    // Update overlay
    overlay.Image = overlayBitmap;
}
```

### Implementing Face Tracking Logic

For more advanced applications, you might want to track faces over time:

```
private Dictionary<int, TrackedFace> trackedFaces = new Dictionary<int, TrackedFace>();
private int nextFaceId = 1;

private void TrackFaces(List<Rectangle> currentFaces)
{
    // Match current faces with previously tracked faces
    List<int> matchedIds = new List<int>();
    List<Rectangle> unmatchedFaces = new List<Rectangle>(currentFaces);

    foreach (var trackedFace in trackedFaces.Values.ToList())
    {
        bool foundMatch = false;

        for (int i = unmatchedFaces.Count - 1; i >= 0; i--)
        {
            if (IsLikelyMatch(trackedFace.LastLocation, unmatchedFaces[i]))
            {
                // Update existing tracked face
                trackedFace.UpdateLocation(unmatchedFaces[i]);
                matchedIds.Add(trackedFace.Id);
                unmatchedFaces.RemoveAt(i);
                foundMatch = true;
                break;
            }
        }

        // Remove faces that disappeared
        if (!foundMatch)
        {
            trackedFaces.Remove(trackedFace.Id);
        }
    }

    // Add new faces
    foreach (var newFace in unmatchedFaces)
    {
        trackedFaces.Add(nextFaceId, new TrackedFace(nextFaceId, newFace));
        nextFaceId++;
    }
}

private bool IsLikelyMatch(Rectangle previous, Rectangle current)
{
    // Calculate center points
    Point prevCenter = new Point(
        previous.Left + previous.Width / 2,
        previous.Top + previous.Height / 2);

    Point currCenter = new Point(
        current.Left + current.Width / 2,
        current.Top + current.Height / 2);

    // Calculate distance between centers
    double distance = Math.Sqrt(
        Math.Pow(prevCenter.X - currCenter.X, 2) +
        Math.Pow(prevCenter.Y - currCenter.Y, 2));

    // If centers are close enough, consider it the same face
    return distance < Math.Max(previous.Width, current.Width) * 0.5;
}

// Simple class to track face data
private class TrackedFace
{
    public int Id { get; private set; }
    public Rectangle LastLocation { get; private set; }
    public DateTime FirstSeen { get; private set; }
    public DateTime LastSeen { get; private set; }

    public TrackedFace(int id, Rectangle location)
    {
        Id = id;
        LastLocation = location;
        FirstSeen = DateTime.Now;
        LastSeen = DateTime.Now;
    }

    public void UpdateLocation(Rectangle newLocation)
    {
        LastLocation = newLocation;
        LastSeen = DateTime.Now;
    }
}
```

## Step 5: Start Video Stream and Face Detection

The final step is to start the video stream and face detection process:

```
// Start video capture asynchronously
await VideoCapture1.StartAsync();
```

If you need to stop the process:

```
// Stop video capture
await VideoCapture1.StopAsync();
```

## Required Dependencies

To ensure your application works correctly, you'll need to include the appropriate redistributable packages:

- Video capture redistributables:
- [x86 version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/)
- [x64 version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)

Install these packages via NuGet:

```
Install-Package VisioForge.DotNet.Core.Redist.VideoCapture.x64
```

Or for x86 projects:

```
Install-Package VisioForge.DotNet.Core.Redist.VideoCapture.x86
```

## Conclusion

Implementing face detection in your .NET applications enhances their capabilities and opens up numerous possibilities for user interaction, security features, and automation. By following this guide, you now have the knowledge to integrate robust face detection into your video capture applications.

For additional resources and more code samples, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Computer Vision - Object and Face Detection in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/computer-vision/
**Description:** Add face detection, object recognition, vehicle counting, and pedestrian tracking to live video with VisioForge Video Capture SDK. C# code examples included.
**Tags:** Video Capture SDK, .NET

# Computer Vision Integration for .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Overview

Our SDK provides powerful built-in computer vision capabilities that enable developers to enhance their applications with intelligent video analysis features. These functionalities allow your software to automatically detect and track various elements in video streams including human faces, general objects, vehicles, and pedestrians in real-time.

## Key Computer Vision Modules

The SDK offers multiple specialized detection modules to address various use cases:

- **PedestrianDetector** - Track and count people moving through video frames
- **ObjectDetector** - Identify and classify common objects within video content
- **FaceDetector** - Locate and analyze human faces, supporting security and UX applications
- **CarCounter** - Monitor and quantify vehicle traffic in transportation scenarios

Each module is optimized for performance and accuracy, allowing for reliable real-time processing even on standard hardware configurations.

## Implementation Resources

Developers can access complete working examples in our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/WinForms/CSharp/Computer%20Vision). These samples demonstrate practical implementation patterns and best practices for integrating computer vision capabilities into .NET applications.

## Advanced Features

- [Face detection](face-detection/) - Learn about facial recognition, landmark detection, and emotion analysis
- Machine learning integration
- Custom detection model support
- Multi-threading optimization techniques

---

For additional code samples and implementation guidance, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Deploy Video Capture App in .NET — NuGet and Redists
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/deployment/
**Description:** Deploy VisioForge Video Capture SDK via NuGet, silent installer, or manual DLL registration. x86/x64 redistributables and cross-platform X-engine setup guide.
**Tags:** Video Capture SDK, .NET, DirectShow, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Encoding, IP Camera, Screen Capture, MP4, WebM, OGG, FLAC, NuGet

# Comprehensive Deployment Guide for Video Capture SDK .Net

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

When deploying the Video Capture SDK .Net to systems without the SDK pre-installed, proper component deployment is essential for functionality. For AnyCPU applications, both x86 and x64 redistributables must be deployed to ensure compatibility across different system architectures.

## Engine Options Overview

### VideoCaptureCoreX Engine (Cross-Platform Compatibility)

For cross-platform deployment scenarios, refer to our comprehensive [deployment guide](../../deployment-x/) which details platform-specific requirements and configuration options.

### VideoCaptureCore Engine (Windows Platform)

The VideoCaptureCore engine is optimized specifically for Windows environments and offers multiple deployment approaches based on your application requirements and target environment constraints.

## Deployment Methods

### NuGet Package Distribution (No Administrator Privileges Required)

The NuGet package approach provides a streamlined deployment method that doesn't require administrator privileges, making it ideal for restricted environments or when deploying to multiple systems without elevated access.

Add the required NuGet packages to your application project, and after building, the necessary redistributable files will be automatically included in your application folder. This method simplifies dependency management while ensuring all required components are available.

#### Essential NuGet Packages

**Core Components (Required):**

- SDK Base Package: [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.Base.x86) | [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.Base.x64)
- Video Capture SDK: [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86) | [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64)

**Feature-Specific Packages:**

- FFMPEG Integration (for file output/network streaming): [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.FFMPEG.x86) | [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.FFMPEG.x64)
- MP4 Output Support: [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MP4.x86) | [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.MP4.x64)
- VLC Source Integration (for file/IP camera sources): [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VLC.x86) | [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VLC.x64)
- WebM Output Format: [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.WebM.x86)
- XIPH Format Support (Ogg, Vorbis, FLAC): [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.XIPH.x86) | [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.XIPH.x64)
- LAV Filters: [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.LAV.x86) | [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.LAV.x64)
- Virtual Camera Support: [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VirtualCamera.x86) | [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VirtualCamera.x64)

> **Note:** When using the Virtual Camera package, additional registration of camera files is required as outlined in the Manual Installation section if you want the virtual camera to be accessible from external applications.

### Silent Installer Deployment (Administrator Privileges Required)

For scenarios where administrator access is available, silent installers provide a streamlined deployment approach that handles component registration automatically.

**Core Components:**

- Base Package (required): [x86](https://files.visioforge.com/redists_net/redist_dotnet_base_x86.exe) | [x64](https://files.visioforge.com/redists_net/redist_dotnet_base_x64.exe)
- .NET Assemblies: Can be installed in the Global Assembly Cache (GAC) or used from a local folder

**Feature-Specific Installers:**

- FFMPEG Integration: [x86](https://files.visioforge.com/redists_net/redist_dotnet_ffmpeg_x86.exe) | [x64](https://files.visioforge.com/redists_net/redist_dotnet_ffmpeg_x64.exe)
- MP4 Output Support: [x86](https://files.visioforge.com/redists_net/redist_dotnet_mp4_x86.exe) | [x64](https://files.visioforge.com/redists_net/redist_dotnet_mp4_x64.exe)
- VLC Source Integration: [x86](https://files.visioforge.com/redists_net/redist_dotnet_vlc_x86.exe) | [x64](https://files.visioforge.com/redists_net/redist_dotnet_vlc_x64.exe)
- Additional Format Support: WebM ([x86](https://files.visioforge.com/redists_net/redist_dotnet_webm_x86.exe)) and XIPH formats ([x86](https://files.visioforge.com/redists_net/redist_dotnet_xiph_x86.exe) | [x64](https://files.visioforge.com/redists_net/redist_dotnet_xiph_x64.exe))
- LAV Filters: [x86](https://files.visioforge.com/redists_net/redist_dotnet_lav_x86.exe) | [x64](https://files.visioforge.com/redists_net/redist_dotnet_lav_x64.exe)

> **Uninstallation Note:** To remove the package, run the installer executable with administrator privileges using the `/x //` parameter.

### Manual Installation Process

For complete control over the deployment process or in environments with specific requirements, manual installation provides the most flexibility:

1. **Runtime Dependencies:** Install or copy the VC++ 2022 (v143) runtime (x86/x64) and OpenMP runtime DLLs. With admin rights, use exe redist or MSM modules; otherwise, copy directly to the application folder.
2. **Core Components:** Copy the `VisioForge_MFP`/`VisioForge_MFPX` DLLs (or x64 versions) from the `Redist\Filters` folder to your application directory.
3. **.NET Assemblies:** Either copy the assemblies to your application folder or install them to the GAC.
4. **DirectShow Filters:** Copy the SDK DirectShow filters to either your application folder or a designated redist folder (configured via the `CustomRedist_Path` property).
5. **Configuration:** Set the `CustomRedist_Enabled` property to `true` in the Window Load event.
6. **Architecture Handling:** For LAV filters (which use identical names for both x64 and x86 versions), use separate redist folders for each architecture.
7. **Path Configuration:** If your application executable resides in a different location, add the filter folder to the system `PATH` environment variable.

#### Core Components

**Basic Features:**

- Base Filters: VisioForge\_BaseFilters.ax / VisioForge\_BaseFilters\_x64.ax
- Video Effects: VisioForge\_Video\_Effects\_Pro.ax / VisioForge\_Video\_Effects\_Pro\_x64.ax
- Audio Processing: VisioForge\_MP3\_Splitter.ax / VisioForge\_MP3\_Splitter\_x64.ax, VisioForge\_Audio\_Mixer.ax / VisioForge\_Audio\_Mixer\_x64.ax

**Legacy Audio Effects:**

- VisioForge\_Audio\_Effects\_4.ax / VisioForge\_Audio\_Effects\_4\_x64.ax

#### Format-Specific Components

**MP3 Output:**

- VisioForge\_LAME.ax / VisioForge\_LAME\_x64.ax

**MP4/M4A Output:**

- Legacy Version: VisioForge\_AAC\_Encoder.ax, VisioForge\_H264\_Encoder\_XP.ax, VisioForge\_MP4\_Muxer.ax with supporting libraries
- Version 10: VisioForge\_AAC\_Encoder\_v10.ax, VisioForge\_H264\_Encoder.ax, VisioForge\_MP4\_Muxer\_v10.ax with supporting libraries
- Version 11/HW Encoding: VisioForge\_MFT.dll, VisioForge\_MF\_Mux.ax (with x64 variants)

**WebM Output:**

- Muxer: VisioForge\_WebM\_Mux.ax / VisioForge\_WebM\_Mux\_x64.ax
- Encoders: VisioForge\_WebM\_Vorbis\_Encoder.ax, VisioForge\_WebM\_VP8\_Encoder.ax
- Audio Enhancement: VisioForge\_Audio\_Enhancer.ax / VisioForge\_Audio\_Enhancer\_x64.ax

**Ogg/FLAC Support:**

- FLAC: VisioForge\_Xiph\_FLAC\_Encoder.ax / VisioForge\_Xiph\_FLAC\_Encoder\_x64.ax
- Ogg Vorbis: VisioForge\_Xiph\_Ogg\_Mux.ax, VisioForge\_Xiph\_Vorbis\_Encoder.ax (with x64 variants)

#### Streaming and Source Components

**RTSP Streaming:**

- VisioForge\_RTSP\_Sink.ax / VisioForge\_RTSP\_Sink\_x64.ax
- MP4 filters (excluding Muxer)

**VLC Source Integration:**

- VisioForge\_VLC\_Source.ax / VisioForge\_VLC\_Source\_x64.ax
- Requires copying all files from Redist\VLC folder, COM registration, and proper environment variable configuration

**FFMPEG Integration:**

- VisioForge\_FFMPEG\_Source.ax / VisioForge\_FFMPEG\_Source\_x64.ax
- Requires all files from Redist\FFMPEG folder and PATH variable updates

**RTSP/RTMP/HTTP Source Support:**

- VisioForge\_RTSP\_Source.ax, VisioForge\_RTSP\_Source\_Live555.ax
- Requires FFMPEG, VLC, or LAV filters

#### Specialized Components

**Screen Capture:**

- VisioForge\_Screen\_Capture\_DD.ax / VisioForge\_Screen\_Capture\_DD\_x64.ax

**Audio Capture:**

- VisioForge\_WhatYouHear\_Source.ax / VisioForge\_WhatYouHear\_Source\_x64.ax

**Virtual Camera:**

- VisioForge\_Virtual\_Camera.ax / VisioForge\_Virtual\_Camera\_x64.ax
- VisioForge\_Virtual\_Audio\_Card.ax / VisioForge\_Virtual\_Audio\_Card\_x64.ax

**Video Processing:**

- Push Source: VisioForge\_Push\_Video\_Source.ax / VisioForge\_Push\_Video\_Source\_x64.ax
- Network Streaming: VisioForge\_Network\_Streamer\_Audio.ax, VisioForge\_Network\_Streamer\_Video.ax
- Video Encryption: Multiple components including Decryptors, Encoders, and supporting libraries
- Picture-In-Picture: VisioForge\_Video\_Mixer.ax / VisioForge\_Video\_Mixer\_x64.ax

#### Filter Registration

For COM registration of all DirectShow filters in a specific folder, you can deploy the `reg_special.exe` utility from the SDK to the filters directory and run it with administrator privileges to automate the registration process.

---END OF PAGE---


## Video Capture Guides - Multi-Camera and Recording in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/guides/
**Description:** Step-by-step guides for VisioForge Video Capture SDK — multi-camera sync, webcam photos, pre-event recording, and screen capture with C# code samples.
**Tags:** Video Capture SDK, .NET, DirectShow, Windows, Capture
**API:** VideoCaptureCore

# Advanced Video Capture SDK .Net Guides & Tutorials

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Overview

Explore advanced implementation techniques, specialized usage guides, and tutorials for the Video Capture SDK .Net. These resources address specific development scenarios that require custom approaches, including synchronizing multiple capture objects, webcam integration, DirectShow capture techniques, and more.

## Available Guides

This curated collection of guides addresses specific advanced functionalities within the Video Capture SDK .Net. Each guide provides practical instructions and insights to help you implement complex features effectively.

### Getting Started Guides

- [**Save Webcam Video in C#**](save-webcam-video/) - Complete guide to capture and record webcam video to MP4 or WebM using C#, with GPU-accelerated encoding, snapshot capture, and cross-platform deployment.
- [**Record Webcam Video in VB.NET**](record-webcam-vb-net/) - Complete VB.NET guide for recording webcam video to MP4 files, including device enumeration, format selection, screenshot capture, and output configuration with full Visual Basic code examples.
- [**Screen Capture in VB.NET**](screen-capture-vb-net/) - Complete VB.NET guide for recording desktop screen to MP4, including full screen and region capture, multi-monitor support, system audio and loopback recording, with full Visual Basic code examples.

### Synchronization Techniques

- [**Synchronizing Multiple Capture Objects**](start-in-sync/) - In many professional video applications, such as multi-camera event coverage, advanced surveillance systems, or immersive 360-degree video recording, the ability to precisely synchronize multiple video capture instances is paramount. This guide delves into the methodologies for initializing and coordinating several `VideoCaptureCore` objects, ensuring that they start, stop, and record in unison. It addresses potential challenges like timestamp alignment and resource management, offering solutions to achieve seamless and synchronized multi-source capture. Implementing robust synchronization is key to producing professional-grade video content where timing and coherence across different angles or sources are critical.

### Camera Integration & Capture Techniques

Explore specialized guides on integrating various camera functionalities and mastering different capture technologies.

- [**Web Camera Photo Capture Implementation**](make-photo-using-webcam/) - Beyond continuous video recording, the ability to capture high-quality still images using webcams is a frequent requirement in diverse applications. This step-by-step guide details how to implement robust photo capture functionality. It covers device selection, resolution configuration, image format choices (like JPEG, PNG, BMP), and saving the captured frames. Common use cases include integrating profile picture capture in user registration forms, developing simple document scanning utilities, or adding snapshot capabilities to security and monitoring applications. The guide simplifies the process, enabling developers to quickly add valuable still image capture features.
- [**Pre-Event Recording**](pre-event-recording/) - Implement circular buffer recording that continuously captures video and writes event clips to disk on trigger, including footage from before the event occurred.

## Additional Resources

Beyond the specific guides listed above, we offer a wealth of supplementary materials to support your development journey with the Video Capture SDK .Net.

### Code Samples

Our extensive [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) is a treasure trove of practical implementation examples. These samples are not just snippets but often complete mini-applications demonstrating various SDK capabilities across different .NET frameworks like WPF, WinForms, and console applications.

### Technical Support

If you encounter challenges during implementation, our technical documentation provides detailed solutions for common development questions.

---END OF PAGE---


## Webcam Photo Capture in C# .NET — Still Frame Grabber API
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/guides/make-photo-using-webcam/
**Description:** Take photos from a webcam in C# / .NET. Still frame capture via hardware button or software trigger. Save to JPEG, PNG, BMP. Code sample included.
**Tags:** Video Capture SDK, .NET, VideoCaptureCore, Windows, Capture, Webcam, C#
**API:** VideoCaptureCore, VideoFrameBitmapEventArgs, VideoFrameBufferEventArgs

# Capturing Photos Using Webcam in .NET Applications

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Introduction to Webcam Integration

Modern applications increasingly require webcam integration for various purposes, from user profile photos to document scanning. Implementing effective webcam photo capture functionality requires understanding the underlying mechanisms of how webcams work with the .NET framework.

Webcams can capture images through two primary methods: software-triggered captures (where the application initiates the process) and hardware-triggered captures, where a physical button on the webcam device triggers the image capture. The latter method is known as "still frame capture" and provides a more intuitive user experience in many applications.

## Understanding Still Frame Capture

Still frame capture is a specialized function available on many webcam models that allows users to capture high-quality images by pressing a dedicated button on the device. This approach offers several advantages:

- More intuitive user experience
- Reduced application complexity
- Lower chance of camera shake
- Often better image quality than video frame extraction

Not all webcams support still frame capture, so it's important to check your device specifications or test this functionality before relying on it in your application.

## Implementing Webcam Photo Capture in .NET

The Video Capture SDK for .NET provides a robust framework for implementing webcam photo capture in your applications. Below, we'll cover the essential steps to integrate this functionality.

### Setting Up Your Project

Before diving into the implementation details, ensure your development environment is properly configured:

1. Create a new .NET application project
2. Add the Video Capture SDK reference to your project
3. Import the necessary namespaces:

```
using System.Drawing;
using System.Drawing.Imaging;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.VideoCapture;
using VisioForge.Core.VideoCapture;
```

### Enabling Still Frame Capture

The first step in implementing still frame capture is to properly configure your application to detect and respond to the webcam's hardware button presses. Here's how:

```
// Initialize the video capture component. Pass an IVideoView for preview,
// or use the parameterless CreateAsync() overload for headless operation.
var videoCapture = await VideoCaptureCore.CreateAsync(VideoView1);

// Enable still frame capture before starting the video stream.
videoCapture.Video_Still_Frames_Grabber_Enabled = true;

// Select a capture device by name. Enumerate devices via videoCapture.Video_CaptureDevices().
videoCapture.Video_CaptureDevice = new VideoCaptureSource("USB Camera");
videoCapture.Video_CaptureDevice.Format_UseBest = true;     // or set Format + FrameRate explicitly
videoCapture.Audio_RecordAudio = false;
videoCapture.Audio_PlayAudio = false;

// Preview-only mode (no file capture).
videoCapture.Mode = VideoCaptureMode.VideoPreview;

// Start the pipeline (async — OnError fires on pipeline errors).
await videoCapture.StartAsync();
```

Setting the `Video_Still_Frames_Grabber_Enabled` property to `true` is crucial. This configuration tells the SDK to monitor for hardware button presses and trigger the appropriate events when a still frame is captured.

### Handling Captured Frames

Once still frame capture is enabled, you need to handle the events that are triggered when a frame is captured. The SDK provides two main events for this purpose:

```
// For handling frames as Bitmap objects
videoCapture.OnStillVideoFrameBitmap += VideoCapture_OnStillVideoFrameBitmap;

// For handling frames as raw buffer data
videoCapture.OnStillVideoFrameBuffer += VideoCapture_OnStillVideoFrameBuffer;
```

Here's an example of how to implement the event handler for bitmap frames (the event is `EventHandler<VideoFrameBitmapEventArgs>`; the bitmap lives on `e.Frame`):

```
private void VideoCapture_OnStillVideoFrameBitmap(object sender, VideoFrameBitmapEventArgs e)
{
    // Clone the bitmap because e.Frame is owned by the SDK and reused after this callback returns.
    Bitmap capturedImage = (Bitmap)e.Frame.Clone();

    // Marshal to the UI thread when running in WinForms / WPF.
    if (pictureBox1.InvokeRequired)
    {
        pictureBox1.BeginInvoke((Action)(() =>
        {
            pictureBox1.Image?.Dispose();
            pictureBox1.Image = capturedImage;
        }));
    }
    else
    {
        pictureBox1.Image?.Dispose();
        pictureBox1.Image = capturedImage;
    }
}
```

For raw buffer access (no Bitmap allocation, useful for custom image pipelines), subscribe to `OnStillVideoFrameBuffer`. Its signature is `EventHandler<VideoFrameBufferEventArgs>`:

```
private void VideoCapture_OnStillVideoFrameBuffer(object sender, VideoFrameBufferEventArgs e)
{
    // Raw frame metadata: width / height / stride / pixel format.
    var width  = e.Frame.Info.Width;
    var height = e.Frame.Info.Height;

    // e.FrameArray is a managed byte[] copy (may be null if the SDK kept data in native memory).
    if (e.FrameArray != null)
    {
        File.WriteAllBytes($"frame-{e.Frame.Timestamp.Ticks}.raw", e.FrameArray);
    }

    // Mark UpdateData = true if you mutated the buffer and want the change to propagate downstream.
    // e.UpdateData = true;
}
```

### Saving Captured Images

After capturing and potentially processing the image, you'll often want to save it to disk. The SDK provides a convenient method for this purpose:

```
// Save the current frame to a file (async API — works after StartAsync).
await videoCapture.Frame_SaveAsync("capturedImage.jpg", ImageFormat.Jpeg);
```

You can specify different image formats based on your application's requirements, such as PNG for lossless quality or JPEG for smaller file sizes.

### Getting the Current Frame

In some scenarios, you might want to programmatically capture an image without relying on the hardware button. You can do this using the `Frame_GetCurrent` method:

```
// Get the current frame as a Bitmap
Bitmap currentFrame = videoCapture.Frame_GetCurrent();

// Process or save the frame
if (currentFrame != null)
{
    // Use the image
    pictureBox1.Image = currentFrame;

    // Save if needed
    currentFrame.Save("manualCapture.png", ImageFormat.Png);
}
```

## Performance Considerations

Webcam applications can be resource-intensive, especially when processing high-resolution images. Consider these optimization techniques:

1. Use background processing for image saving operations
2. Implement frame rate limiting if continuous monitoring is necessary
3. Scale down resolution for preview while maintaining high resolution for captures
4. Release resources properly when the application closes:

```
protected override void OnFormClosing(FormClosingEventArgs e)
{
    // Stop capture and release resources
    videoCapture.Stop();
    videoCapture.Dispose();
    base.OnFormClosing(e);
}
```

## Troubleshooting Common Issues

- **Camera Not Detected**: Ensure the webcam is properly connected and drivers are installed
- **Still Frame Capture Not Working**: Verify that your webcam model supports hardware button capture
- **Poor Image Quality**: Check resolution settings and ensure proper lighting conditions
- **Application Crashes**: Implement proper error handling and resource management

## Conclusion

Implementing webcam photo capture in .NET applications provides valuable functionality for many scenarios. By following the guidelines in this article, you can create robust, user-friendly applications that effectively leverage webcam capabilities.

Remember to test your implementation across different webcam models and configurations to ensure consistent performance and reliability.

---

For more code samples and implementation examples, visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) repository.

---END OF PAGE---


## Pre-Event Recording with Circular Buffer in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/guides/pre-event-recording/
**Description:** Buffer and save video before motion triggers using VisioForge Video Capture SDK. Circular buffer for webcam, IP camera, and RTSP streams with C# examples.
**Tags:** Video Capture SDK, .NET, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Streaming, Encoding, Webcam, IP Camera, RTSP, MP4, MKV, TS, H.264, H.265, AAC, C#, NuGet
**API:** VideoCaptureCoreX, PreEventRecordingOutput, PreEventRecordingSettings, DeviceEnumerator, RTSPSourceSettings

# Pre-Event Recording Using C# .Net: Circular Buffer Video Capture

Pre-event recording allows your application to continuously buffer video and audio in memory and save event clips that include footage from before the trigger occurred. Use it to record webcam video, capture IP camera streams, or save RTSP footage with motion detection triggers — essential for surveillance, security, and monitoring applications where capturing what happened before an event is critical.

## Key Features of Video Capture SDK .Net Pre-Event Recording

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

- **Configurable buffer duration**: Buffer the last 5 to 120+ seconds of video in memory
- **Automatic post-event recording**: Continue recording for a configurable duration after the trigger
- **Multiple output formats**: MP4 (default), MPEG-TS (crash-safe), MKV
- **Extend on re-trigger**: If an event recurs during recording, the timer resets without creating a new file
- **Multiple independent outputs**: Add multiple pre-event recording outputs per pipeline
- **GPU-accelerated encoding**: Leverages NVENC, QSV, and AMF hardware encoders when available
- **Event notifications**: Receive callbacks when recording starts and stops

## How Pre-Event Recording Works

```
graph LR;
    A[Camera Source] --> B[VideoCaptureCoreX];
    B --> C[Preview Window];
    B --> D[Pre-Event Buffer in Memory];
    D -- "Trigger Event" --> E[Event Clip File];
```

1. `VideoCaptureCoreX` captures video from a camera (webcam, IP camera, etc.) and displays a preview
2. Encoded frames are continuously stored in a circular buffer in memory
3. When you call `TriggerPreEventRecording()`, the buffer is flushed to a file
4. Live frames continue recording for the configured post-event duration
5. Recording stops automatically and the system returns to buffering mode

## Implementation Example

Info

For a complete working project with XAML and all dependencies, see the [Pre-Event Recording VideoCaptureCoreX Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WPF/CSharp/PreEventRecording).

### WPF Application with Camera, Motion Detection, and Pre-Event Recording

The following code is based on the [Pre-Event Recording WPF demo](https://github.com/visioforge/.Net-SDK-s-samples). It supports both local camera and RTSP IP camera sources, with motion detection for automatic recording triggers.

```
using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Windows;

using VisioForge.Core;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.VideoProcessing;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.PreEventRecording;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.VideoEncoders;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.VideoCaptureX;

public partial class MainWindow : Window, IDisposable
{
    private VideoCaptureCoreX VideoCapture1;
    private string _outputFolder;
    private System.Timers.Timer _statusTimer;

    private async void BtStart_Click(object sender, RoutedEventArgs e)
    {
        _outputFolder = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.MyVideos),
            "PreEventRecording");
        Directory.CreateDirectory(_outputFolder);

        // Create VideoCaptureCoreX with video preview
        VideoCapture1 = new VideoCaptureCoreX(VideoView1);
        VideoCapture1.OnError += (s, args) => Log($"[Error] {args.Message}");

        // Configure video source — camera or RTSP
        bool useRtsp = false; // Set to true for RTSP IP camera
        if (useRtsp)
        {
            var rtspSettings = await RTSPSourceSettings.CreateAsync(
                new Uri("rtsp://192.168.1.21:554/Streaming/Channels/101"),
                login: "admin",
                password: "password",
                audioEnabled: true);
            VideoCapture1.Video_Source = rtspSettings;
            VideoCapture1.Audio_Record = true;
        }
        else
        {
            // Local camera
            var device = (await DeviceEnumerator.Shared.VideoSourcesAsync()).FirstOrDefault();
            VideoCapture1.Video_Source = new VideoCaptureDeviceSourceSettings(device);

            // Local audio device
            var audioDevice = (await DeviceEnumerator.Shared.AudioSourcesAsync()).FirstOrDefault();
            if (audioDevice != null)
            {
                VideoCapture1.Audio_Source = audioDevice.CreateSourceSettingsVC(null);
                VideoCapture1.Audio_Record = true;
            }
        }

        // Enable motion detection for automatic triggering
        VideoCapture1.Motion_Detection = new MotionDetectionExSettings
        {
            ProcessorType = MotionProcessorType.None,
            DetectorType = MotionDetectorType.TwoFramesDifference,
            DifferenceThreshold = 15,
            SuppressNoise = true
        };
        VideoCapture1.OnMotionDetection += VideoCapture1_OnMotionDetection;

        // Add pre-event recording output with explicit encoders
        var preEventSettings = new PreEventRecordingSettings
        {
            PreEventDuration = TimeSpan.FromSeconds(10),
            PostEventDuration = TimeSpan.FromSeconds(5)
        };

        var preEventOutput = new PreEventRecordingOutput(
            settings: preEventSettings,
            videoEnc: new OpenH264EncoderSettings(),
            audioEnc: new VOAACEncoderSettings());
        VideoCapture1.Outputs_Add(preEventOutput);

        // Subscribe to recording events
        VideoCapture1.OnPreEventRecordingStarted += (s, args) =>
        {
            Log($"Recording started: {args.Filename}");
            Dispatcher.Invoke(() => lbRecFile.Text = $"File: {args.Filename}");
        };

        VideoCapture1.OnPreEventRecordingStopped += (s, args) =>
        {
            Log($"Recording stopped: {args.Filename}");
        };

        // Start capture — preview and buffering begin
        await VideoCapture1.StartAsync();

        // Start status timer
        _statusTimer = new System.Timers.Timer(500);
        _statusTimer.Elapsed += (s, args) => UpdateStatus();
        _statusTimer.Start();

        Log("Started. Buffering...");
    }

    // Motion detection handler: auto-trigger recording on motion
    private void VideoCapture1_OnMotionDetection(object sender, MotionDetectionExEventArgs e)
    {
        if (VideoCapture1 == null) return;

        bool isMotion = e.LevelPercent >= 5;
        if (!isMotion) return;

        var state = VideoCapture1.GetPreEventRecordingState(0);
        if (state == PreEventRecordingState.Buffering)
        {
            var filename = Path.Combine(_outputFolder,
                $"motion_{DateTime.Now:yyyyMMdd_HHmmss}.mp4");
            VideoCapture1.TriggerPreEventRecording(0, filename);
            Log($"Motion triggered recording: {filename}");
        }
        else if (state == PreEventRecordingState.Recording ||
                 state == PreEventRecordingState.PostEventRecording)
        {
            // Motion still active — extend the recording
            VideoCapture1.ExtendPreEventRecording(0);
        }
    }

    // Manual trigger button
    private void BtTrigger_Click(object sender, RoutedEventArgs e)
    {
        if (VideoCapture1 == null) return;

        var filename = Path.Combine(_outputFolder,
            $"event_{DateTime.Now:yyyyMMdd_HHmmss}.mp4");
        VideoCapture1.TriggerPreEventRecording(0, filename);
        Log($"Trigger recording: {filename}");
    }

    // Manual stop recording button
    private void BtStopRec_Click(object sender, RoutedEventArgs e)
    {
        VideoCapture1?.StopPreEventRecording(0);
        Log("Recording stopped manually.");
    }

    // Extend recording button
    private void BtExtend_Click(object sender, RoutedEventArgs e)
    {
        VideoCapture1?.ExtendPreEventRecording(0);
        Log("Post-event timer extended.");
    }

    // Monitor status periodically
    private void UpdateStatus()
    {
        if (VideoCapture1 == null) return;

        var state = VideoCapture1.GetPreEventRecordingState(0);
        Dispatcher.Invoke(() => lbState.Text = $"State: {state}");
    }

    // Stop and clean up
    private async void BtStop_Click(object sender, RoutedEventArgs e)
    {
        _statusTimer?.Stop();
        _statusTimer?.Dispose();

        if (VideoCapture1 != null)
        {
            VideoCapture1.OnMotionDetection -= VideoCapture1_OnMotionDetection;
            await VideoCapture1.StopAsync();
            await VideoCapture1.DisposeAsync();
            VideoCapture1 = null;
        }

        Log("Stopped.");
    }

    private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
    {
        _statusTimer?.Stop();
        _statusTimer?.Dispose();

        VideoCapture1?.DisposeAsync().GetAwaiter().GetResult();
        VisioForgeX.DestroySDK();
    }
}
```

## MPEG-TS Output for Crash Safety

For unattended or headless deployments, use MPEG-TS output to ensure recordings are always playable even if the process crashes:

```
// Use the factory method for MPEG-TS output
var preEventOutput = PreEventRecordingOutput.CreateMPEGTS(
    settings: new PreEventRecordingSettings
    {
        PreEventDuration = TimeSpan.FromSeconds(30),
        PostEventDuration = TimeSpan.FromSeconds(10)
    });
core.Outputs_Add(preEventOutput);

// Trigger with .ts extension
core.TriggerPreEventRecording(0, "/recordings/event_001.ts");
```

MP4 vs MPEG-TS

MP4 files require a finalization step (writing the moov atom). If the process crashes during recording, the MP4 file may be unplayable. MPEG-TS does not have this requirement and is always playable, making it the recommended format for surveillance applications running unattended.

## MKV Output

```
var preEventOutput = PreEventRecordingOutput.CreateMKV(
    settings: new PreEventRecordingSettings
    {
        PreEventDuration = TimeSpan.FromSeconds(30),
        PostEventDuration = TimeSpan.FromSeconds(10)
    });
core.Outputs_Add(preEventOutput);

core.TriggerPreEventRecording(0, "/recordings/event_001.mkv");
```

## API Reference

### PreEventRecordingOutput

| Constructor / Factory | Description |
| --- | --- |
| `new PreEventRecordingOutput(filename, settings, videoEnc, audioEnc)` | MP4 output with default or custom encoders. All args optional; use named args to skip `filename`. |
| `PreEventRecordingOutput.CreateMPEGTS(filename, settings, videoEnc, audioEnc)` | MPEG-TS output (crash-safe). All args optional. |
| `PreEventRecordingOutput.CreateMKV(filename, settings, videoEnc, audioEnc)` | MKV output. All args optional. |

### VideoCaptureCoreX Methods

| Method | Description |
| --- | --- |
| `TriggerPreEventRecording(int index, string filename)` | Flush buffer to file and start recording. `index` is the zero-based pre-event output index. |
| `TriggerPreEventRecordingAsync(int index, string filename)` | Async version of TriggerPreEventRecording. |
| `ExtendPreEventRecording(int index)` | Reset the post-event timer. Call when the trigger condition persists. |
| `StopPreEventRecording(int index)` | Manually stop recording and return to buffering. |
| `IsPreEventRecording(int index)` | Returns `true` if the output is currently recording. |
| `GetPreEventRecordingState(int index)` | Returns the current `PreEventRecordingState`. |

### VideoCaptureCoreX Properties

| Property | Type | Description |
| --- | --- | --- |
| `PreEventRecording_Count` | int | Number of configured pre-event recording outputs. |

### VideoCaptureCoreX Events

| Event | Description |
| --- | --- |
| `OnPreEventRecordingStarted` | Fired when a pre-event recording begins. Includes filename and actual pre-event duration. |
| `OnPreEventRecordingStopped` | Fired when a recording finishes (timer expired or manual stop). |

### Available Encoders

**Video encoders:**

- OpenH264 (software, cross-platform)
- Intel QSV H264 (hardware)
- NVIDIA NVENC H264 (hardware)
- AMD AMF H264 (hardware)
- Intel QSV HEVC (hardware)
- NVIDIA NVENC HEVC (hardware)
- AMD AMF H265 (hardware)

**Audio encoders:**

- MP3
- VO-AAC
- AVENC AAC
- MF AAC (Windows only)

## Native Dependencies

Major SDK package (managed):

```
<PackageReference Include="VisioForge.DotNet.VideoCapture" Version="2026.8.16" />
```

Native dependencies for Windows x64:

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
```

For alternative platforms (macOS, Linux, Android, iOS), use the corresponding native dependency packages. See the [Deployment Guide](../../../deployment-x/) for details.

## Cross-Platform Compatibility

Pre-event recording is available on all platforms supported by Video Capture SDK .Net:

- Windows (x86, x64, ARM64)
- macOS (x64, ARM64)
- Linux (x64, ARM64)
- Android
- iOS

Platform availability depends on GStreamer muxer and encoder support. Hardware-accelerated encoders (NVENC, QSV, AMF) are available on platforms with compatible GPU hardware.

---END OF PAGE---


## Record Webcam Video in VB.NET - Capture & Save Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/guides/record-webcam-vb-net/
**Description:** Learn to record webcam video in VB.NET with device enumeration, MP4 output, live preview, and screenshot capture using async/await.
**Tags:** Video Capture SDK, .NET, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, Capture, Webcam, Screen Capture, MP4, WebM, AVI, C#, VB.NET, NuGet
**API:** VideoView

# Record Webcam Video in VB.NET: Complete Guide

Recording webcam video in VB.NET applications is a common requirement for video conferencing, surveillance, and media projects. This guide provides step-by-step instructions to capture, preview, and save webcam video to MP4 files using [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) in VB.NET (Visual Basic .NET).

## Why Use Video Capture SDK .Net for VB.NET Webcam Recording

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) provides first-class VB.NET support with:

- Full async/await support for non-blocking webcam capture
- Device enumeration for video sources, audio sources, and audio outputs
- MP4 recording with H.264/H.265 encoding and GPU acceleration
- Real-time webcam preview during recording
- Screenshot capture from live webcam feed
- WinForms and WPF support

## Required NuGet Packages

Add the following packages to your VB.NET project:

```
<PackageReference Include="VisioForge.DotNet.VideoCapture" Version="2026.2.19" />
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />
```

## Complete VB.NET Webcam Recording Example

The following example demonstrates a full WinForms application that enumerates webcam devices, previews the webcam feed, and records video to MP4.

### SDK Initialization and Device Enumeration

First, initialize the SDK and enumerate available devices when the form loads:

```
Imports System.IO
Imports VisioForge.Core
Imports VisioForge.Core.VideoCaptureX
Imports VisioForge.Core.Types.X.Sources
Imports VisioForge.Core.Types.X.Output
Imports VisioForge.Core.Types.X.AudioRenderers

Public Class Form1
    Private VideoCapture1 As VideoCaptureCoreX

    Private Async Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        ' Initialize the SDK
        Await VisioForgeX.InitSDKAsync()

        ' Create the video capture engine
        VideoCapture1 = New VideoCaptureCoreX(VideoView1)
        AddHandler VideoCapture1.OnError, AddressOf VideoCapture1_OnError

        ' Enumerate video sources (webcams)
        Dim videoSources = Await DeviceEnumerator.Shared.VideoSourcesAsync()
        For Each source In videoSources
            cbVideoInputDevice.Items.Add(source.DisplayName)
            If cbVideoInputDevice.Items.Count = 1 Then cbVideoInputDevice.SelectedIndex = 0
        Next

        ' Enumerate audio sources (microphones)
        Dim audioSources = Await DeviceEnumerator.Shared.AudioSourcesAsync()
        For Each source In audioSources
            cbAudioInputDevice.Items.Add(source.DisplayName)
            If cbAudioInputDevice.Items.Count = 1 Then cbAudioInputDevice.SelectedIndex = 0
        Next

        ' Enumerate audio outputs (speakers)
        Dim audioOutputs = Await DeviceEnumerator.Shared.AudioOutputsAsync()
        For Each audioOutput In audioOutputs
            cbAudioOutputDevice.Items.Add(audioOutput.DisplayName)
            If cbAudioOutputDevice.Items.Count = 1 Then cbAudioOutputDevice.SelectedIndex = 0
        Next

        edOutput.Text = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.MyVideos), "capture.mp4")
    End Sub
```

### Listing Available Video Formats and Frame Rates

When the user selects a webcam device, populate the available video formats:

```
    Private Async Sub cbVideoInputDevice_SelectedIndexChanged(
            sender As Object, e As EventArgs) Handles cbVideoInputDevice.SelectedIndexChanged

        If cbVideoInputDevice.SelectedIndex = -1 Then Return

        cbVideoInputFormat.Items.Clear()
        cbVideoInputFrameRate.Items.Clear()

        Dim videoSources = Await DeviceEnumerator.Shared.VideoSourcesAsync()
        Dim device = videoSources.FirstOrDefault(
            Function(d) d.DisplayName = cbVideoInputDevice.Text)

        If device IsNot Nothing Then
            For Each videoFormat In device.VideoFormats
                cbVideoInputFormat.Items.Add(videoFormat.Name)
            Next
            If cbVideoInputFormat.Items.Count > 0 Then cbVideoInputFormat.SelectedIndex = 0
        End If
    End Sub
```

### Starting Webcam Recording to MP4

Configure the video and audio sources, set the MP4 output, and start the recording:

```
    Private Async Sub btStart_Click(sender As Object, e As EventArgs) Handles btStart.Click
        Try
            ' Configure video source
            Dim videoSources = Await DeviceEnumerator.Shared.VideoSourcesAsync()
            Dim videoDevice = videoSources.FirstOrDefault(
                Function(d) d.DisplayName = cbVideoInputDevice.Text)

            If videoDevice IsNot Nothing Then
                Dim videoSourceSettings As New VideoCaptureDeviceSourceSettings(videoDevice)
                VideoCapture1.Video_Source = videoSourceSettings
            End If

            ' Configure audio source
            Dim audioSources = Await DeviceEnumerator.Shared.AudioSourcesAsync()
            Dim audioDevice = audioSources.FirstOrDefault(
                Function(d) d.DisplayName = cbAudioInputDevice.Text)

            If audioDevice IsNot Nothing Then
                VideoCapture1.Audio_Source = audioDevice.CreateSourceSettingsVC(Nothing)
            End If

            ' Configure audio output for live monitoring
            Dim audioOutputs = Await DeviceEnumerator.Shared.AudioOutputsAsync()
            Dim audioOutput = audioOutputs.FirstOrDefault(
                Function(d) d.DisplayName = cbAudioOutputDevice.Text)

            If audioOutput IsNot Nothing Then
                VideoCapture1.Audio_OutputDevice = New AudioRendererSettings(audioOutput)
            End If

            VideoCapture1.Audio_Play = True
            VideoCapture1.Audio_Record = True
            VideoCapture1.Video_Play = True

            ' Configure MP4 output
            VideoCapture1.Outputs_Clear()
            VideoCapture1.Outputs_Add(New MP4Output(edOutput.Text), True)

            ' Start recording
            Await VideoCapture1.StartAsync()
        Catch ex As Exception
            MessageBox.Show(Me, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
        End Try
    End Sub
```

### Stopping Webcam Recording

Stop the recording and release resources:

```
    Private Async Sub btStop_Click(sender As Object, e As EventArgs) Handles btStop.Click
        Try
            Await VideoCapture1.StopAsync()
        Catch ex As Exception
            MessageBox.Show(Me, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
        End Try
    End Sub
```

### Saving Screenshots from Webcam

Capture still images from the live webcam feed:

```
    Private Async Sub btSaveScreenshot_Click(sender As Object, e As EventArgs) Handles btSaveScreenshot.Click
        Dim saveDialog As New SaveFileDialog With {
            .Filter = "JPEG|*.jpg|PNG|*.png|BMP|*.bmp",
            .FileName = "snapshot.jpg"
        }

        If saveDialog.ShowDialog() = DialogResult.OK Then
            Dim format As SKEncodedImageFormat = SKEncodedImageFormat.Jpeg
            If saveDialog.FileName.EndsWith(".png", StringComparison.OrdinalIgnoreCase) Then
                format = SKEncodedImageFormat.Png
            End If

            Await VideoCapture1.Snapshot_SaveAsync(saveDialog.FileName, format)
        End If
    End Sub
```

### Cleanup on Form Close

Properly dispose of resources when the application exits:

```
    Private Async Sub Form1_FormClosing(
            sender As Object, e As FormClosingEventArgs) Handles MyBase.FormClosing

        If VideoCapture1 IsNot Nothing Then
            Await VideoCapture1.DisposeAsync()
            VideoCapture1 = Nothing
        End If

        VisioForgeX.DestroySDK()
    End Sub

    Private Sub VideoCapture1_OnError(sender As Object, e As ErrorsEventArgs)
        If Me.InvokeRequired Then
            Me.Invoke(Sub() mmLog.Text &= e.Message & Environment.NewLine)
        Else
            mmLog.Text &= e.Message & Environment.NewLine
        End If
    End Sub
End Class
```

## Preview-Only Mode (No Recording)

To preview the webcam feed without recording, simply skip adding the MP4 output:

```
' No output added - preview only
VideoCapture1.Video_Play = True
VideoCapture1.Audio_Play = True

Await VideoCapture1.StartAsync()
```

## Output Format Options

While this guide focuses on MP4 recording, you can save webcam video in other formats:

### WebM Output

```
VideoCapture1.Outputs_Add(New WebMOutput(edOutput.Text), True)
```

### AVI Output

```
VideoCapture1.Outputs_Add(New AVIOutput(edOutput.Text), True)
```

For detailed format configuration, see the [MP4 format documentation](../../../general/output-formats/mp4/) and [WebM format documentation](../../../general/output-formats/webm/).

## Sample Applications

Complete VB.NET sample applications are available:

- [Simple Video Capture VB.NET (WinForms)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WinForms/VB/Simple%20Video%20Capture%20X%20VB) — full-featured webcam capture application

## Frequently Asked Questions

### How do I convert C# webcam capture examples to VB.NET?

The Video Capture SDK .Net API is identical in C# and VB.NET — only the language syntax differs. Key conversions: replace `+=` event handlers with `AddHandler`/`AddressOf`, replace C# lambdas `(x) =>` with `Function(x)` or `Sub(x)`, and use `Async Sub` instead of `async void`. All classes, methods, and properties shown in C# documentation work directly in VB.NET with these syntax adjustments.

### Does VB.NET support async webcam recording with Await?

Yes. VB.NET fully supports `Async`/`Await` for all SDK operations including `StartAsync()`, `StopAsync()`, and `Snapshot_SaveAsync()`. Mark event handlers as `Async Sub` and use `Await` before each SDK call to keep the UI thread responsive during webcam recording. The VB.NET async pattern is functionally identical to C# `async`/`await`.

### Which VB.NET project types support webcam video capture?

The SDK supports VB.NET WinForms and WPF applications on .NET 8+ and .NET Framework 4.7.2+. WinForms is the most common choice for VB.NET webcam projects because it provides the `VideoView` control via the visual designer. For WPF, add the `VideoView` control in XAML. Console applications can record without preview by omitting the `VideoView` parameter.

### How do I handle webcam errors and device disconnection in VB.NET?

Subscribe to the `OnError` event using `AddHandler VideoCapture1.OnError, AddressOf VideoCapture1_OnError`. Inside the handler, use `Me.InvokeRequired` and `Me.Invoke()` to safely update the UI from a background thread. Wrap `StartAsync()` and `StopAsync()` calls in `Try`/`Catch` blocks to handle device disconnection or permission errors gracefully.

## See Also

- [Save Webcam Video in C#](../save-webcam-video/) — same functionality with C# code examples
- [Screen Capture in VB.NET](../screen-capture-vb-net/) — record desktop screen instead of webcam in Visual Basic
- [Build a Video Player in VB.NET](../../../mediaplayer/guides/video-player-vb-net/) — VB.NET media player with playback controls
- [Webcam to MP4 Tutorial](../../video-tutorials/video-capture-webcam-mp4/) — step-by-step C# webcam recording walkthrough
- [Web Camera Photo Capture](../make-photo-using-webcam/) — capture still images from webcam instead of video
- [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) — product page and downloads

---END OF PAGE---


## Save Webcam Video in C# .NET — Record and Capture Guide
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/guides/save-webcam-video/
**Description:** Save webcam video to MP4 and WebM in C# with VisioForge Video Capture SDK. GPU-accelerated encoding, device enumeration, and cross-platform support.
**Tags:** Video Capture SDK, .NET, VideoCaptureCoreX, Windows, WinForms, Capture, Encoding, Webcam, IP Camera, Screen Capture, MP4, WebM, H.264, H.265, VP8, VP9, AV1, C#, NuGet
**API:** VideoCaptureCoreX, DeviceEnumerator, VideoCaptureDeviceSourceSettings, MP4Output, WebMOutput

# Save Webcam Video Using .Net: A Complete Guide to Record and Capture Webcam

Capturing and saving video from webcams is a common requirement in many modern applications, from video conferencing tools to surveillance systems. Whether you need to record webcam footage, display the webcam feed, or capture images, implementing reliable webcam functionality in .NET (DotNet) can be challenging. This tutorial provides a simple step-by-step guide to save webcam video using C# (C Sharp) with minimal code.

## Key Features of Video Capture SDK .Net

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) is a powerful library designed specifically for .NET developers who need to implement webcam capture functionality in their applications. Whether you want to record webcam video, save webcam frames as images, or display the webcam feed in your application, this SDK has you covered. Some of its standout features include:

- Seamless integration with .NET applications
- Support for multiple capture devices (USB webcams, IP cameras, capture cards)
- High-performance video and audio recording and processing
- Simple code to get and display webcam feeds
- Create and save video files in various formats
- GPU-accelerated encoding for optimal performance
- Cross-platform compatibility

## Output Formats: MP4 and WebM in Detail

### MP4 Format

MP4 is one of the most widely supported video container formats, making it an excellent choice for applications where compatibility is a priority. For detailed configuration options, see the [MP4 format documentation](../../../general/output-formats/mp4/).

Supported codecs for MP4:

- **H.264 (AVC):** The industry standard for video compression, offering excellent quality and wide compatibility. See the [H.264 encoder documentation](../../../general/video-encoders/h264/).
- **H.265 (HEVC):** Next-generation codec providing up to 50% better compression than H.264 while maintaining the same quality. See the [HEVC encoder documentation](../../../general/video-encoders/hevc/).
- **AAC:** Advanced Audio Coding, the industry standard for lossy digital audio compression.

### WebM Format

WebM is an open, royalty-free media file format designed for the web. For detailed configuration options, see the [WebM format documentation](../../../general/output-formats/webm/).

Supported codecs for WebM:

- **VP8:** Open-source video codec developed by Google, primarily used with WebM format.
- **VP9:** Successor to VP8, offering significantly improved compression efficiency.
- **AV1:** Newest open-source video codec with superior compression and quality, particularly at lower bitrates.
- **Vorbis:** Free and open-source audio compression format offering good quality at lower bitrates.

Each codec can be fine-tuned with various parameters to achieve the optimal balance between quality and file size for your specific application requirements.

## GPU Acceleration for Efficient Encoding

One of the standout features of Video Capture SDK .Net is its robust support for GPU-accelerated video encoding, which offers several significant advantages:

### Benefits of GPU Acceleration

- **Dramatically reduced CPU usage:** Free up CPU resources for other application tasks
- **Faster encoding speeds:** Up to 10x faster than CPU-only encoding
- **Real-time high-resolution encoding:** Enable 4K video capture with minimal system impact
- **Lower power consumption:** Particularly important for mobile and laptop applications
- **Higher quality at the same bitrate:** Some GPU encoders offer better quality-per-bit than CPU encoding

### Supported GPU Technologies

Video Capture SDK .Net leverages multiple GPU acceleration technologies:

- **NVIDIA NVENC:** Hardware-accelerated encoding on NVIDIA GPUs
- **AMD AMF/VCE:** Acceleration on AMD graphics cards
- **Intel Quick Sync Video:** Hardware encoding on Intel integrated graphics

The SDK automatically detects available hardware and selects the optimal encoding path based on your system's capabilities, with fallback to software encoding when necessary.

## Implementation Example (C# Code to Capture Video from Webcam)

Let's walk through a simple tutorial on how to record webcam video using C#. Implementing webcam capture with Video Capture SDK .Net is straightforward. Here's a complete example showing how to get your webcam feed, display it in your application, and save it to an MP4 file with H.264 encoding:

```
using System;
using System.IO;
using System.Linq;
using System.Windows.Forms;

using VisioForge.Core;
using VisioForge.Core.VideoCaptureX;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.AudioRenderers;

namespace video_capture_webcam_mp4
{
    public partial class Form1 : Form
    {
        // Core Video Capture object
        private VideoCaptureCoreX videoCapture1;

        public Form1()
        {
            InitializeComponent();
        }

        private async void btStart_Click(object sender, EventArgs e)
        {
            // Create VideoCaptureCoreX instance and set VideoView for video rendering
            videoCapture1 = new VideoCaptureCoreX(VideoView1);

            // Enumerate video and audio sources
            var videoSources = await DeviceEnumerator.Shared.VideoSourcesAsync();
            var audioSources = await DeviceEnumerator.Shared.AudioSourcesAsync();

            // Set default video source
            videoCapture1.Video_Source = new VideoCaptureDeviceSourceSettings(videoSources[0]);

            // Set default audio source
            videoCapture1.Audio_Source = audioSources[0].CreateSourceSettingsVC();

            // Set default audio sink
            var audioRenderers = await DeviceEnumerator.Shared.AudioOutputsAsync();
            videoCapture1.Audio_OutputDevice = new AudioRendererSettings(audioRenderers[0]);
            videoCapture1.Audio_Play = true;

            // Configure MP4 output. Default video and audio encoders will be used.
            // GPU encoders will be used if available.
            var mp4Output = new MP4Output(Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.MyVideos),
                "output.mp4"));
            videoCapture1.Outputs_Add(mp4Output);

            videoCapture1.Audio_Record = true;

            // Start capture
            await videoCapture1.StartAsync();
        }

        private async void Form1_Load(object sender, EventArgs e)
        {
            // We have to initialize the engine on start
            Text += " [FIRST TIME LOAD, BUILDING THE REGISTRY...]";
            this.Enabled = false;
            await VisioForgeX.InitSDKAsync();
            this.Enabled = true;
            Text = Text.Replace("[FIRST TIME LOAD, BUILDING THE REGISTRY...]", "");
        }

        private async void btStop_Click(object sender, EventArgs e)
        {
            // Stop capture
            await videoCapture1.StopAsync();

            // Release resources
            await videoCapture1.DisposeAsync();
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            // Release SDK
            VisioForgeX.DestroySDK();
        }
    }
}
```

## Additional Code Examples

### WebM Output with VP9

For WebM output with VP9 encoding, simply modify the encoder settings:

```
using VisioForge.Core.Types.X.Output;

// Configure WebM output with VP9 codec
var webmOutput = new WebMOutput(Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.MyVideos),
    "output.webm"));
videoCapture1.Outputs_Add(webmOutput);
```

### Enable Snapshot Grabber

Here's a simple example of how to just save a single image from the webcam. Enable video sample grabber:

```
// Enable snapshot grabber before starting capture
videoCapture1.Snapshot_Grabber_Enabled = true;
await videoCapture1.StartAsync();
```

### Save Snapshot

Get and save a single image from the webcam:

```
using SkiaSharp;

// Save current frame as JPEG
await videoCapture1.Snapshot_SaveAsync(
    "snapshot.jpg",
    SKEncodedImageFormat.Jpeg,
    85);

// Or save as PNG
await videoCapture1.Snapshot_SaveAsync(
    "snapshot.png",
    SKEncodedImageFormat.Png);
```

## Native Dependencies

Video Capture SDK .Net relies on native libraries to access webcam devices and perform video and audio processing. These native dependencies are bundled with the SDK and are automatically deployed with your application, ensuring seamless integration and compatibility across different systems.

### Package Reference

Main SDK package:

```
<PackageReference Include="VisioForge.DotNet.VideoCapture" Version="2026.2.19" />
```

### Platform-Specific Redist Packages

Windows x64:

```
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />
```

For other platforms:

```
<!-- macOS -->
<PackageReference Include="VisioForge.CrossPlatform.Core.macOS" Version="2026.8.5" />

<!-- Linux x64 (needs system GStreamer 1.22+) -->
<PackageReference Include="VisioForge.CrossPlatform.Core.Linux.x64" Version="2025.9.0" />
```

## Cross-Platform Compatibility

Video Capture SDK .Net is designed with cross-platform compatibility in mind, making it an ideal choice for developers working on applications that need to run on multiple operating systems.

### MAUI Compatibility

For developers working with .NET MAUI (Multi-platform App UI), Video Capture SDK .Net offers:

- Full compatibility with MAUI applications
- Consistent API across all supported platforms
- Platform-specific optimizations while maintaining a unified codebase
- Sample MAUI projects demonstrating implementation across platforms

This cross-platform capability allows developers to write code once and deploy across Windows, macOS, and mobile platforms through MAUI, significantly reducing development time and maintenance overhead.

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) provides a comprehensive solution for adding webcam video capture capabilities to your DotNet applications. Whether you need to record webcam footage, save webcam images, or simply display the webcam feed in your application, this library makes the process simple with just a few lines of C# code.

With support for industry-standard formats like MP4 and WebM, modern codecs including H.264/H.265 and VP8/VP9/AV1, and powerful GPU acceleration, it offers the performance and flexibility needed for even the most demanding video capture applications. The ability to create and save video files efficiently makes this library perfect for any application that needs to record webcam content.

The SDK's cross-platform compatibility, extending to macOS and MAUI applications, ensures that your webcam capture solution works consistently across different operating systems. Whether you're building a video conferencing tool, a surveillance application, or any other software requiring webcam functionality, Video Capture SDK .Net offers the tools you need to implement these features quickly.

Getting started is as simple as following the step-by-step tutorial and code examples provided above. For more advanced use cases and detailed documentation on how to record webcam video using .NET, visit our website or refer to the SDK documentation.

## Frequently Asked Questions

### Which format should I use to save webcam video — MP4 or WebM?

MP4 with H.264 encoding is the best choice for most applications because it offers broad device and player compatibility, efficient compression, and hardware-accelerated encoding on most GPUs. Choose WebM with VP9 or AV1 if you need a royalty-free format for web delivery or browser-based playback. Both formats support high-quality audio recording alongside video.

### How do I set the resolution and frame rate for webcam recording?

Use the `VideoCaptureDeviceSourceSettings` class to select a specific resolution and frame rate from your camera's supported formats. After creating the source settings object, call `GetFormats()` to enumerate available modes, then assign your preferred format before starting capture. The SDK automatically negotiates the closest match if the exact format is unavailable.

### Can I use GPU acceleration to record webcam video in C#?

Yes. Video Capture SDK .Net automatically detects available GPU hardware — NVIDIA NVENC, AMD AMF/VCE, and Intel Quick Sync Video — and selects hardware-accelerated encoding when you create an `MP4Output` or `WebMOutput`. No additional configuration is required. If no compatible GPU is found, the SDK falls back to optimized software encoding transparently.

### How do I record webcam video with audio?

Set the `Audio_Source` property to a microphone or other audio input device, then enable recording with `Audio_Record = true`. To monitor audio during capture, set `Audio_Play = true` and assign an `Audio_OutputDevice`. When saving to MP4, audio is encoded as AAC by default; WebM uses Vorbis.

### Does webcam recording work on macOS and Linux?

Yes. The SDK is fully cross-platform. Add the appropriate platform-specific NuGet redist packages (macOS, Linux x64) alongside the main `VisioForge.DotNet.VideoCapture` package. The same C# code runs on Windows, macOS, and Linux, and the SDK also supports .NET MAUI for mobile and cross-platform desktop deployment.

## VB.NET Support

Looking for VB.NET webcam recording? See our dedicated guide: [Record Webcam Video in VB.NET](../record-webcam-vb-net/).

## See Also

- [Record Webcam Video in VB.NET](../record-webcam-vb-net/) — same functionality with VB.NET code examples
- [Screen Capture to MP4](../../video-tutorials/screen-capture-mp4/) — record desktop screen instead of webcam
- [Webcam to MP4 Tutorial](../../video-tutorials/video-capture-webcam-mp4/) — step-by-step MP4 recording walkthrough
- [IP Camera Capture to MP4](../../video-tutorials/ip-camera-capture-mp4/) — record from network cameras instead of local webcams
- [Barcode & QR Code Scanner](../../../mediablocks/Guides/barcode-qr-reader-guide/) — combine webcam capture with barcode detection
- [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) — product page and downloads

---END OF PAGE---


## Screen Capture in VB.NET - Record Desktop Video to MP4
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/guides/screen-capture-vb-net/
**Description:** Learn how to record your desktop screen in VB.NET. Complete guide for full screen and region capture to MP4 with system audio using Video Capture SDK .Net.
**Tags:** Video Capture SDK, .NET, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, Capture, Webcam, Screen Capture, MP4, WebM, AVI, C#, VB.NET, NuGet
**API:** ScreenCaptureD3D11SourceSettings, VideoCaptureCoreX, MP4Output, VideoView, LoopbackAudioCaptureDeviceSourceSettings

# Screen Capture in VB.NET: Complete Guide to Record Desktop Video

Recording your desktop screen in VB.NET (Visual Basic .NET) applications is essential for building screen recorders, tutorial tools, and surveillance software. Whether you need full screen capture, region recording, or system audio capture, this guide provides step-by-step Visual Basic code examples using [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net).

## Why Use Video Capture SDK .Net for VB.NET Screen Recording

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) provides a complete screen recording solution for VB.NET developers:

- Full desktop capture and custom region screen recording
- Multi-monitor support with display enumeration
- Mouse cursor capture with optional click highlighting
- System audio recording (microphone and loopback/system sound)
- MP4 output with H.264/H.265 encoding and GPU acceleration
- Real-time screen preview during recording
- Async/await pattern for non-blocking capture
- WinForms and WPF support

## Required NuGet Packages

Add the following packages to your VB.NET project:

```
<PackageReference Include="VisioForge.DotNet.VideoCapture" Version="2026.2.19" />
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />
```

## Complete VB.NET Screen Recording Example

The following screen capture example demonstrates a WinForms application that records the desktop with audio and saves it to an MP4 file.

### SDK Initialization and Display Enumeration

Initialize the SDK and enumerate available displays and audio devices when the form loads:

```
Imports System.IO
Imports VisioForge.Core
Imports VisioForge.Core.VideoCaptureX
Imports VisioForge.Core.Types.X.Sources
Imports VisioForge.Core.Types.X.Output
Imports VisioForge.Core.Types.X.AudioRenderers

Public Class Form1
    Private VideoCapture1 As VideoCaptureCoreX

    Private Async Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        ' Initialize the SDK
        Await VisioForgeX.InitSDKAsync()

        ' Create the video capture engine with VideoView for preview
        VideoCapture1 = New VideoCaptureCoreX(VideoView1)
        AddHandler VideoCapture1.OnError, AddressOf VideoCapture1_OnError

        ' Enumerate available displays
        For i As Integer = 0 To Screen.AllScreens.Length - 1
            Dim scr = Screen.AllScreens(i)
            cbDisplayIndex.Items.Add(
                $"{i}: {scr.DeviceName} ({scr.Bounds.Width}x{scr.Bounds.Height})")
        Next
        If cbDisplayIndex.Items.Count > 0 Then cbDisplayIndex.SelectedIndex = 0

        ' Enumerate audio input devices (microphones)
        Dim audioSources = Await DeviceEnumerator.Shared.AudioSourcesAsync()
        For Each source In audioSources
            cbAudioInputDevice.Items.Add(source.DisplayName)
            If cbAudioInputDevice.Items.Count = 1 Then cbAudioInputDevice.SelectedIndex = 0
        Next

        ' Enumerate audio loopback devices (system sound)
        Dim audioOutputs = Await DeviceEnumerator.Shared.AudioOutputsAsync(
            AudioOutputDeviceAPI.WASAPI2)
        For Each audioOutput In audioOutputs
            cbAudioLoopbackDevice.Items.Add(audioOutput.Name)
            If cbAudioLoopbackDevice.Items.Count = 1 Then cbAudioLoopbackDevice.SelectedIndex = 0
        Next

        ' Set default output file path
        edOutput.Text = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.MyVideos),
            "screen_capture.mp4")
    End Sub
```

### Full Screen Capture to MP4

Use the [ScreenCaptureD3D11SourceSettings](../../video-sources/screen/) class to capture the entire desktop at a specified frame rate and save to MP4:

```
    Private Async Sub btStartFullScreen_Click(
            sender As Object, e As EventArgs) Handles btStartFullScreen.Click
        Try
            ' Configure full screen capture source
            Dim screenSource As New ScreenCaptureD3D11SourceSettings() With {
                .MonitorIndex = cbDisplayIndex.SelectedIndex,
                .FrameRate = New VideoFrameRate(15, 1),
                .CaptureCursor = True
            }

            VideoCapture1.Video_Source = screenSource
            VideoCapture1.Video_Play = True

            ' Configure MP4 output
            VideoCapture1.Outputs_Clear()
            VideoCapture1.Outputs_Add(New MP4Output(edOutput.Text), True)

            ' Start capture
            Await VideoCapture1.StartAsync()
        Catch ex As Exception
            MessageBox.Show(Me, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
        End Try
    End Sub
```

### Region Capture (Custom Area)

Capture a specific rectangular area of the screen instead of the full desktop:

```
    Private Async Sub btStartRegion_Click(
            sender As Object, e As EventArgs) Handles btStartRegion.Click
        Try
            ' Configure region capture with custom rectangle
            Dim screenSource As New ScreenCaptureD3D11SourceSettings() With {
                .Rectangle = New Rect(
                    CInt(edLeft.Text),
                    CInt(edTop.Text),
                    CInt(edRight.Text),
                    CInt(edBottom.Text)),
                .FrameRate = New VideoFrameRate(15, 1),
                .CaptureCursor = True
            }

            VideoCapture1.Video_Source = screenSource
            VideoCapture1.Video_Play = True

            ' Configure MP4 output
            VideoCapture1.Outputs_Clear()
            VideoCapture1.Outputs_Add(New MP4Output(edOutput.Text), True)

            ' Start capture
            Await VideoCapture1.StartAsync()
        Catch ex As Exception
            MessageBox.Show(Me, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
        End Try
    End Sub
```

### Recording with System Audio (Microphone)

Add microphone audio recording to your screen capture:

```
    ' Configure microphone audio source
    Dim audioSources = Await DeviceEnumerator.Shared.AudioSourcesAsync()
    Dim audioDevice = audioSources.FirstOrDefault(
        Function(d) d.DisplayName = cbAudioInputDevice.Text)

    If audioDevice IsNot Nothing Then
        VideoCapture1.Audio_Source = audioDevice.CreateSourceSettingsVC(Nothing)
    End If

    VideoCapture1.Audio_Record = True
```

### Recording with Loopback Audio (System Sound)

Capture system audio output (what you hear from speakers) instead of microphone input:

```
    ' Configure loopback audio source (system sound)
    Dim audioOutputs = Await DeviceEnumerator.Shared.AudioOutputsAsync(
        AudioOutputDeviceAPI.WASAPI2)
    Dim audioDevice = audioOutputs.FirstOrDefault(
        Function(d) d.Name = cbAudioLoopbackDevice.Text)

    If audioDevice IsNot Nothing Then
        VideoCapture1.Audio_Source = New LoopbackAudioCaptureDeviceSourceSettings(audioDevice)
    End If

    VideoCapture1.Audio_Record = True
```

### Stopping Recording

Stop the screen recording and finalize the output file:

```
    Private Async Sub btStop_Click(sender As Object, e As EventArgs) Handles btStop.Click
        Try
            Await VideoCapture1.StopAsync()
        Catch ex As Exception
            MessageBox.Show(Me, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
        End Try
    End Sub
```

### Cleanup on Form Close

Properly dispose of resources when the application exits:

```
    Private Async Sub Form1_FormClosing(
            sender As Object, e As FormClosingEventArgs) Handles MyBase.FormClosing

        If VideoCapture1 IsNot Nothing Then
            Await VideoCapture1.DisposeAsync()
            VideoCapture1 = Nothing
        End If

        VisioForgeX.DestroySDK()
    End Sub

    Private Sub VideoCapture1_OnError(sender As Object, e As ErrorsEventArgs)
        If Me.InvokeRequired Then
            Me.Invoke(Sub() mmLog.Text &= e.Message & Environment.NewLine)
        Else
            mmLog.Text &= e.Message & Environment.NewLine
        End If
    End Sub
End Class
```

## Preview-Only Mode (No Recording)

To preview the desktop capture feed without saving to a file, skip adding the output:

```
' Configure screen source
Dim screenSource As New ScreenCaptureD3D11SourceSettings() With {
    .MonitorIndex = 0,
    .FrameRate = New VideoFrameRate(15, 1),
    .CaptureCursor = True
}

VideoCapture1.Video_Source = screenSource
VideoCapture1.Video_Play = True

' No output added - preview only
Await VideoCapture1.StartAsync()
```

## Output Format Options

While this guide focuses on [MP4 recording](../../../general/output-formats/mp4/), you can save your screen capture in other formats:

### WebM Output

[WebM](../../../general/output-formats/webm/) is ideal for web-based screen recordings, offering royalty-free VP8/VP9 encoding with smaller file sizes:

```
VideoCapture1.Outputs_Add(New WebMOutput(edOutput.Text), True)
```

### AVI Output

AVI provides maximum compatibility with legacy video editors and Windows-based workflows:

```
VideoCapture1.Outputs_Add(New AVIOutput(edOutput.Text), True)
```

## Sample Applications

Complete VB.NET sample applications are available:

- [Screen Capture X VB.NET (WinForms)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WinForms/VB/Screen%20Capture%20X%20VB) — full-featured screen capture application with region and full screen modes

## Frequently Asked Questions

### How do I record both microphone and system audio simultaneously in VB.NET screen capture?

`VideoCaptureCoreX` exposes a single `Audio_Source`, so to mix a microphone with system-loopback audio you build a Media Blocks pipeline: one `SystemAudioSourceBlock` for the microphone, one loopback source, and an `AudioMixerBlock` that combines them before the encoder/sink. The [Media Blocks audio processing reference](../../../mediablocks/AudioProcessing/) covers `AudioMixerBlock` setup. Alternatively, on Windows switch to `VideoCaptureCore` (non-X) where `Additional_Audio_CaptureDevice_MixChannels` + the internal additional-devices list handle mixing directly.

### What frame rate should I use for VB.NET screen recording?

Use 10–15 FPS for general desktop recording (documents, presentations, browsing) and 25–30 FPS for motion-intensive content like video playback or animations. Higher frame rates increase CPU usage and file size. The example code in this guide uses `New VideoFrameRate(15, 1)` — change the first parameter to your desired FPS. For GPU-accelerated encoding, pair higher frame rates with `MP4Output` which uses hardware H.264 encoding when available.

### Can I record the screen without showing a preview in VB.NET?

Yes. Create `VideoCaptureCoreX` without a `VideoView` parameter: `VideoCapture1 = New VideoCaptureCoreX()`. Set `Video_Play = False` to skip rendering, configure the screen source and MP4 output as usual, then call `Await VideoCapture1.StartAsync()`. This reduces CPU usage because no frames are rendered to the UI. Console applications and Windows Services can use this approach for headless screen recording.

### How do I handle high-DPI and scaled displays in VB.NET screen recording?

`ScreenCaptureD3D11SourceSettings` captures the native screen resolution regardless of Windows display scaling. A 4K monitor at 150% scaling is still recorded at 3840×2160 pixels. If your VB.NET WinForms application displays incorrect coordinates in region capture, add `<dpiAware>true</dpiAware>` to your `app.manifest` file or call `SetProcessDPIAware()` at startup so that `Screen.AllScreens` reports physical pixel dimensions instead of scaled values.

## See Also

- [Screen Capture to MP4 Tutorial](../../video-tutorials/screen-capture-mp4/) — step-by-step C# screen recording walkthrough
- [Screen Source Configuration](../../video-sources/screen/) — DirectX 11/12 and WGC capture API reference
- [Record Webcam Video in VB.NET](../record-webcam-vb-net/) — capture from webcam instead of screen in Visual Basic
- [Save Webcam Video in C#](../save-webcam-video/) — same webcam capture functionality with C# code examples
- [Build a Video Player in VB.NET](../../../mediaplayer/guides/video-player-vb-net/) — VB.NET media player with playback controls
- [Pre-Event Recording](../pre-event-recording/) — circular buffer recording that captures footage before the trigger event
- [Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) — product page and downloads

---END OF PAGE---


## Synchronized Multi-Camera Video Recording in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/guides/start-in-sync/
**Description:** Start and stop multiple webcam or IP camera recordings in perfect sync with VisioForge Video Capture SDK. C# code examples and troubleshooting tips.
**Tags:** Video Capture SDK, .NET, VideoCaptureCore, Windows, Capture, Webcam, IP Camera, MP4, C#
**API:** VideoCaptureCore

# Sync Multiple Video Captures in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Introduction to Multi-Source Video Capture

When developing applications that require recording from multiple video sources simultaneously, synchronization becomes a critical challenge. Whether you're building surveillance systems, multi-camera recording solutions, or specialized video production tools, ensuring all video streams start and end recording at precisely the same moment can make the difference between professional-grade and amateur results.

This guide explains how to properly synchronize multiple video capture objects in .NET applications, eliminating timing discrepancies between different cameras or input sources.

## Understanding the Challenge of Video Synchronization

Without proper synchronization, multiple video recordings started sequentially will have timing offsets. Even millisecond differences can cause problems in applications where precise timing alignment is required, such as:

- Multi-angle sports analysis
- Security camera systems
- Motion capture setups
- Scientific measurements and observations
- Professional video production

These timing discrepancies occur because each time you initialize a capture device and start recording, there's processing overhead that varies between devices.

## The Solution: Delayed Start Mechanism

The Video Capture SDK provides an elegant solution through its delayed start mechanism. This approach allows you to:

1. Initialize all capture objects and prepare them for recording
2. Put them in a "ready" state where they're waiting for a final signal
3. Trigger all recordings to start with minimal delay between sources

This approach dramatically reduces the synchronization gap between recordings compared to sequential start operations.

## Implementation Using VideoCaptureCore

In this implementation, we'll use the `VideoCaptureCore` engine to demonstrate the synchronization technique.

### Step 1: Set Up Your Video Capture Objects

First, create and configure your video capture objects for each source:

```
// Create video capture objects
var capture1 = new VideoCaptureCore();
var capture2 = new VideoCaptureCore();

// Configure output files
capture1.Output_Filename = "camera1_recording.mp4";
capture2.Output_Filename = "camera2_recording.mp4";

// Configure video sources
// ...

// Configure other settings as needed
```

### Step 2: Enable Delayed Start

The critical step is to enable the delayed start feature on all capture objects before calling their respective `Start` or `StartAsync` methods:

```
// Enable delayed start for all capture objects
capture1.Start_DelayEnabled = true;
capture2.Start_DelayEnabled = true;
```

### Step 3: Initialize the Capture Objects

Next, call the `Start` or `StartAsync` method on each object. This initializes the sources, codecs, and output files but doesn't begin the actual recording process:

```
// Initialize all capture objects (but don't start recording yet)
await capture1.StartAsync();
await capture2.StartAsync();

// Or for synchronous operation:
// capture1.Start();
// capture2.Start();
```

At this point, all your capture objects are initialized and waiting for the final trigger.

### Step 4: Trigger Synchronized Recording

Finally, call the `StartDelayed` or `StartDelayedAsync` method on each object to begin recording with minimal delay between them:

```
// Begin synchronized recording
await capture1.StartDelayedAsync();
await capture2.StartDelayedAsync();

// Or for synchronous operation:
// capture1.StartDelayed();
// capture2.StartDelayed();
```

This triggers the actual recording to start on all prepared devices with the smallest possible delay between them.

## Complete Synchronization Example

Here's a complete example demonstrating synchronized recording from two video sources:

```
using System;
using System.Threading.Tasks;
using VisioForge.Core.VideoCapture;

namespace MultiCameraRecordingApp
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Create video capture objects
            var camera1 = new VideoCaptureCore();
            var camera2 = new VideoCaptureCore();

            try
            {
                // Configure camera 1
                // ...
                camera1.Output_Filename = "camera1_recording.mp4";

                // Configure camera 2
                // ...
                camera2.Output_Filename = "camera2_recording.mp4";

                // Enable delayed start for synchronization
                camera1.Start_DelayEnabled = true;
                camera2.Start_DelayEnabled = true;

                Console.WriteLine("Initializing cameras...");

                // Initialize both cameras (but don't start recording yet)
                await camera1.StartAsync();
                await camera2.StartAsync();

                Console.WriteLine("Cameras initialized and ready.");
                Console.WriteLine("Starting synchronized recording...");

                // Begin synchronized recording
                await camera1.StartDelayedAsync();
                await camera2.StartDelayedAsync();

                Console.WriteLine("Recording in progress. Press Enter to stop.");
                Console.ReadLine();

                // Stop recording
                await camera1.StopAsync();
                await camera2.StopAsync();

                Console.WriteLine("Recording completed successfully.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
            finally
            {
                // Clean up resources
                camera1.Dispose();
                camera2.Dispose();
            }
        }
    }
}
```

## Advanced Synchronization Techniques

### Hardware Synchronization

For applications requiring frame-perfect synchronization, consider these additional approaches:

- External hardware triggers: Some professional cameras support external trigger inputs
- Genlock: Professional broadcast equipment often uses genlock for frame-level synchronization
- Timecode synchronization: Embedding matching timecodes across video files

### Multiple File Format Considerations

When recording to different file formats simultaneously, be aware that certain formats have different initialization times. To minimize this effect:

- Use identical encoding settings when possible
- Prefer container formats with similar overhead
- When mixing container formats, initialize the more complex format first

## Troubleshooting Synchronization Issues

If you encounter synchronization problems, consider these common issues:

1. **Variable Initialization Times**: Different camera models may have different startup times. Call `StartDelayedAsync` in order from slowest to fastest device.
2. **Resource Contention**: Multiple high-resolution captures may compete for system resources. Consider reducing resolution or frame rate for better sync.
3. **USB Bandwidth Limitations**: When using multiple USB cameras, bandwidth constraints may cause delays. Use separate USB controllers when possible.
4. **CPU Overload**: High-resolution encoding across multiple streams can overwhelm the CPU. Monitor CPU usage and consider using hardware encoding.

## Performance Optimization

To maximize synchronization precision:

- Prioritize your recording thread using system thread priority settings
- Close unnecessary applications to free system resources
- Use SSDs for recording outputs to minimize I/O bottlenecks
- Consider dedicated graphics cards with hardware encoding support

## Conclusion

Properly synchronizing multiple video capture sources is essential for creating professional multi-camera applications. By using the delayed start mechanism provided by the Video Capture SDK, developers can achieve highly synchronized recordings with minimal effort.

This approach separates the initialization phase from the recording phase, allowing all devices to be prepared before any begin recording, resulting in significantly improved synchronization between sources.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Video Capture SDK for C# .NET - Webcam, Screen, IP Camera
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/
**Description:** Record webcam, screen, and IP camera (RTSP/ONVIF) to MP4 with VisioForge Video Capture SDK. Cross-platform async API with GPU encoding for WinForms, WPF, MAUI.
**Tags:** Video Capture SDK, .NET, DirectShow, Windows, macOS, Linux, Android, iOS, Capture, Streaming
**API:** MP4Output, DeviceEnumerator, VideoCaptureCoreX, VideoCaptureDeviceSourceSettings, VideoView

# Video Capture SDK for C# .NET — Webcam, Screen, and IP Camera Capture API

[Video Capture SDK .NET](https://www.visioforge.com/video-capture-sdk-net)

## Introduction

The Video Capture SDK for .NET is a C# video capture API that lets you record from webcams, IP cameras (RTSP/ONVIF), and screens in your .NET applications. It replaces low-level DirectShow video capture code with a modern async API — enumerate devices, configure sources, and start recording in a few lines of C#.

The SDK handles device enumeration, format negotiation, GPU-accelerated encoding, and file output across Windows, macOS, and Linux. Whether you need to save an RTSP stream to file, capture photos from a webcam, or build a screen capture tool, the API covers it.

## Quick Start

### 1. Install NuGet Packages

```
dotnet add package VisioForge.DotNet.VideoCapture
```

Add platform-specific native dependencies:

```
<!-- Windows x64 -->
<PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
<PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />

<!-- macOS -->
<PackageReference Include="VisioForge.CrossPlatform.Core.macOS" Version="2026.8.5" />

<!-- Linux x64 (needs system GStreamer 1.22+) -->
<PackageReference Include="VisioForge.CrossPlatform.Core.Linux.x64" Version="2025.9.0" />
```

For the full list of packages and UI framework support (WinForms, WPF, MAUI, Avalonia), see the [Installation Guide](../install/).

### 2. Initialize the SDK

Call `InitSDKAsync()` once at application startup before using any capture functionality:

```
using VisioForge.Core;

await VisioForgeX.InitSDKAsync();
```

### 3. C# Webcam Capture to MP4 (Minimal Example)

```
using VisioForge.Core;
using VisioForge.Core.VideoCaptureX;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.Output;

// Create capture instance linked to a VideoView control
var capture = new VideoCaptureCoreX(videoView);

// Enumerate available devices
var videoDevices = await DeviceEnumerator.Shared.VideoSourcesAsync();
var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync();

// Configure video and audio sources
capture.Video_Source = new VideoCaptureDeviceSourceSettings(videoDevices[0]);
capture.Audio_Source = audioDevices[0].CreateSourceSettingsVC();
capture.Audio_Record = true;

// Add MP4 output (H.264 + AAC, GPU-accelerated when available)
capture.Outputs_Add(new MP4Output("recording.mp4"));

// Start capture
await capture.StartAsync();

// ... when done:
await capture.StopAsync();
await capture.DisposeAsync();
```

### 4. Cleanup at Shutdown

```
VisioForgeX.DestroySDK();
```

## Core Workflow

Every capture application follows the same pattern:

1. **Initialize SDK** — `VisioForgeX.InitSDKAsync()` (once per app lifetime)
2. **Enumerate devices** — `DeviceEnumerator.Shared.VideoSourcesAsync()` / `AudioSourcesAsync()`
3. **Create capture object** — `new VideoCaptureCoreX(videoView)` for preview, or without a view for headless recording
4. **Configure source** — Set `Video_Source` to a webcam, IP camera, screen, or other source
5. **Configure output** — Add one or more outputs: `MP4Output`, `WebMOutput`, `AVIOutput`, etc.
6. **Start** — `await capture.StartAsync()`
7. **Stop** — `await capture.StopAsync()` finalizes the output file
8. **Dispose** — `await capture.DisposeAsync()` releases all resources

## Common C# Video Capture Scenarios

### Record Webcam Video in C

Record from a USB webcam or built-in camera to MP4 with H.264/AAC:

```
capture.Video_Source = new VideoCaptureDeviceSourceSettings(device);
capture.Outputs_Add(new MP4Output("webcam.mp4"));
```

See the full tutorial: [Save Webcam Video in C#](guides/save-webcam-video/)

### Save RTSP Stream to File in C

Connect to IP cameras and save RTSP streams to MP4 files. Supports RTSP, ONVIF, and HTTP protocols:

```
// RTSPSourceSettings has a private ctor — construct via the async factory
// so the source can probe codecs before the pipeline starts.
capture.Video_Source = await RTSPSourceSettings.CreateAsync(
    new Uri("rtsp://192.168.1.100:554/stream"),
    login: "admin",
    password: "password",
    audioEnabled: true);
capture.Outputs_Add(new MP4Output("ipcam.mp4"));
```

See: [IP Camera to MP4](video-tutorials/ip-camera-capture-mp4/) | [RTSP Guide](video-sources/ip-cameras/rtsp/) | [ONVIF Guide](video-sources/ip-cameras/onvif/)

### C# Screen Capture to MP4

Record the desktop or a specific screen region to MP4:

```
// X-engine screen capture on Windows uses ScreenCaptureD3D11SourceSettings
// (other platforms: ScreenCaptureGDISourceSettings, ScreenCaptureMacOSSourceSettings,
// ScreenCaptureXDisplaySourceSettings — all implement IVideoCaptureBaseVideoSourceSettings).
capture.Video_Source = new ScreenCaptureD3D11SourceSettings
{
    FrameRate     = new VideoFrameRate(30),
    CaptureCursor = true,
};
capture.Outputs_Add(new MP4Output("screen.mp4"));
```

See: [Screen Capture to MP4](video-tutorials/screen-capture-mp4/)

### Audio-Only Recording

Record from a microphone without video:

```
capture.Video_Source = null; // disable video for audio-only capture
capture.Audio_Source = audioDevices[0].CreateSourceSettingsVC();
capture.Audio_Record = true;
capture.Outputs_Add(new MP4Output("audio.mp4"));
```

### Capture Photo from Webcam

Grab a still image from the live webcam video feed:

```
capture.Snapshot_Grabber_Enabled = true;
await capture.StartAsync();

// Later, save a frame:
await capture.Snapshot_SaveAsync("photo.jpg", SKEncodedImageFormat.Jpeg, 85);
```

See: [Webcam Photo Capture](guides/make-photo-using-webcam/)

## Supported Input Devices

### Cameras and Capture Hardware

- USB webcams and capture devices (up to 4K)
- DV and HDV MPEG-2 camcorders
- Professional PCI capture cards
- Television tuners (with and without MPEG encoder)

### Network and IP Cameras

- RTSP-enabled IP cameras
- JPEG/MJPEG HTTP cameras
- RTMP streaming sources
- ONVIF-compatible cameras
- SRT and NDI sources

Browse our [IP camera brands directory](../camera-brands/) for brand-specific RTSP URLs and connection guides covering 60+ manufacturers.

### Professional and Industrial Equipment

- Blackmagic Decklink capture devices
- Microsoft Kinect and Kinect 2
- GenICam / GigE Vision / USB3 Vision industrial cameras

### Audio Sources

- System audio capture devices and sound cards
- Professional ASIO audio devices
- Audio loopback (system sound) capture

## Output Formats and Encoders

The SDK supports multiple output containers and codecs. GPU-accelerated encoding (NVIDIA NVENC, AMD AMF, Intel Quick Sync) is used automatically when available.

| Format | Video Codecs | Audio Codecs | Use Case |
| --- | --- | --- | --- |
| MP4 | H.264, H.265 (HEVC) | AAC | General purpose, widest compatibility |
| WebM | VP8, VP9, AV1 | Vorbis, Opus | Web delivery, royalty-free |
| AVI | MJPEG, custom codecs | PCM, MP3 | Legacy compatibility |
| MKV | H.264, H.265, VP9 | AAC, Vorbis, FLAC | Flexible container, multiple tracks |
| GIF | Animated GIF | — | Short clips, previews |

For detailed codec configuration, see [Output Formats](../general/output-formats/mp4/) and [Video Encoders](../general/video-encoders/h264/).

## Platform Support

| Platform | UI Frameworks | Notes |
| --- | --- | --- |
| Windows x64 | WinForms, WPF, MAUI, Avalonia, Console | Full feature set including DirectShow sources |
| macOS | MAUI, Avalonia, Console | AVFoundation camera access |
| Linux x64 | Avalonia, Console | V4L2 camera access |
| Android | MAUI | Via MAUI camera integration |
| iOS | MAUI | Via MAUI camera integration |

## Migrating from DirectShow Video Capture

If you're currently using DirectShow (DirectShow.NET) for video capture in C#, the Video Capture SDK provides a modern replacement. Instead of manually building filter graphs with `IGraphBuilder`, connecting pins, and managing COM objects, you use typed settings classes and async methods.

| DirectShow Concept | Video Capture SDK Equivalent |
| --- | --- |
| `IGraphBuilder` filter graph | Managed automatically by `VideoCaptureCoreX` |
| `ICaptureGraphBuilder2` | Not needed — source and output configured via properties |
| Device enumeration via `DsDevice` | `DeviceEnumerator.Shared.VideoSourcesAsync()` |
| `ISampleGrabber` for frame access | `Snapshot_SaveAsync()` or `OnVideoFrameBuffer` event |
| Manual pin connection | Automatic — or use [Media Blocks SDK](../mediablocks/GettingStarted/) for explicit pipelines |
| COM cleanup / `Marshal.ReleaseComObject` | Standard `IAsyncDisposable` pattern |

For a detailed migration guide with side-by-side code examples, see [Migrate from DirectShow.NET](https://www.visioforge.com/compare/migrate-from-directshow-net).

## Developer Documentation

### Core Functionality

- [Configuring Video Sources](video-sources/)
- [Configuring Audio Sources](audio-sources/)
- [Video Processing and Effects](video-processing/)
- [Audio Rendering](audio-rendering/)

### Advanced Features

- [Video Capture Implementation](video-capture/)
- [Audio Capture Implementation](audio-capture/)
- [Motion Detection](motion-detection/)
- [Network Streaming](network-streaming/)
- [Pre-Event Recording](guides/pre-event-recording/)
- [Synchronizing Multiple Captures](guides/start-in-sync/)

### Tutorials (Step-by-Step with Code)

- [Webcam to MP4](video-tutorials/video-capture-webcam-mp4/) | [to AVI](video-tutorials/video-capture-camera-avi/) | [to WMV](video-tutorials/video-capture-webcam-wmv/)
- [Screen Capture to MP4](video-tutorials/screen-capture-mp4/) | [to AVI](video-tutorials/screen-capture-avi/) | [to WMV](video-tutorials/screen-capture-wmv/)
- [IP Camera Preview](video-tutorials/ip-camera-preview/) | [IP Camera to MP4](video-tutorials/ip-camera-capture-mp4/)
- [Text Overlay on Webcam](video-tutorials/webcam-capture-text-overlay/)
- [Camera Video Preview](video-tutorials/camera-video-preview/)
- [All Video Tutorials](video-tutorials/)

### Guides

- [Save Webcam Video in C#](guides/save-webcam-video/)
- [Record Webcam in VB.NET](guides/record-webcam-vb-net/)
- [Screen Capture in VB.NET](guides/screen-capture-vb-net/)
- [Webcam Photo Capture](guides/make-photo-using-webcam/)
- [All Guides](guides/)

### Integration

- [Third-Party Software Integration](3rd-party-software/)
- [Computer Vision (Face Detection)](computer-vision/)
- [MAUI Camera Recording](maui/camera-recording-maui/)

## Developer Resources

- [Code Samples on GitHub](https://github.com/visioforge/.Net-SDK-s-samples/)
- [Deployment Guidelines](deployment/)
- [API Reference](https://api.visioforge.org/dotnet/api/index.html)
- [Changelog](../changelog/)
- [End User License Agreement](../../eula/)
- [Licensing Information](https://www.visioforge.com/licensing)

---END OF PAGE---


## Camera Recording in .NET MAUI — iOS, Android, Windows
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/maui/camera-recording-maui/
**Description:** Record video from device cameras in .NET MAUI using VisioForge Video Capture SDK. Cross-platform capture for iOS, Android, macCatalyst, and Windows.
**Tags:** Video Capture SDK, .NET, C++, VideoCaptureCoreX, Windows, macOS, Android, iOS, MAUI, Capture, Streaming, Encoding, Effects, MP4, H.264, MP3, C#, NuGet, Entitlements
**API:** DeviceEnumerator, VideoView, IVideoView, VideoCaptureDeviceSourceSettings, VideoCaptureCoreX

# How to Capture and Process Video in .NET MAUI Apps Using VisioForge SDK

## Introduction

The VisioForge Video Capture SDK for .NET is a comprehensive media capture and processing solution that integrates seamlessly with .NET MAUI applications. As a feature-rich SDK, it significantly extends .NET MAUI's native capabilities for video capture across supported platforms including iOS, Android, macCatalyst, and Windows.

In this tutorial, we will learn how to record video from hardware cameras on iOS/Android devices and webcams on Windows and macOS. We will also cover how to add various effects and filters to the video, as well as how to save the video to the device using native APIs for each platform.

For mobile devices (.NET iOS and .NET Android), we will request the necessary permissions to ensure proper functionality with the native device capabilities.

The full sample code is available on [GitHub](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/MAUI/SimpleCapture) as part of the SDK documentation.

## Prerequisites

Required software and tools:

- Visual Studio or Visual Studio Code with .NET MAUI support or JetBrains Rider
- [VisioForge Video Capture SDK for .NET](https://www.visioforge.com/video-capture-sdk-net) (we'll use NuGet packages)

## Setting up a Basic .NET MAUI Project Structure

### Create a New Empty .NET MAUI Project (.NET 8 or Later)

You can use Visual Studio, Rider, or dotnet tool to create a new .NET MAUI project with cross-platform support.

### Update Project File

Add runtime targets for macCatalyst for arm64 and x86\_64 compatibility, which ensures proper .NET MAUI support for Mac environments:

```
<PropertyGroup Condition="$([MSBuild]::IsOSPlatform('osx')) AND $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'maccatalyst' AND '$([System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture)' == 'X64'">
  <RuntimeIdentifier>maccatalyst-x64</RuntimeIdentifier>
</PropertyGroup>
<PropertyGroup Condition="$([MSBuild]::IsOSPlatform('osx')) AND $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'maccatalyst' AND '$([System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture)' == 'Arm64'">
  <RuntimeIdentifier>maccatalyst-arm64</RuntimeIdentifier>
</PropertyGroup>
```

### NuGet Main SDK Packages

Use the latest NuGet package versions of the SDK for .NET in your project.

Add the following NuGet packages to your project:

```
<PackageReference Include="VisioForge.DotNet.VideoCapture" Version="2026.8.16" />
<PackageReference Include="VisioForge.DotNet.Core.UI.MAUI" Version="2026.8.16" />
```

The `VideoCapture` package contains the main video capture functionality, while the `Core.UI.MAUI` package contains the `VideoView` control for video preview in .NET MAUI apps.

### NuGet Redist Packages

Add the following NuGet packages to your project based on target platform:

**Windows:**

```
<ItemGroup Condition="$(TargetFramework.Contains('-windows'))">
  <PackageReference Include="VisioForge.CrossPlatform.Core.Windows.x64" Version="2026.4.29" />
  <PackageReference Include="VisioForge.CrossPlatform.Libav.Windows.x64" Version="2026.4.29" />
</ItemGroup>
```

**Android** requires a NuGet redist package and a project reference to the [Android dependency project](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/AndroidDependency):

```
<ItemGroup Condition="$(TargetFramework.Contains('-android'))">
  <PackageReference Include="VisioForge.CrossPlatform.Core.Android" Version="2026.7.27" />
  <ProjectReference Include="..\..\..\AndroidDependency\VisioForge.Core.Android.X10.csproj" />
</ItemGroup>
```

**iOS:**

```
<ItemGroup Condition="$(TargetFramework.Contains('-ios'))">
  <!-- The iOS redist version trails the SDK version on purpose - it tracks the
       GStreamer-iOS rebuild cadence, not the wrapper release. -->
  <PackageReference Include="VisioForge.CrossPlatform.Core.iOS" Version="2025.12.0" />
</ItemGroup>
```

**macCatalyst** requires a NuGet redist package and a target code to copy the redist files to the app file:

```
<!-- Custom NuGet package and target code for maccatalyst to copy NuGet redist files to app file -->
<ItemGroup Condition="$(TargetFramework.Contains('-maccatalyst'))">
  <PackageReference Include="VisioForge.CrossPlatform.Core.macCatalyst" Version="2026.8.5" />
</ItemGroup>

<Target Name="CopyNativeLibrariesToMonoBundle" AfterTargets="Build" Condition="$(TargetFramework.Contains('-maccatalyst'))">
  <Message Text="Starting CopyNativeLibrariesToMonoBundle target..." Importance="High" />
  <PropertyGroup>
    <AppBundleDir>$(OutputPath)$(AssemblyName).app</AppBundleDir>
    <MonoBundleDir>$(AppBundleDir)/Contents/MonoBundle</MonoBundleDir>
  </PropertyGroup>
  <Message Text="AppBundleDir: $(AppBundleDir)" Importance="High" />
  <Message Text="MonoBundleDir: $(MonoBundleDir)" Importance="High" />
  <MakeDir Directories="$(MonoBundleDir)" Condition="!Exists('$(MonoBundleDir)')" />
  <Copy SourceFiles="@(None-&gt;'%(FullPath)')" DestinationFolder="$(MonoBundleDir)" Condition="'%(Extension)' == '.dylib' Or '%(Extension)' == '.so'">
    <Output TaskParameter="CopiedFiles" ItemName="CopiedNativeFiles" />
  </Copy>
  <Message Text="Copied native files:" Importance="High" Condition="@(CopiedNativeFiles) != ''" />
  <Message Text=" - %(CopiedNativeFiles.Identity)" Importance="High" Condition="@(CopiedNativeFiles) != ''" />
  <Message Text="Finished CopyNativeLibrariesToMonoBundle target." Importance="High" />
</Target>
```

### Update MauiProgram.cs

We need to add SkiaSharp support and VisioForge handlers initialization code to the MauiProgram.cs file:

```
using SkiaSharp.Views.Maui.Controls.Hosting;
using VisioForge.Core.UI.MAUI;

public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()

        // Add SkiaSharp support
        .UseSkiaSharp()

        // Add VisioForge handlers for VideoView and other controls
        .ConfigureMauiHandlers(handlers => handlers.AddVisioForgeHandlers())

        .ConfigureFonts(fonts =>
        {
            fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
        });

#if DEBUG
    builder.Logging.AddDebug();
#endif

    return builder.Build();
}
```

### Update Android Manifest

Add additional permissions to the `AndroidManifest.xml` file for native .NET Android functionality:

```
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
  <application android:allowBackup="true" android:icon="@mipmap/appicon" android:supportsRtl="true"></application>
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  <uses-permission android:name="android.permission.INTERNET" />
  <uses-permission android:name="android.permission.CAMERA" />
  <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" />
  <uses-permission android:name="android.permission.MANAGE_MEDIA" />
  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  <uses-permission android:name="android.permission.RECORD_AUDIO" />
  <uses-sdk android:minSdkVersion="23" android:targetSdkVersion="33" />
  <uses-feature android:name="android.hardware.camera" android:required="false" />
  <uses-feature android:name="android.hardware.camera.autofocus" />
</manifest>
```

CAMERA, RECORD\_AUDIO, and WRITE\_EXTERNAL\_STORAGE permissions are required for video capture on .NET Android. INTERNET and ACCESS\_NETWORK\_STATE permissions are required for network access. READ\_EXTERNAL\_STORAGE and WRITE\_EXTERNAL\_STORAGE permissions are required to save videos to the device. MANAGE\_EXTERNAL\_STORAGE and MANAGE\_MEDIA permissions are required for Android 11 and later.

### Add Permissions to iOS Info.plist File

Configure native iOS permissions in the Info.plist file for SDK iOS compatibility:

```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>LSRequiresIPhoneOS</key>
    <true/>
    <key>UIDeviceFamily</key>
    <array>
        <integer>1</integer>
        <integer>2</integer>
    </array>
    <key>UIRequiredDeviceCapabilities</key>
    <array>
        <string>arm64</string>
    </array>
    <key>UISupportedInterfaceOrientations</key>
    <array>
        <string>UIInterfaceOrientationLandscapeRight</string>
    </array>
    <key>UISupportedInterfaceOrientations~ipad</key>
    <array>
        <string>UIInterfaceOrientationPortrait</string>
        <string>UIInterfaceOrientationPortraitUpsideDown</string>
        <string>UIInterfaceOrientationLandscapeLeft</string>
        <string>UIInterfaceOrientationLandscapeRight</string>
    </array>
    <key>XSAppIconAssets</key>
    <string>Assets.xcassets/appicon.appiconset</string>
    <key>NSCameraUsageDescription</key>
    <string>Camera usage required</string>
    <key>NSMicrophoneUsageDescription</key>
    <string>Mic usage required</string>
    <key>NSPhotoLibraryUsageDescription</key>
    <string>This app requires access to the photos library to save videos.</string>
    <key>CFBundleIdentifier</key>
    <string></string>
</dict>
</plist>
```

NSCameraUsageDescription and NSMicrophoneUsageDescription are required for video capture on SDK iOS. NSPhotoLibraryUsageDescription is required to save videos to the device.

### Update macCatalyst Permissions

**Info.plist file for Mac Catalyst:**

```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>UIDeviceFamily</key>
    <array>
        <integer>1</integer>
        <integer>2</integer>
    </array>
    <key>UIRequiredDeviceCapabilities</key>
    <array>
        <string>arm64</string>
    </array>
    <key>UISupportedInterfaceOrientations</key>
    <array>
        <string>UIInterfaceOrientationPortrait</string>
        <string>UIInterfaceOrientationLandscapeLeft</string>
        <string>UIInterfaceOrientationLandscapeRight</string>
    </array>
    <key>UISupportedInterfaceOrientations~ipad</key>
    <array>
        <string>UIInterfaceOrientationPortrait</string>
        <string>UIInterfaceOrientationPortraitUpsideDown</string>
        <string>UIInterfaceOrientationLandscapeLeft</string>
        <string>UIInterfaceOrientationLandscapeRight</string>
    </array>
    <key>XSAppIconAssets</key>
    <string>Assets.xcassets/appicon.appiconset</string>
    <key>NSCameraUsageDescription</key>
    <string>Camera usage required</string>
    <key>NSMicrophoneUsageDescription</key>
    <string>Mic usage required</string>
</dict>
</plist>
```

**Entitlements.plist file for Mac Catalyst:**

```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>com.apple.security.device.audio-input</key>
    <true/>
    <key>com.apple.security.device.camera</key>
    <true/>
    <key>com.apple.security.device.usb</key>
    <true/>
</dict>
</plist>
```

## Creating UI

To see the video preview, add the `VideoView` control to your MainPage.xaml file.

Add the namespace to the top of the file:

```
xmlns:my="clr-namespace:VisioForge.Core.UI.MAUI;assembly=VisioForge.Core.UI.MAUI"
```

Add the `VideoView` control to the content of the page:

```
<my:VideoView
    Grid.Row="0"
    HorizontalOptions="FillAndExpand"
    VerticalOptions="FillAndExpand"
    x:Name="videoView"/>
```

In your code, you can add buttons to start and stop recording, select cameras, and more.

In this sample, we'll use buttons to select source video, audio sources, and audio output.

```
<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="SimpleCapture.MainPage"
             xmlns:my="clr-namespace:VisioForge.Core.UI.MAUI;assembly=VisioForge.Core.UI.MAUI">

    <ScrollView>
        <Grid RowDefinitions="*,Auto" >

            <my:VideoView
                Grid.Row="0"
                HorizontalOptions="FillAndExpand"
                VerticalOptions="FillAndExpand"
                x:Name="videoView"/>

            <StackLayout Grid.Row="1" x:Name="pnMain" Orientation="Vertical" HorizontalOptions="Fill" Background="#1e1e1e">

                <Grid>
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="*" />
                        <ColumnDefinition Width="*" />
                        <ColumnDefinition Width="*" />
                    </Grid.ColumnDefinitions>

                    <StackLayout Orientation="Vertical" Grid.Column="0" HorizontalOptions="StartAndExpand" Margin="5">
                        <Label Text="CAMERA" VerticalOptions="Center" HorizontalOptions="Center" Margin="5" TextColor="White" />
                        <Button x:Name="btCamera" Text="CAMERA" MinimumWidthRequest="200" Clicked="btCamera_Clicked" />
                    </StackLayout>

                    <StackLayout Orientation="Vertical" Grid.Column="1" HorizontalOptions="CenterAndExpand" Margin="5">
                        <Label Text="MICROPHONE" VerticalOptions="Center" HorizontalOptions="Center" Margin="5" TextColor="White" />
                        <Button x:Name="btMic" Text="MICROPHONE" MinimumWidthRequest="200" Clicked="btMic_Clicked" />
                    </StackLayout>

                    <StackLayout Orientation="Vertical" Grid.Column="2" HorizontalOptions="EndAndExpand" Margin="5">
                        <Label Text="SPEAKERS" VerticalOptions="Center" HorizontalOptions="Center" Margin="5" TextColor="White" />
                        <Button x:Name="btSpeakers" Text="SPEAKERS" MinimumWidthRequest="200" Clicked="btSpeakers_Clicked" />
                    </StackLayout>
                </Grid>

                <StackLayout
                    Orientation="Horizontal"
                    HorizontalOptions="Center"
                    Margin="5, 0, 5, 0">

                    <Button
                        x:Name="btStartPreview"
                        Text="PREVIEW"
                        Margin="5"
                        Clicked="btStartPreview_Clicked"
                        MinimumWidthRequest="100" />

                    <Button
                        x:Name="btStartCapture"
                        Text="CAPTURE"
                        Margin="5"
                        IsEnabled="False"
                        Clicked="btStartCapture_Clicked"
                        MinimumWidthRequest="100" />
                </StackLayout>
            </StackLayout>
        </Grid>
    </ScrollView>

</ContentPage>
```

Now we can start writing our source code to implement the functionality for our .NET MAUI app with native platform support.

## Namespaces and Fields

Add namespaces to your MainPage.xaml.cs file:

```
#if (__IOS__ && !__MACCATALYST__) || __ANDROID__
#define MOBILE
#endif

using System;
using System.ComponentModel;
using System.Diagnostics;

using VisioForge.Core;
using VisioForge.Core.Helpers;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.AudioRenderers;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.VideoCapture;
using VisioForge.Core.VideoCaptureX;
```

Add the following fields to your MainPage.xaml.cs file to handle native device capabilities:

```
// Video capture core object.
private VideoCaptureCoreX _core;

// Video capture devices.
private VideoCaptureDeviceInfo[] _cameras;

// Selected camera index.
private int _cameraSelectedIndex = 0;

// Audio capture devices.
private AudioCaptureDeviceInfo[] _mics;

// Selected microphone index.
private int _micSelectedIndex = 0;

// Audio output devices.
private AudioOutputDeviceInfo[] _speakers;

// Selected speaker index.
private int _speakerSelectedIndex = 0;

// Default button color.
private Color _defaultButtonColor;
```

## MainPage Constructor

Update constructor and add event handlers:

```
public MainPage()
{
    InitializeComponent();

    Loaded += MainPage_Loaded;
    Unloaded += MainPage_Unloaded;

    this.BindingContext = this;
}
```

## Permissions

Add code to request permissions for mobile platforms:

```
#if __IOS__ && !__MACCATALYST__
private void RequestPhotoPermission()
{
    Photos.PHPhotoLibrary.RequestAuthorization(status =>
    {
        if (status == Photos.PHAuthorizationStatus.Authorized)
        {
            Debug.WriteLine("Photo library access granted.");
        }
    });
}
#endif

private async Task RequestCameraPermissionAsync()
{
    var result = await Permissions.RequestAsync<Permissions.Camera>();

    // Check result from permission request. If it is allowed by the user, connect to scanner
    if (result == PermissionStatus.Granted)
    {
    }
    else
    {
        if (Permissions.ShouldShowRationale<Permissions.Camera>())
        {
            if (await DisplayAlert(null, "You need to allow access to the Camera", "OK", "Cancel"))
                await RequestCameraPermissionAsync();
        }
    }
}

private async Task RequestMicPermissionAsync()
{
    var result = await Permissions.RequestAsync<Permissions.Microphone>();

    // Check result from permission request. If it is allowed by the user, connect to scanner
    if (result == PermissionStatus.Granted)
    {
    }
    else
    {
        if (Permissions.ShouldShowRationale<Permissions.Microphone>())
        {
            if (await DisplayAlert(null, "You need to allow access to the Microphone", "OK", "Cancel"))
                await RequestMicPermissionAsync();
        }
    }
}
```

## MainPage Events

Add Loaded event to initialize the SDK for .NET MAUI apps:

```
private async void MainPage_Loaded(object sender, EventArgs e)
{
    // Ask for permissions
#if __ANDROID__ || __MACOS__ || __MACCATALYST__ || __IOS__
    await RequestCameraPermissionAsync();
    await RequestMicPermissionAsync();
#endif

#if __IOS__ && !__MACCATALYST__
    RequestPhotoPermission();
#endif

    // Loads the native GStreamer stack. It has to run before the first
    // VideoCaptureCoreX is constructed, otherwise the constructor throws
    // DllNotFoundException.
    await VisioForgeX.InitSDKAsync();

    // Get IVideoView interface
    IVideoView vv = videoView.GetVideoView();

    // Create core object with IVideoView interface
    _core = new VideoCaptureCoreX(vv);

    // Add event handlers
    _core.OnError += Core_OnError;

    // Enumerate cameras
    _cameras = await DeviceEnumerator.Shared.VideoSourcesAsync();
    if (_cameras.Length > 0)
    {
        btCamera.Text = _cameras[0].DisplayName;
    }

    // Enumerate microphones and other audio sources
    _mics = await DeviceEnumerator.Shared.AudioSourcesAsync(null);
    if (_mics.Length > 0)
    {
        btMic.Text = _mics[0].DisplayName;
    }

    // Enumerate audio outputs
    _speakers = await DeviceEnumerator.Shared.AudioOutputsAsync(null);
    if (_speakers.Length > 0)
    {
        btSpeakers.Text = _speakers[0].DisplayName;
    }

    // Add Destroying event handler
    Window.Destroying += Window_Destroying;

#if __ANDROID__ || (__IOS__ && !__MACCATALYST__)
    // Select second camera if available for mobile platforms
    if (_cameras.Length > 1)
    {
        btCamera.Text = _cameras[1].DisplayName;
        _cameraSelectedIndex = 1;
    }

    // Start preview
    btStartCapture.IsEnabled = true;
    await StartPreview();
#endif
}
```

Add Unloaded event:

```
private void MainPage_Unloaded(object sender, EventArgs e)
{
    // Dispose core object
    _core?.Dispose();
    _core = null;

    // Destroy SDK
    VisioForgeX.DestroySDK();
}
```

Add Destroying event handler:

```
private async void Window_Destroying(object sender, EventArgs e)
{
    if (_core != null)
    {
        _core.OnError -= Core_OnError;
        await _core.StopAsync();

        _core?.Dispose();
        _core = null;
    }

    VisioForgeX.DestroySDK();
}
```

Add error event handler:

```
private void Core_OnError(object sender, VisioForge.Core.Types.Events.ErrorsEventArgs e)
{
    Debug.WriteLine(e.Message);
}
```

Camera, microphone, and speaker selection event handlers are available in the GitHub code as part of the SDK documentation. We'll skip them here for brevity.

## Preview and Capture Implementation

Start button code:

```
private async Task StartPreview()
{
    if (_core.State == PlaybackState.Play || _core.State == PlaybackState.Pause)
    {
        return;
    }
}
```

Create audio output settings for desktop or disable for mobile platforms. `DeviceEnumerator` is used to get available audio output devices:

```
    // audio output
#if MOBILE
    _core.Audio_Play = false;
#else

    var audioOutputDevice = (await DeviceEnumerator.Shared.AudioOutputsAsync()).Where(device => device.DisplayName == btSpeakers.Text).First();
    _core.Audio_OutputDevice = new AudioRendererSettings(audioOutputDevice);
    _core.Audio_Play = true;
#endif
```

Create video source settings for the selected camera. `DeviceEnumerator` is used to get available video sources:

`VideoCaptureDeviceSourceSettings` allows you to specify device, format, and orientation. The `GetHDVideoFormatAndFrameRate` method is used to get the default HD available format and frame rate for the selected camera. Alternatively, you can enumerate all available formats and frame rates and let the user select them:

```
    // video source
    VideoCaptureDeviceSourceSettings videoSourceSettings = null;

    var deviceName = btCamera.Text;
    if (!string.IsNullOrEmpty(deviceName))
    {
        var device = (await DeviceEnumerator.Shared.VideoSourcesAsync()).FirstOrDefault(x => x.DisplayName == deviceName);
        if (device != null)
        {
            var formatItem = device.GetHDVideoFormatAndFrameRate(out var frameRate);
            if (formatItem != null)
            {
                videoSourceSettings = new VideoCaptureDeviceSourceSettings(device)
                {
                    Format = formatItem.ToFormat()
                };

                videoSourceSettings.Format.FrameRate = frameRate;
            }
        }
    }

    _core.Video_Source = videoSourceSettings;

#if __IOS__ && !__MACCATALYST__
    videoSourceSettings.Orientation = IOSVideoSourceOrientation.LandscapeRight;
#endif

    if (videoSourceSettings == null)
    {
        await DisplayAlert("Error", "Unable to configure camera settings", "OK");
    }
```

Create audio source settings for the selected microphone. `DeviceEnumerator` is used to get available audio sources:

```
    // audio source
    IVideoCaptureBaseAudioSourceSettings audioSourceSettings = null;

    deviceName = btMic.Text;
    if (!string.IsNullOrEmpty(deviceName))
    {
        var device = (await DeviceEnumerator.Shared.AudioSourcesAsync()).FirstOrDefault(x => x.DisplayName == deviceName);
        if (device != null)
        {
            var formatItem = device.GetDefaultFormat();
            audioSourceSettings = device.CreateSourceSettingsVC(formatItem);
        }
    }

    _core.Audio_Source = audioSourceSettings;
```

Configure output file settings. In this example, we use MP4 video and MP3 audio. The `Outputs_Add` second parameter is set to false to not start recording immediately.

By default, H264 GPU encoder is used for all platforms (.NET iOS, .NET Android, Windows, Mac Catalyst). As an alternative or on platforms where GPU encoding is not available, you can use a software encoder.

For audio stream, you can use MP3 or AAC encoders.

The SDK supports a wide range of video and audio formats and encoders across all .NET MAUI supported platforms.

```
    // configure capture
    _core.Audio_Record = true;

    _core.Outputs_Clear();
    _core.Outputs_Add(new MP4Output(GenerateFilename(), H264EncoderBlock.GetDefaultSettings(), new MP3EncoderSettings()), false);
```

Start the preview and update button label:

```
    // start
    await _core.StartAsync();

    btStartPreview.Text = "STOP";
}
```

Now we can implement Start preview, Start capture, and Stop buttons code:

```
private async void btStartPreview_Clicked(object sender, EventArgs e)
{
    if (_core == null)
    {
        return;
    }

    switch (_core.State)
    {
        case PlaybackState.Play:
            {
                await StopAllAsync();

                btStartPreview.Text = "PREVIEW";
                btStartCapture.IsEnabled = false;
            }

            break;
        case PlaybackState.Free:
            {
                if (_core.State == PlaybackState.Play || _core.State == PlaybackState.Pause)
                {
                    return;
                }

                await StartPreview();
                btStartCapture.IsEnabled = true;
            }

            break;
        default:
            break;
    }
}
```

The `StartCaptureAsync` method is used to start video capture. We use the `GenerateFilename` method to generate a unique filename for each video:

```
private async void btStartCapture_Clicked(object sender, EventArgs e)
{
    if (_core == null || _core.State != PlaybackState.Play)
    {
        return;
    }

    if (btStartCapture.BackgroundColor != Colors.Red)
    {
        System.Diagnostics.Debug.WriteLine("Start capture");
        await _core.StartCaptureAsync(0, GenerateFilename());
        btStartCapture.BackgroundColor = Colors.Red;
        btStartCapture.Text = "STOP";
    }
    else
    {
        await StopCaptureAsync();
    }
}

private string GenerateFilename()
{
    DateTime now = DateTime.Now;
#if __ANDROID__
    var filename = Path.Combine(Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryDcim).AbsolutePath, "Camera", $"visioforge_{now.Hour}_{now.Minute}_{now.Second}.mp4");
#elif __IOS__ && !__MACCATALYST__
    var filename = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "..",
                "Library", $"{now.Hour}_{now.Minute}_{now.Second}.mp4");
#elif __MACCATALYST__
    var filename = Path.Combine("/tmp", $"{now.Hour}_{now.Minute}_{now.Second}.mp4");
#else
    var filename = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyVideos), $"{now.Hour}_{now.Minute}_{now.Second}.mp4");
#endif

    return filename;
}
```

The `StopCaptureAsync` method is used to stop video capture and save the recording to the appropriate platform-specific location:

```
private async Task StopCaptureAsync()
{
    System.Diagnostics.Debug.WriteLine("Stop capture");
    await _core.StopCaptureAsync(0);
    btStartCapture.BackgroundColor = _defaultButtonColor;
    btStartCapture.Text = "CAPTURE";

    // save video to photo library on native iOS and Android platforms
#if __ANDROID__ || (__IOS__ && !__MACCATALYST__)
    string filename = null;
    var output = _core.Outputs_Get(0);
    filename = output.GetFilename();
    await PhotoGalleryHelper.AddVideoToGalleryAsync(filename);
#endif
}
```

## Video Effects and Enhancement Features

The VisioForge SDK for .NET supports a wide range of video effects across all .NET MAUI platforms, including text and image overlays, chroma key, and more, providing consistent functionality in iOS MAUI, Mac Catalyst, and .NET Android apps.

In this guide we'll add optional image and text overlays to the video.

Add the following code before the **\_core.StartAsync** method call to add text overlay:

```
var textOverlay = new OverlayManagerText("Hello world", x: 50, y: 50);
_core.Video_Overlay_Add(textOverlay);
```

Copy PNG or JPEG image to the assets folder and add the following code to add image overlay:

```
using var stream = await FileSystem.OpenAppPackageFileAsync("icon.png");
var bitmap = SkiaSharp.SKBitmap.Decode(stream);
var img = new OverlayManagerImage(bitmap, x: 250, y: 50);
_core.Video_Overlay_Add(img);
```

## Conclusion

This tutorial demonstrated how to integrate the VisioForge Video Capture SDK with .NET MAUI applications to create powerful cross-platform video capture solutions. The SDK provides consistent functionality across Windows, macOS (through Mac Catalyst), iOS, and Android platforms while leveraging native capabilities of each platform.

The SDK documentation provides more details on advanced features including:

- Additional video effects and filters
- Various video and audio codecs
- Network streaming
- Video analysis capabilities
- Custom processing pipelines

By using this SDK with .NET MAUI, developers can create sophisticated video applications with minimal platform-specific code while still maintaining the native look and feel on each platform.

---END OF PAGE---


## Motion Detection - Configurable Zones and Alerts in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/motion-detection/
**Description:** Add simple and advanced motion detection to webcam or IP camera streams with VisioForge Video Capture SDK. Configurable zones, sensitivity, and C# examples.
**Tags:** Video Capture SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture
**API:** MotionDetectionSettings, MotionDetectionExSettings

# Motion Detection for Video Processing

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Overview

The Video Capture SDK provides powerful motion detection capabilities for your .NET applications. Whether you need simple presence detection or advanced object tracking, the SDK offers two distinct motion detector implementations to match your specific requirements:

1. **Simple Motion Detector** - Efficient, lightweight processing with customizable detection matrices
2. **Advanced Motion Detector** - Enhanced capabilities including object detection, multiple processor types, and specialized detectors

These motion detection tools enable developers to implement sophisticated video analysis features such as security monitoring, automated alerts, object counting, and interactive motion-responsive applications.

## Simple Motion Detector

[VideoCaptureCore](#)

### How It Works

The simple motion detector offers an efficient solution for basic movement detection scenarios. Its streamlined approach makes it ideal for applications where processing speed and resource efficiency are priorities.

When activated, the detector:

- Processes each frame to detect movement changes
- Generates a two-dimensional byte array (motion matrix)
- Calculates the overall motion level as a percentage
- Optionally highlights detected motion areas visually

### Key Features

- **Customizable Matrix Size**: Adjust detection resolution to balance performance and accuracy
- **Channel Selection**: Analyze all RGB channels or focus on specific ones for optimized detection
- **Motion Highlighting**: Visually emphasize detected motion with color overlays
- **Performance Optimization**: Configure frame interval settings to manage processing load

### Implementation Example

```
// create motion detector settings
var motionDetector = new MotionDetectionSettings();

// set the motion detector matrix dimensions
motionDetector.Matrix_Width = 10;
motionDetector.Matrix_Height = 10;

// configure color channel analysis
motionDetector.Compare_Red = false;
motionDetector.Compare_Green = false;
motionDetector.Compare_Blue = false;
motionDetector.Compare_Greyscale = true;

// motion highlighting configuration
motionDetector.Highlight_Color = MotionCHLColor.Green;
motionDetector.Highlight_Enabled = true;

// performance optimization settings
motionDetector.FrameInterval = 5;
motionDetector.DropFrames_Enabled = false;

// enable detection (default is false — required for OnMotion events to fire)
motionDetector.Enabled = true;

// apply settings to the video capture component
VideoCapture1.Motion_Detection = motionDetector;
VideoCapture1.MotionDetection_Update();
```

### Retrieving Motion Data

Subscribe to the `OnMotion` event (type: `EventHandler<MotionDetectionEventArgs>`) before starting the pipeline. The handler fires once per frame when motion is detected:

```
VideoCapture1.OnMotion += (sender, e) =>
{
    // e.Level  — overall motion intensity (int, typically 0-100).
    // e.Matrix — byte[] grid overlay; each cell holds the motion amount for that region.
    if (e.Level > 25)
    {
        Console.WriteLine($"Motion level {e.Level}% — {e.Matrix?.Length ?? 0} grid cells");
        // Trigger recording, push an alert, enqueue a snapshot, etc.
    }
};
```

Events are raised on a background thread — marshal to the UI thread (`Dispatcher`/`Invoke`) before touching UI controls.

## Advanced Motion Detector

[VideoCaptureCoreX](#) [VideoCaptureCore](#)

### Enhanced Capabilities

The advanced motion detector provides more sophisticated detection algorithms and analysis options. This detector is designed for applications requiring detailed motion information, object identification, and precise motion area definition.

Key advantages include:

- Object detection and counting
- Multiple processor types for different visual analysis needs
- Specialized detector algorithms for various environments
- Enhanced motion area processing

### Configuration Options

#### Motion Processor Types

The processor determines how motion is analyzed and visualized:

- **None**: Raw detection without visual highlighting
- **BlobCountingObjects**: Identifies and counts distinct moving objects
- **GridMotionAreaProcessing**: Divides frame into grid sections for analysis
- **MotionAreaHighlighting**: Highlights full areas where motion is detected
- **MotionBorderHighlighting**: Outlines the perimeter of motion areas

#### Motion Detector Types

The detector algorithm defines the fundamental approach to motion identification:

- **CustomFrameDifference**: Compares current frame against a predefined background
- **SimpleBackgroundModeling**: Uses adaptive background modeling techniques
- **TwoFramesDifference**: Analyzes differences between consecutive frames

### Implementation Steps

1. Create the advanced motion detector settings:

```
var motionDetector = new MotionDetectionExSettings();
```

1. Select the appropriate processor type for your application needs:

```
motionDetector.ProcessorType = MotionProcessorType.BlobCountingObjects;
```

1. Choose the detection algorithm that best suits your environment:

```
motionDetector.DetectorType = MotionDetectorType.CustomFrameDifference;
```

1. Apply the settings to your video capture component:

VideoCaptureCoreXVideoCaptureCore

```
VideoCapture1.Motion_Detection = motionDetector;
```

```
VideoCapture1.Motion_DetectionEx = motionDetector;
```

1. Implement the corresponding event handler to receive detection data. Both events carry `MotionDetectionExEventArgs` with `Level` (float), `LevelPercent` (0-100 int), `ObjectsCount`, `ObjectRectangles` (`Rect[]`), and `MotionGrid` (`float[,]`):

   VideoCaptureCoreXVideoCaptureCore

   ```
   VideoCapture1.OnMotionDetection += (sender, e) =>
   {
       if (e.LevelPercent > 25)
       {
           Console.WriteLine($"Motion {e.LevelPercent}% — {e.ObjectsCount} moving objects");
           foreach (var rect in e.ObjectRectangles)
           {
               Console.WriteLine($"  at {rect}");
           }
       }
   };
   ```

   ```
   VideoCapture1.OnMotionDetectionEx += (sender, e) =>
   {
       if (e.LevelPercent > 25)
       {
           Console.WriteLine($"Motion {e.LevelPercent}% — {e.ObjectsCount} moving objects");
       }
   };
   ```

   Handlers run on a worker thread — marshal to the UI thread before updating controls.

## Practical Applications

Motion detection capabilities enable developers to create powerful video-processing applications:

- **Security Systems**: Trigger recording or alerts when unauthorized movement is detected
- **Traffic Analysis**: Count and track vehicles or pedestrians
- **Interactive Installations**: Create motion-responsive digital experiences
- **Automated Video Indexing**: Mark and categorize sections containing activity
- **Industrial Automation**: Monitor production lines or restricted areas
- **Wildlife Observation**: Record animal activity without human intervention

## Performance Considerations

To optimize motion detection performance:

1. Adjust the matrix dimensions to balance accuracy and processing load
2. Use frame interval settings to analyze only essential frames
3. Select the appropriate color channels for your detection scenario
4. Consider enabling the frame dropping option for high-performance requirements
5. Choose the detector type based on your specific environment conditions

## Advanced Configuration

The advanced `MotionDetectionExSettings` class (used by `VideoCaptureCoreX` via `Motion_Detection` / by classic `VideoCaptureCore` via `Motion_DetectionEx`) exposes these additional properties:

- `DifferenceThreshold` — per-pixel difference threshold to filter out minor movements
- `MinObjectsWidth` / `MinObjectsHeight` — ignore detected objects below these dimensions
- `SuppressNoise` — noise-suppression filter to reduce false positives
- `HighlightMotionRegions` — draw bounding rectangles around detected object regions
- `KeepObjectsEdges` — preserve sharp edges when highlighting
- `HighlightColor` (SKColor) — color used for motion highlighting

## Event Integration

The motion detection events can be integrated with other SDK features:

- Video recording to capture detected motion
- Snapshot creation when motion is detected
- Custom notification systems
- Data logging and analysis

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Network Streaming in C# .NET — RTSP, RTMP, NDI, SRT
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/network-streaming/
**Description:** Stream live video over RTSP, RTMP, NDI, HLS, and SRT from VisioForge Video Capture SDK. Protocol setup, encoder config, and C# code examples.
**Tags:** Video Capture SDK, Media Blocks SDK, Video Edit SDK, .NET, Windows, macOS, Linux, Android, iOS, Streaming

# Network Streaming in .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Video Edit SDK .Net](https://www.visioforge.com/video-edit-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

## Introduction to Network Streaming

Network streaming has become a fundamental component of modern digital communication infrastructure, enabling real-time transmission of audio and video data across diverse network environments. As bandwidth capabilities continue to expand and user expectations for content delivery evolve, developers need robust tools to implement streaming solutions that balance performance, quality, and reliability.

The VisioForge Video Capture SDK for .NET provides comprehensive support for multiple streaming protocols, offering developers a versatile toolkit for integrating sophisticated streaming capabilities into their applications. Whether you're building live broadcasting platforms, video conferencing tools, surveillance systems, or content delivery networks, this SDK provides the foundation for implementing professional-grade streaming solutions.

## Quick Start — RTMP streaming with VideoCaptureCoreX

The shortest end-to-end path: pick a capture device, add an RTMP output block to the engine, start. Swap `RTMPOutput` for `YouTubeOutput`, `FacebookLiveOutput`, `RTSPServerOutput`, or `HLSOutput` to target other destinations — the surrounding wiring stays the same.

```
using VisioForge.Core;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.VideoCaptureX;

// 1. Initialise the cross-platform engine once per process.
VisioForgeX.InitSDK();

// 2. Create the engine, bound to an IVideoView (or null for headless).
var videoCapture = new VideoCaptureCoreX(videoView as IVideoView);

// 3. Select the first enumerated capture device + mic.
var videoDevice = (await DeviceEnumerator.Shared.VideoSourcesAsync()).First();
var audioDevice = (await DeviceEnumerator.Shared.AudioSourcesAsync()).First();

videoCapture.Video_Source = new VideoCaptureDeviceSourceSettings(videoDevice);
videoCapture.Audio_Source = new AudioCaptureDeviceSourceSettings(audioDevice);
videoCapture.Audio_Record = true;

// 4. Add an RTMP output. The string is the full ingest URL including stream key.
var rtmpOutput = new RTMPOutput("rtmp://live.example.com/app/<stream-key>");
videoCapture.Outputs_Add(rtmpOutput, true);

// 5. Start. OnError fires on network / encoder failures.
await videoCapture.StartAsync();
```

For per-protocol configuration (encoder tuning, buffer sizes, authentication, adaptive bitrates, etc.) see the dedicated pages under [Available Protocols](#available-protocols) below.

## Core Network Streaming Protocols

### RTSP (Real-Time Streaming Protocol)

RTSP is an application-level protocol designed for controlling the delivery of data with real-time properties. It serves as a "network remote control" for multimedia servers, establishing and controlling media sessions between endpoints.

#### Key RTSP Features:

- **Session Control**: Enables clients to establish and manage media sessions with servers
- **Transport Independence**: Works with various transport protocols including UDP, TCP, and multicast UDP
- **Command Support**: Implements commands like PLAY, PAUSE, and RECORD for granular session control
- **Scalability**: Supports unicast and multicast delivery for efficient bandwidth utilization

### RTMP (Real-Time Messaging Protocol)

Originally developed by Macromedia for streaming Flash content, RTMP has evolved into one of the most widely used protocols for live broadcasting. It maintains persistent connections between the client and server, facilitating low-latency transmission crucial for interactive applications.

#### Key RTMP Features:

- **Low Latency**: Typically delivers sub-second latency, making it suitable for interactive streaming
- **Reliable Delivery**: Uses TCP as its transport layer for reliable packet delivery
- **Content Protection**: Supports encryption for secure content delivery
- **Widespread Support**: Compatible with numerous CDNs and streaming platforms

### NDI (Network Device Interface)

NDI represents a significant advancement in professional video production workflows, enabling high-quality, low-latency video transmission over standard IP networks. Developed by NewTek, NDI has gained widespread adoption in broadcast and production environments.

#### Key NDI Features:

- **IP-Based Workflow**: Leverages existing network infrastructure without specialized hardware
- **Bidirectional Communication**: Supports metadata and control data alongside audio/video
- **Discovery Mechanism**: Automatic device and source discovery on local networks
- **High-Quality Encoding**: Maintains visual quality while optimizing for network conditions

### HLS (HTTP Live Streaming)

Developed by Apple, HLS has become one of the most widely supported streaming protocols. It segments content into small HTTP-based file downloads, allowing adaptive bitrate streaming that adjusts quality based on the viewer's available bandwidth.

#### Key HLS Features:

- **Adaptive Bitrate**: Dynamically adjusts stream quality based on network conditions
- **Wide Compatibility**: Supported across most modern browsers and devices
- **HTTP Delivery**: Uses standard web servers and CDNs for efficient content delivery
- **Content Protection**: Supports encryption and DRM integration

### SRT (Secure Reliable Transport)

SRT is an open-source protocol optimized for delivering high-quality, low-latency video over unpredictable networks. It combines the reliability of TCP with the speed of UDP while adding security features.

#### Key SRT Features:

- **Packet Loss Recovery**: Implements dynamic retransmission mechanisms
- **Encryption**: Built-in AES encryption for secure transmission
- **Network Health Monitoring**: Continually assesses connection quality
- **Latency Control**: Configurable latency settings to balance reliability and delay

## Additional Supported Protocols

### HTTP MJPEG (Motion JPEG)

MJPEG over HTTP transmits a sequence of JPEG images, providing a simple yet effective streaming solution. While not as bandwidth-efficient as modern codecs, its simplicity and compatibility make it suitable for certain applications.

### UDP (User Datagram Protocol)

UDP streaming prioritizes speed over reliability, making it ideal for real-time applications where occasional packet loss is preferable to increased latency. The SDK provides configurable buffer settings to help optimize UDP streaming for specific network conditions.

### WMV (Windows Media Video)

The SDK supports streaming in Microsoft's WMV format, which remains relevant for certain Windows-centric applications and legacy systems integration.

### Platform-Specific Streaming

The SDK also integrates with popular streaming platforms including:

- **YouTube Live**: Direct streaming to YouTube channels
- **Facebook Live**: Integrated Facebook Live broadcasting
- **AWS S3**: Cloud-based media distribution via Amazon Web Services

## Implementation Considerations

When implementing network streaming with the SDK, developers should consider:

1. **Bandwidth Requirements**: Estimate and test the required bandwidth for your target quality and framerate
2. **Network Resilience**: Implement appropriate error handling and reconnection logic
3. **Quality vs. Latency**: Balance visual quality against latency requirements
4. **Cross-Platform Compatibility**: Select protocols based on your target platforms
5. **Security Needs**: Implement encryption and authentication where required

## Conclusion

The VisioForge Video Capture SDK for .NET provides comprehensive support for contemporary streaming protocols, empowering developers to implement sophisticated streaming solutions without managing the complexity of protocol implementations directly. From low-latency live broadcasts to secure content delivery, the SDK's streaming capabilities address diverse use cases across industries.

By leveraging these capabilities, developers can focus on building compelling experiences while relying on the SDK to handle the technical challenges of reliable network streaming. Whether you're developing applications for entertainment, education, security, or professional video production, the SDK provides a solid foundation for your streaming needs.

## Available Protocols

- [Adobe Flash Server](../../general/network-streaming/adobe-flash/)
- [AWS S3](../../general/network-streaming/aws-s3/)
- [Facebook](../../general/network-streaming/facebook/)
- [HLS](../../general/network-streaming/hls-streaming/)
- [HTTP MJPEG](../../general/network-streaming/http-mjpeg/)
- [NDI](../../general/network-streaming/ndi/)
- [RTMP](../../general/network-streaming/rtmp/)
- [RTSP](../../general/network-streaming/rtsp/)
- [SRT](../../general/network-streaming/srt/)
- [UDP](../../general/network-streaming/udp/)
- [WMV](../../general/network-streaming/wmv/)
- [YouTube](../../general/network-streaming/youtube/)

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## DV Camcorder Video Capture via FireWire in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-capture/dv/
**Description:** Capture DV camcorder video in .NET with direct and recompressed modes using VisioForge Video Capture SDK. Type-1/Type-2 DV format handling and C# examples.
**Tags:** Video Capture SDK, .NET, VideoCaptureCore, Windows, Capture, Webcam, DV Camera, AVI, C#, NuGet
**API:** DVOutput, VideoCaptureMode, DirectCaptureDVOutput

# Capturing Video to DV Format in .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [VideoCaptureCore](#)

DV (Digital Video) is a professional-grade digital video format widely used in the broadcasting and film industry. Originally developed for camcorders, DV provides exceptional quality while maintaining reasonable file sizes, making it suitable for both consumer and professional video production environments.

## Understanding DV Format

DV format offers several advantages for video capture applications:

- **High-quality video** with minimal compression artifacts
- **Consistent frame rate** suitable for broadcast standards
- **Efficient compression** with predictable file sizes
- **Industry-standard compatibility** across editing platforms
- **Frame-accurate editing** capabilities

DV streams are typically stored either directly on tape (in traditional DV camcorders) or as digital files using containers like AVI or MKV. The format uses a specific codec for video compression along with PCM audio, creating a reliable standard for video production workflows.

## Implementation Options

When implementing DV capture in your .NET applications, you have two primary approaches:

1. **Direct capture without recompression** - Requires a DV/HDV camcorder that outputs native DV
2. **Capture with recompression** - Works with any video source but requires processing power

Each method has specific hardware requirements and performance considerations that will be covered in detail below.

## Setting Up Your Development Environment

Before implementing DV capture functionality, ensure your development environment includes:

1. The VideoCaptureCore component from the Video Capture SDK
2. Proper video capture device drivers
3. Required runtime redistributables (detailed at the end of this document)

## Direct DV Capture Without Recompression

This method provides the highest quality output with minimal processing overhead, but requires specialized hardware.

### Hardware Requirements

To capture DV without recompression, you'll need:

- A DV or HDV camcorder with FireWire (IEEE 1394) output
- A compatible FireWire port on your capture system
- Sufficient disk speed to handle the DV data stream (approximately 3.6 MB/s)

### Implementation Steps

#### Step 1: Configure the Video Capture Device

First, ensure your DV camcorder is properly connected and recognized by the system. The device should appear in the available capture devices list.

```
// Select your DV camcorder from the available devices
VideoCapture1.Video_CaptureDevice = ...
```

#### Step 2: Set DV as Output Format

Configure the output format to use direct DV capture without recompression:

```
VideoCapture1.Output_Format = new DirectCaptureDVOutput();
```

#### Step 3: Configure Capture Mode and Output File

Specify the capture mode and destination file:

```
VideoCapture1.Mode = VideoCaptureMode.VideoCapture;
VideoCapture1.Output_Filename = "captured_footage.avi";
```

#### Step 4: Start the Capture Process

Initiate the capture process either synchronously or asynchronously:

```
// Asynchronous capture (recommended for UI applications)
await VideoCapture1.StartAsync();

// Or synchronous capture (for console applications)
// VideoCapture1.Start();
```

#### Step 5: Stop Capture When Finished

When the desired footage has been captured:

```
await VideoCapture1.StopAsync();
```

## DV Capture With Recompression

This method allows you to use any video source to create DV-compatible files, though it requires more processing power.

### Hardware Considerations

For recompression-based DV capture, you'll need:

- Any compatible video capture device (webcam, capture card, etc.)
- Sufficient CPU processing power for real-time DV encoding
- Adequate system memory for buffer processing

### Implementation Process

#### Step 1: Configure Your Video Source

Select and configure any supported video capture device:

```
// Select video source
VideoCapture1.Video_CaptureDevice = ...

// Configure audio source (if separate)
VideoCapture1.Audio_CaptureDevice = ...
```

#### Step 2: Configure DV Output Parameters

Create and configure a DVOutput object with appropriate settings:

```
var dvOutput = new DVOutput();

// Audio configuration
dvOutput.Audio_Channels = 2;
dvOutput.Audio_SampleRate = 44100;

// Video format - PAL (Europe/Asia) or NTSC (North America/Japan)
dvOutput.Video_Format = DVVideoFormat.PAL;
// Alternatively: DVVideoFormat.NTSC

// Use Type 2 DV file format (recommended for most applications)
dvOutput.Type2 = true;

// Apply the configuration
VideoCapture1.Output_Format = dvOutput;
```

#### Step 3: Set Capture Mode and Output File

```
VideoCapture1.Mode = VideoCaptureMode.VideoCapture;
VideoCapture1.Output_Filename = "recompressed_footage.avi";
```

#### Step 4: Initiate and Manage Capture

```
// Start capture
await VideoCapture1.StartAsync();

// Stop capture when done
await VideoCapture1.StopAsync();
```

### Custom Audio Settings

While DV typically uses 48 kHz audio, you can configure alternative settings:

```
dvOutput.Audio_SampleRate = 48000; // Professional standard
dvOutput.Audio_Channels = 2;       // Stereo
// Note: DVOutput exposes only Audio_SampleRate + Audio_Channels;
// bit depth is fixed by the DV format itself and is not a configurable property.
```

## Error Handling and Troubleshooting

Implement proper error handling to manage common DV capture issues:

```
VideoCapture1.OnError += (sender, args) =>
{
    // Log error details
    LogError($"Capture error: {args.Message}");

    // Safely stop capture if needed
    try
    {
        VideoCapture1.Stop();
    }
    catch
    {
        // Handle secondary exceptions
    }

    // Notify user
    NotifyUser("Capture stopped due to an error. Check logs for details.");
};
```

## Performance Optimization Tips

To ensure smooth DV capture performance:

1. **Disk speed**: Use SSDs or high-performance HDDs for capture storage
2. **Memory allocation**: Increase buffer size for more stable capture
3. **CPU priority**: Consider increasing the process priority for capture operations
4. **Background processes**: Minimize other activities during capture
5. **Dropped frames**: Monitor and log frame drops to identify bottlenecks

## Required Redistributables

To deploy your DV capture application, include the following redistributables:

- Video capture redistributables:
- [x86 version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/)
- [x64 version](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)

## Conclusion

Implementing DV capture in your .NET applications provides a professional-grade video acquisition solution with excellent quality and compatibility. Whether using direct capture from DV devices or recompression from standard sources, the SDK provides flexible options to meet your requirements.

For further information and sample implementations, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) containing additional code examples and integration patterns.

---END OF PAGE---


## Video Recording Formats and Encoder Options in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-capture/
**Description:** Record to MP4, AVI, WMV, WebM, and MKV with VisioForge Video Capture SDK. H.264, H.265, MJPEG encoders and GPU-accelerated encoding in .NET apps.
**Tags:** Video Capture SDK, .NET, DirectShow, Streaming

# Video Capture SDK for .NET Developers

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Introduction

Our Video Capture SDK for .NET equips developers with a powerful, versatile solution for implementing professional-grade video recording capabilities in their applications. Designed specifically for .NET environments, this SDK provides seamless integration with your existing codebase while delivering exceptional performance and reliability.

## Quick Start — Record webcam to MP4

Minimum end-to-end path with `VideoCaptureCoreX` (cross-platform). Swap the `MP4Output` for `MKVOutput` / `WebMOutput` / `MOVOutput` to switch container, or for `RTSPServerOutput` / `RTMPOutput` / `HLSOutput` to stream instead of record — the surrounding wiring stays the same.

```
using VisioForge.Core;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.VideoCaptureX;

// 1. Initialise the cross-platform engine once per process.
VisioForgeX.InitSDK();

// 2. Create the engine, bound to an IVideoView for preview (or null for headless).
var videoCapture = new VideoCaptureCoreX(videoView as IVideoView);

// 3. Select first enumerated camera + microphone.
var videoDevice = (await DeviceEnumerator.Shared.VideoSourcesAsync()).First();
var audioDevice = (await DeviceEnumerator.Shared.AudioSourcesAsync()).First();
videoCapture.Video_Source = new VideoCaptureDeviceSourceSettings(videoDevice);
videoCapture.Audio_Source = new AudioCaptureDeviceSourceSettings(audioDevice);
videoCapture.Audio_Record = true;

// 4. Add an MP4 output. Defaults to H.264 + AAC.
videoCapture.Outputs_Add(new MP4Output("output.mp4"), true);

// 5. Start. OnError fires on pipeline errors.
await videoCapture.StartAsync();
```

## Key Capabilities

- **Multi-source capture** - Record from webcams, capture cards, and other video devices
- **Real-time processing** - Apply filters and effects during capture
- **Customizable quality settings** - Control bitrate, framerate, and resolution
- **Event-driven architecture** - Respond to capture events in your application
- **Multi-platform support** - Works across Windows desktop environments

## Extensive Format Support

Our SDK supports a comprehensive range of output formats to meet diverse project requirements, ensuring your applications can deliver video in exactly the format your users need:

### Standard Video Formats

- [MP4 (H.264/AAC)](../../general/output-formats/mp4/) - Industry standard format offering excellent compatibility across devices and platforms, ideal for distribution and streaming applications
- [WebM](../../general/output-formats/webm/) - Open-source format optimized for web applications with efficient compression and broad browser support
- [AVI](../../general/output-formats/avi/) - Classic container format with widespread compatibility and minimal processing overhead, supporting virtually any DirectShow-compatible codec
- [WMV](../../general/output-formats/wmv/) - Microsoft's video format providing good compression ratios and integration with Windows environments

### Professional & Broadcast Formats

- [MKV (Matroska)](../../general/output-formats/mkv/) - Flexible container format supporting multiple audio, video, and subtitle tracks, ideal for archiving and high-quality storage
- [MOV (QuickTime)](../../general/output-formats/mov/) - Apple's container format widely used in professional video editing and production workflows
- [MPEG-TS (Transport Stream)](../../general/output-formats/mpegts/) - Format optimized for broadcasting and streaming applications with robust error correction
- [MXF (Material Exchange Format)](../../general/output-formats/mxf/) - Professional video production format used in broadcast and post-production environments

### Specialized Output Options

- [GIF (Graphics Interchange Format)](../../general/output-formats/gif/) - Perfect for creating short, looping animations with wide web compatibility
- [DV (Digital Video)](dv/) - Professional-grade format commonly used with digital camcorders, preserving high-quality video for editing workflows
- [FFMPEG Integration](../../general/output-formats/ffmpeg-exe/) - Advanced encoding options leveraging the powerful FFMPEG library for specialized encoding requirements
- [Custom Output Solutions](../../general/output-formats/custom/) - Create your own format specifications and processing pipelines for unique application needs

### Hardware-Optimized Capture

- [MPEG-2 Camcorder Integration](mpeg2-camcorder/) - Direct capture from digital camcorders with hardware-optimized encoding for maximum efficiency
- [MPEG-2 TV Tuner with Hardware Encoding](mpeg2-tvtuner/) - Specially optimized for television capture devices, utilizing hardware acceleration when available

## Advanced Video Encoders

Our SDK incorporates multiple advanced video encoders to provide optimal compression efficiency and performance for different capture scenarios:

### Modern High-Efficiency Encoders

- [H.264 (AVC)](../../general/video-encoders/h264/) - Industry-standard encoder offering excellent compatibility and multiple hardware acceleration options from NVIDIA, AMD, and Intel
- [HEVC (H.265)](../../general/video-encoders/hevc/) - Next-generation encoder providing ~50% better compression than H.264 with support for 4K and HDR content
- [AV1](../../general/video-encoders/av1/) - Royalty-free open standard delivering superior compression efficiency, ideal for web streaming applications

### Specialized & Legacy Encoders

- [MJPEG](../../general/video-encoders/mjpeg/) - Motion JPEG encoder providing low-latency frame-by-frame compression with hardware and software implementations
- [VP8/VP9](../../general/video-encoders/vp8-vp9/) - Google's open-source codecs offering competitive quality-to-bitrate ratios for WebM containers

### Hardware Acceleration Support

Our encoders support hardware acceleration from major vendors:

- **NVIDIA NVENC** - GPU-accelerated encoding with minimal CPU usage
- **AMD AMF** - Advanced Media Framework for efficient AMD GPU encoding
- **Intel QuickSync** - Intel's hardware-accelerated video processing
- **Software Fallbacks** - Comprehensive software implementations when hardware acceleration isn't available

For detailed encoder specifications, configuration options, and performance comparisons, visit our [Video Encoders Guide](../../general/video-encoders/).

## Advanced Implementation Techniques

- [Concurrent Preview and Capture](separate-capture/) - Implement simultaneous preview and recording functionality for improved user experience
- **Memory Optimization** - Best practices for managing memory during long recording sessions
- **Thread Management** - Guidelines for proper threading to ensure responsive applications

## Developer Resources

For additional implementation examples, detailed documentation, and sample code, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## MPEG-2 Camcorder Capture with Hardware Encoder in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-capture/mpeg2-camcorder/
**Description:** Record camcorder video to MPEG-2 format in .NET with VisioForge Video Capture SDK. Hardware encoder configuration and C# implementation examples.
**Tags:** Video Capture SDK, .NET, VideoCaptureCore, Windows, Capture, Encoding, MPEG-2, C#, NuGet
**API:** DirectCaptureMPEGOutput, VideoCaptureCore, VideoCaptureMode, PlaybackState

# Capturing Camcorder Video to MPEG-2 Format

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [VideoCaptureCore](#)

## Introduction

MPEG-2 remains a reliable video encoding standard widely used in professional video workflows. This guide shows how to implement camcorder-to-MPEG-2 capture functionality in your .NET applications.

MPEG-2 (Moving Picture Experts Group 2) was established in 1995 as an industry standard for digital video and audio encoding. Despite newer formats, MPEG-2 continues to be valued for its optimal balance between compression efficiency and video quality, making it particularly suitable for applications requiring high fidelity video capture from camcorders.

## Why Use MPEG-2 for Camcorder Capture?

MPEG-2 offers several advantages for developers implementing camcorder capture functionality:

- **Widespread compatibility** with video editing software and playback devices
- **Efficient compression** that preserves visual quality at reasonable file sizes
- **Robust handling** of interlaced video content (common in camcorders)
- **Industry standard** that ensures long-term support and compatibility
- **Lower processing requirements** compared to more complex modern codecs

## Implementation Guide

### Required Dependencies

Before implementing camcorder-to-MPEG-2 capture, ensure your project includes:

- Video Capture SDK .NET (VideoCaptureCore component)
- Video capture redistributables:
- [x86 package](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/)
- [x64 package](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)

Install these packages using NuGet Package Manager:

```
Install-Package VisioForge.DotNet.Core.Redist.VideoCapture.x64
```

### Basic Implementation

The following code demonstrates how to set up and execute a basic camcorder-to-MPEG-2 capture:

```
// Initialize video capture component. VideoCaptureCore requires an IVideoView
// (WinForms VideoView control, WPF VideoView, etc.) to host the preview window.
using var videoCapture = new VideoCaptureCore(VideoView1 as IVideoView);

// Configure MPEG-2 output format
videoCapture.Output_Format = new DirectCaptureMPEGOutput();

// Specify capture mode
videoCapture.Mode = VideoCaptureMode.VideoCapture;

// Set output file path
videoCapture.Output_Filename = "captured_video.mpg";

// Begin capture process (asynchronously)
await videoCapture.StartAsync();

// ... Additional code to manage the capture process

// Stop capture when complete
await videoCapture.StopAsync();
```

### Selecting Input Devices

To ensure your application captures from the correct camcorder:

```
// List available video input devices (Video_CaptureDevices is a method, not a property)
foreach (var device in videoCapture.Video_CaptureDevices())
{
    Console.WriteLine($"Device: {device.Name}");
}

// Select a specific camcorder and format
videoCapture.Video_CaptureDevice = ...
```

## Advanced Features

### Audio Configuration

Configure audio settings for optimal results:

```
// List available audio devices (Audio_CaptureDevices is a method, not a property)
foreach (var device in videoCapture.Audio_CaptureDevices())
{
    Console.WriteLine($"Audio device: {device.Name}");
}

// Select specific audio device and format
videoCapture.Audio_CaptureDevice = ...
```

### Event Handling

Monitor and respond to events:

```
// Subscribe to status change events
videoCapture.OnError += (sender, args) =>
{
    Console.WriteLine($"Error: {args.Message}");
};
```

### Memory Management

Ensure proper resource cleanup:

```
// Implement proper disposal. State() is a method that returns PlaybackState
// (Free | Play | Pause) — there is no VideoCaptureState enum.
public async Task StopAndDisposeCapture()
{
    if (videoCapture != null)
    {
        if (videoCapture.State() == PlaybackState.Play)
        {
            await videoCapture.StopAsync();
        }

        videoCapture.Dispose();
    }
}
```

## Troubleshooting

If you encounter issues with your MPEG-2 camcorder capture:

1. **Verify device compatibility** - Ensure your camcorder is properly recognized
2. **Check driver installation** - Update to the latest device drivers
3. **Monitor system resources** - Capture can be resource-intensive
4. **Inspect connection quality** - USB or FireWire issues can affect stability
5. **Test with different resolutions** - Lower resolutions may perform better

## Conclusion

Implementing MPEG-2 capture from camcorders provides a reliable solution for applications requiring high-quality video capture with broad compatibility. By following the techniques outlined in this guide, developers can create robust video capture functionality that maintains the balance between quality and efficiency that MPEG-2 is known for.

For more advanced usage scenarios and detailed examples, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) containing additional code samples and implementation guides.

---END OF PAGE---


## TV Tuner MPEG-2 Hardware Capture and Recording in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-capture/mpeg2-tvtuner/
**Description:** Capture TV tuner video to MPEG-2 using hardware encoders in VisioForge Video Capture SDK. Step-by-step C# guide for WPF, WinForms, and Console apps.
**Tags:** Video Capture SDK, .NET, VideoCaptureCore, Windows, Capture, Streaming, Encoding, TV Tuner, MPEG-2, C#, NuGet
**API:** DirectCaptureMPEGOutput, SpecialFilterType, VideoCaptureMode

# MPEG-2 Video Capture Using TV Tuner Hardware Encoder in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [VideoCaptureCore](#)

## Introduction to MPEG-2 Video Capture

MPEG-2, introduced in 1995, revolutionized digital video as a standard for "the generic coding of moving pictures and associated audio information." This format remains widely implemented across multiple platforms including digital television broadcasting, DVD video, and various streaming applications. Despite being an older standard, MPEG-2 continues to be relevant in specific broadcast scenarios due to its balance of quality and efficiency.

The ability to capture video directly to MPEG-2 format using hardware encoders provides significant advantages for developers building media applications. Hardware encoding offloads intensive processing from the CPU, resulting in better system performance and more efficient battery usage on portable devices.

## Why Use Hardware-Accelerated MPEG-2 Encoding?

Hardware encoding offers several distinct advantages for video capture applications:

1. **Reduced CPU Usage**: By utilizing dedicated encoding hardware, your application can maintain responsive performance while capturing video
2. **Improved Battery Life**: Critical for portable applications where energy efficiency matters
3. **Real-Time Encoding**: Hardware encoders can process high-resolution video in real-time
4. **Consistent Quality**: Hardware encoders deliver reliable encoding performance

TV tuners with built-in MPEG-2 hardware encoders are particularly valuable for applications that need to capture broadcast content efficiently. These devices handle both the tuning and encoding processes, simplifying your application architecture.

## Implementation Guide

This guide walks through implementing MPEG-2 video capture using TV tuners with internal MPEG encoders in .NET applications. The code examples work across WPF, WinForms, and console applications.

### Prerequisites

Before implementing MPEG-2 video capture, ensure you have:

- Installed the Video Capture SDK .Net
- A compatible TV tuner device with internal MPEG-2 encoding capability
- Properly configured redist packages for your target platform
- Basic understanding of video capture concepts in .NET

### Device Configuration

[First, configure the video capture device](../../video-sources/video-capture-devices/) using the standard procedures. This includes selecting the correct input device and configuring basic video parameters.

The TV tuner must be properly installed and recognized by your operating system before it can be accessed by your application. Use the Windows Device Manager to verify the device is correctly installed and functioning.

### Step 1: Enumerate Available MPEG-2 Hardware Encoders

Your first task is to discover which MPEG-2 hardware encoders are available in the system. This allows users to select the appropriate encoder for their needs:

```
// Get all hardware video encoders available on the system
foreach (var specialFilter in VideoCapture1.Special_Filters(SpecialFilterType.HardwareVideoEncoder))
{
  // Add each encoder to a dropdown or selection list
  cbMPEGEncoder.Items.Add(specialFilter);
}
```

This code enumerates all hardware video encoders and populates a selection interface element, allowing users to choose their preferred encoding device.

### Step 2: Select the MPEG-2 Encoder

Once the user has selected a hardware encoder, set it as the active encoder for the capture session:

```
// Apply the selected MPEG-2 encoder to the video capture device
VideoCapture1.Video_CaptureDevice.InternalMPEGEncoder_Name = cbMPEGEncoder.Text;
```

This line configures the video capture component to use the hardware encoder selected by the user. The `InternalMPEGEncoder_Name` property accepts the name of the encoder device exactly as returned by the `Special_Filters` enumeration.

### Step 3: Configure DirectCapture MPEG Output

Next, configure the output format to use DirectCapture MPEG, which optimizes the capture pipeline for hardware-encoded MPEG-2:

```
// Set the output format for MPEG-2 capture
VideoCapture1.Output_Format = new DirectCaptureMPEGOutput();
```

The `DirectCaptureMPEGOutput` class handles the specific requirements for MPEG-2 formatted output, including proper container formatting and stream multiplexing.

### Step 4: Set Video Capture Mode and Start Capturing

Finally, configure the capture mode, specify the output filename, and start the capture process:

```
// Configure the capture mode for video recording
VideoCapture1.Mode = VideoCaptureMode.VideoCapture;

// Set the output filename for the captured MPEG-2 file
VideoCapture1.Output_Filename = "output.mpg";

// Start the asynchronous capture process
await VideoCapture1.StartAsync();
```

The `StartAsync` method begins the capture process asynchronously, allowing your application to remain responsive during capture.

### Audio Configuration

Proper audio configuration is essential for complete MPEG-2 capture. Most TV tuners with MPEG-2 encoders will handle audio automatically, but you can verify and adjust settings:

```
// Ensure audio is enabled for the capture
VideoCapture1.Audio_RecordAudio = true;
```

### Handling Capture Events

Implementing event handlers improves user experience by providing feedback during the capture process:

```
// Handle errors during capture
VideoCapture1.OnError += (sender, args) =>
{
    // Log or display error information
    Console.WriteLine($"Error: {args.Message}");
};
```

## Performance Considerations

When capturing video with hardware MPEG-2 encoders, consider these performance factors:

1. **Disk Speed**: Ensure your storage device can handle the sustained write speeds required for MPEG-2 capture
2. **Buffer Settings**: Adjust buffer sizes based on available memory and system performance
3. **Background Processing**: Minimize CPU-intensive tasks during capture to prevent frame drops
4. **Thermal Management**: Extended capture sessions may cause device heating; monitor system temperatures

## Troubleshooting Common Issues

### Encoder Not Found

If your application cannot find hardware encoders, verify:

- The device is properly connected and powered
- Appropriate drivers are installed
- The device supports MPEG-2 hardware encoding

### Poor Video Quality

If captured video quality is unsatisfactory:

- Check signal strength from the TV source
- Verify encoder quality settings
- Ensure proper lighting conditions if using a camera source

### Capture Failures

For capture failures or crashes:

- Verify the output directory is writable
- Check for sufficient disk space
- Ensure no other applications are using the capture device

## Required Redistributables

For proper operation, your application needs these redist packages:

- Video capture redist [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/) [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)

Install the appropriate package based on your application's target architecture.

## Conclusion

Implementing MPEG-2 video capture using TV tuners with hardware encoders enables efficient broadcast recording in your .NET applications. The hardware acceleration provides performance benefits while maintaining good video quality. By following the steps outlined in this guide, you can create robust video capture solutions for various broadcast applications.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Start/Stop Recording Without Stopping Preview in .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-capture/separate-capture/
**Description:** Control video recording independently from live preview in VisioForge Video Capture SDK. Separate capture mode for webcam, screen, and IP camera in C#.
**Tags:** Video Capture SDK, .NET, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, Capture, Streaming, Webcam, IP Camera, Screen Capture, RTMP, MP4, C#
**API:** VideoCaptureMode, MP4Output, RTMPOutput

# Managing Video Capture and Preview Independently in .NET

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Introduction

When developing video applications, it's often necessary to start or stop recording while maintaining an uninterrupted preview. This capability is essential for creating professional video recording software, security applications, or any scenario where continuous visual feedback is required regardless of the recording state.

This guide demonstrates how to independently control video capture operations without affecting the preview display. This technique applies to various capture scenarios including camera recording, screen capture, and other input sources.

## Why Separate Preview and Capture?

There are several advantages to separating preview and capture functionality:

1. **Enhanced User Experience** - Users can continuously see what's being captured, even when not recording
2. **Resource Efficiency** - Prevents unnecessary stopping/restarting of video streams
3. **Reduced Latency** - Eliminates the delay associated with reestablishing preview after stopping a recording
4. **Greater Control** - Provides more precise management of recording sessions

## Implementation Options

There are two main approaches to implementing this functionality depending on which SDK version you're using:

VideoCaptureCoreXVideoCaptureCore

### Method 1: Using VideoCaptureCoreX

The VideoCaptureCoreX approach offers a streamlined way to manage outputs and control capture states.

#### Step 1: Configure the Output

First, add a new output with your desired settings. In this example, we'll use MP4 output. Note the `false` parameter which indicates we don't want to start capture immediately:

```
VideoCapture1.Outputs_Add(new MP4Output("output.mp4"), false); // false - don't start capture immediately.
```

#### Step 2: Start Preview Only

Next, start the video preview without initiating capture:

```
await VideoCapture1.StartAsync();
```

#### Step 3: Start Capture When Needed

When you want to begin recording, start the actual video capture to your output destination:

```
await VideoCapture1.StartCaptureAsync(0, "output.mp4"); // 0 - index of the output.
```

#### Step 4: Stop Capture While Maintaining Preview

To stop recording while keeping the preview active:

```
await VideoCapture1.StopCaptureAsync(0); // 0 - index of the output.
```

### Advanced Output Management

You can add multiple outputs with different settings:

```
// Add MP4 output
VideoCapture1.Outputs_Add(new MP4Output("primary_recording.mp4"), false);

// Add additional output for streaming
VideoCapture1.Outputs_Add(new RTMPOutput("rtmp://streaming.example.com/live/stream"), false);

// Start preview
await VideoCapture1.StartAsync();

// Start recording to both outputs
await VideoCapture1.StartCaptureAsync(0, "primary_recording.mp4");
await VideoCapture1.StartCaptureAsync(1, "rtmp://streaming.example.com/live/stream");
```

### Output Control With Indices

When managing multiple outputs, the index parameter becomes crucial:

```
// Stop the MP4 recording but continue streaming
await VideoCapture1.StopCaptureAsync(0);

// Later, stop the stream too
await VideoCapture1.StopCaptureAsync(1);
```

### Method 2: Using VideoCaptureCore

The older VideoCaptureCore approach uses a different pattern with explicit separate capture enablement.

#### Step 1: Enable Separate Capture Mode

Begin by enabling the separate capture functionality:

```
VideoCapture1.SeparateCapture_Enabled = true;
```

#### Step 2: Configure Capture Mode

Set the appropriate capture mode for your application:

```
VideoCapture1.Mode = VideoCaptureMode.VideoCapture;
// Other options include:
// VideoCaptureMode.ScreenCapture
// VideoCaptureMode.AudioCapture
// etc.
```

#### Step 3: Configure Output Format

Set your desired output format configuration:

```
VideoCapture1.Output_Format = ...
```

#### Step 4: Start Preview

Begin the preview without starting the actual recording:

```
await VideoCapture1.StartAsync();
```

#### Step 5: Start Capture When Needed

When you want to begin recording, start the separate capture process:

```
// SeparateCapture_StartAsync takes the output filename for the recording file.
await VideoCapture1.SeparateCapture_StartAsync("recording.mp4");
```

#### Step 6: Stop Capture While Maintaining Preview

To stop recording while keeping the preview active:

```
await VideoCapture1.SeparateCapture_StopAsync();
```

### Dynamic Filename Changes

A key advantage of the separate capture approach is the ability to change the output filename during an active recording session:

```
await VideoCapture1.SeparateCapture_ChangeFilenameOnTheFlyAsync("newfile.mp4");
```

This is particularly useful for:

- Creating sequential file segments
- Implementing file size limits with automatic continuation
- Responding to user-initiated filename changes

## Implementation Considerations

### Memory and Performance

When implementing separate capture and preview functionality, be mindful of these performance considerations:

- **Memory Usage**: Maintaining an active preview while not capturing consumes system resources
- **CPU Impact**: Encoding operations during capture increase CPU load
- **Buffer Management**: Ensure proper buffer handling to prevent memory leaks

### UI Considerations

Your application UI should clearly indicate the current state of both preview and capture:

- Use different visual indicators for preview-only vs. active recording
- Implement appropriate UI controls for each state
- Consider adding recording timers and indicators

## Integration Best Practices

For optimal performance and reliability:

1. **Initialize Early**: Set up your capture configuration at application startup
2. **Release Resources**: Always stop capture and preview when they're no longer needed
3. **Handle Device Changes**: Implement proper detection and handling of device connection/disconnection
4. **Thread Management**: Perform capture operations on background threads to prevent UI freezing

## Conclusion

Separating video capture and preview operations provides greater flexibility and a better user experience in video applications. By following the approaches outlined in this guide, you can implement this functionality in your .NET applications with either the VideoCaptureCoreX or VideoCaptureCore components.

These techniques can be applied to a wide range of scenarios including webcam recording, screen capture, surveillance systems, and professional video production tools.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Real-Time Video Effects - Resize, Crop, Overlay in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-processing/
**Description:** Apply real-time resize, crop, rotation, text overlays, and color filters during video capture with VisioForge Video Capture SDK. C# API examples.
**Tags:** Video Capture SDK, .NET

# Video Processing and Effects for .NET Developers

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Transform Your Video Content with Powerful Processing Tools

Our .NET SDK offers developers a complete toolkit for modifying and enhancing video streams during the capture process. With our robust API, you can implement professional-grade video manipulations with minimal code.

## Key Features and Capabilities

### Dynamic Resizing and Cropping

Precisely control your video dimensions to match any requirement. Our SDK enables you to:

- Adjust resolution on-the-fly to optimize for different platforms
- Crop unwanted areas from your video frame
- Maintain aspect ratios or create custom dimensions
- Scale content proportionally for different screen sizes

### Professional Overlay System

Enhance your videos with rich content overlays:

- **Text Overlays**: Add customizable captions, titles, timestamps, or any text element with precise control over fonts, colors, positioning, and animations
- **Image Overlays**: Incorporate logos, watermarks, or informational graphics with transparency support
- **Animated GIF Integration**: Embed animated elements that bring movement and visual interest to static scenes

### Advanced Color Manipulation

Fine-tune the visual characteristics of your video with our color adjustment tools:

- Modify brightness, contrast, and gamma for perfect exposure
- Adjust hue and saturation to create specific moods or correct color issues
- Apply color balance adjustments for professional-looking results
- Create custom color grading profiles for consistent visual styling

### Creative Effects Library

Transform ordinary footage with our collection of real-time effects:

- Apply sepia, grayscale, or noir filters for artistic expression
- Use fish-eye, barrel distortion, or other perspective effects
- Implement blur, sharpen, or other focus-based modifications
- Create picture-in-picture and custom compositing effects

## Detailed Documentation

Explore our comprehensive guides for implementing specific features:

- [Video Effects Implementation Guide](video-effects/)
- [Resizing and Cropping Techniques](resize-crop/)
- [Multi-Stream Video Mixing](video-mixing/)

## Developer Resources

For practical implementation examples and code snippets, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) containing extensive sample applications and projects.

---END OF PAGE---


## Resize, Crop, and Scale Live Video During Capture in C#
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-processing/resize-crop/
**Description:** Resize and crop live video from webcams, screens, and IP cameras with VisioForge Video Capture SDK. Aspect ratio control and region-of-interest in C#.
**Tags:** Video Capture SDK, .NET, Windows, NuGet
**API:** VideoResizeSettings, VideoCropSettings

# Video Resize and Crop Operations for .NET Developers

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Introduction to Video Processing

When working with video streams in .NET applications, controlling the dimensions and focus area of your video is essential for creating professional applications. This guide explains how to implement resize and crop operations on video streams from webcams, screen captures, IP cameras, and other sources.

## Video Resizing Implementation

Resizing allows you to standardize video dimensions across different video sources, which is particularly useful when working with multiple camera inputs or when targeting specific output formats.

### Step 1: Enable Resize Functionality

First, enable the resize or crop feature in your application:

```
VideoCapture1.Video_ResizeOrCrop_Enabled = true;
```

### Step 2: Configure Resize Parameters

Set your desired width and height, and determine whether to maintain aspect ratio with letterboxing:

```
VideoCapture1.Video_Resize = new VideoResizeSettings
{
    Width = 640,
    Height = 480,
    LetterBox = true
};
```

### Step 3: Select Appropriate Resize Algorithm

Choose the algorithm that best fits your performance and quality requirements:

```
// Video_Resize is typed as the IVideoResizeSettings marker interface;
// Mode lives on the concrete VideoResizeSettings, so cast before assigning.
var resize = (VideoResizeSettings)VideoCapture1.Video_Resize;
switch (cbResizeMode.SelectedIndex)
{
  case 0: resize.Mode = VideoResizeMode.NearestNeighbor; break;
  case 1: resize.Mode = VideoResizeMode.Bilinear; break;
  case 2: resize.Mode = VideoResizeMode.Bicubic; break;
  case 3: resize.Mode = VideoResizeMode.Lancroz; break;
}
```

## Video Cropping Implementation

Cropping allows you to focus on specific regions of interest in your video feed, removing unwanted areas from the frame.

### Step 1: Enable Crop Functionality

Similar to resizing, first enable the crop functionality:

```
VideoCapture1.Video_ResizeOrCrop_Enabled = true;
```

### Step 2: Define Crop Region

Specify the crop region by setting the margins to remove from each edge of the video frame:

```
VideoCapture1.Video_Crop = new VideoCropSettings(40, 0, 40, 0);
```

## Performance Considerations

When implementing resize and crop operations in production applications, consider the following:

- Resizing operations require CPU resources, especially at higher resolutions
- More complex algorithms (Bicubic, Lanczos) provide better quality but require more processing power
- For real-time applications, balance quality and performance based on your target hardware

## Required Dependencies

Ensure your project includes the necessary redistributable packages:

- Video capture redist [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/) [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)

## Additional Resources

For more advanced implementations and code samples, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) containing numerous examples for .NET developers.

---END OF PAGE---


## Apply Brightness, Chroma Key, and Overlay Effects in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-processing/video-effects/
**Description:** Apply brightness, contrast, chroma key, deinterlace, and image overlay effects during live capture with VisioForge Video Capture SDK. C# code examples.
**Tags:** Video Capture SDK, .NET, Windows, Effects, NuGet

# Video effects

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

Video Capture SDK .Net allows you to apply various video effects to the video captured from different sources. The video effects are applied in realtime.

Read the [Video Effects in .Net SDKs](../../../general/video-effects/) article to learn more about video effects in Video Capture SDK .Net.

## Required redists

- Video capture redist [x86](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/) [x64](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## Video Mixing and Picture-in-Picture Layout in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-processing/video-mixing/
**Description:** Implement Picture-in-Picture with multiple video sources in .NET using C# code examples for mixing streams with custom layouts.
**Tags:** Video Capture SDK, .NET, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, Capture, Mixing, IP Camera, Screen Capture, MP4, C#, NuGet
**API:** VideoCaptureCoreX, ScreenCaptureSourceSettings, VideoMixerSourceSettings, IPCameraSourceSettings, VideoCaptureDeviceSourceSettings

# Mixing Multiple Video Streams in .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Introduction to Video Stream Mixing

The SDK provides powerful capabilities for mixing several video streams with different resolutions and frame rates. This functionality is essential for creating professional video applications that require Picture-in-Picture effects, multi-camera views, or combined display outputs.

## Key Features of Video Mixing

- Combine multiple video sources in a single output
- Support for different video resolutions and frame rates
- Multiple layout options (horizontal, vertical, grid, custom)
- Real-time position and parameter adjustments
- Transparency and flip controls
- Support for diverse input sources (cameras, screens, IP cameras)

## VideoCaptureCore engine

The implementation process involves three main steps:

1. Setting up the video mixing mode
2. Adding multiple video sources
3. Configuring and adjusting source parameters

Let's explore each step in detail with code examples.

### Setting Video Mixing Mode

The SDK supports various predefined layouts as well as custom configurations. Select the appropriate mode based on your application requirements.

#### Horizontal Stack Layout

This mode arranges all video sources horizontally in a row:

```
VideoCapture1.PIP_Mode = PIPMode.Horizontal;
```

#### Vertical Stack Layout

This mode arranges all video sources vertically in a column:

```
VideoCapture1.PIP_Mode = PIPMode.Vertical;
```

#### Grid Layout (2×2)

This mode organizes up to four video sources in a square grid:

```
VideoCapture1.PIP_Mode = PIPMode.Mode2x2;
```

#### Custom Layout with Specific Resolution

For advanced scenarios, you can define a custom layout with precise output dimensions:

```
VideoCapture1.PIP_Mode = PIPMode.Custom;
VideoCapture1.PIP_CustomOutputSize_Set(1920, 1080);
```

### Adding Video Sources

The first configured source serves as the main input, while additional sources can be added using the PIP API.

#### Adding a Video Capture Device

To incorporate a camera or other video capture device:

```
// Signature: (string deviceName, string format, bool useBestFormat, VideoFrameRate frameRate,
//             string crossbarInput, int left, int top, int width, int height) → bool
VideoCapture1.PIP_Sources_Add_VideoCaptureDevice(
    deviceName:     "USB Camera",                     // name from Video_CaptureDevices()
    format:         "1280x720 30fps",                 // format string, or empty + useBestFormat=true
    useBestFormat:  false,
    frameRate:      new VideoFrameRate(30),
    input:          null,                             // crossbar input name, or null
    left: 100, top: 100, width: 320, height: 240);
```

#### Adding an IP Camera Source

For network-based cameras:

```
var ipCameraSource = new IPCameraSourceSettings
{
    URL = new Uri("rtsp://192.168.1.1:554/live") // URL is Uri, not string
};

// Set additional IP camera parameters as needed
// Authentication, protocol, buffering, etc.

VideoCapture1.PIP_Sources_Add_IPCamera(
    ipCameraSource,
    left,
    top,
    width,
    height);
```

#### Adding a Screen Capture Source

To include desktop or application windows:

```
ScreenCaptureSourceSettings screenSource = new ScreenCaptureSourceSettings();
screenSource.Mode = ScreenCaptureMode.Screen;
screenSource.FullScreen = true;
VideoCapture1.PIP_Sources_Add_ScreenSource(
    screenSource,
    left,
    top,
    width,
    height);
```

### Dynamic Source Adjustments

A major advantage of the SDK is the ability to adjust source parameters in real-time during operation.

#### Repositioning Sources

You can modify the position and dimensions of any source:

```
// SetSourcePositionAsync takes (int index, Rectangle rect).
await VideoCapture1.PIP_Sources_SetSourcePositionAsync(
    index,                                 // 0 is main source, 1+ are additional sources
    new System.Drawing.Rectangle(left, top, width, height));
```

#### Adjusting Visual Properties

Fine-tune the appearance with transparency and orientation controls:

```
int transparency = 127; // Range: 0-255
bool flipX = false;
bool flipY = false;

// SetSourceSettingsAsync takes (int index, int transparency, bool flipX, bool flipY, bool disabled = false).
await VideoCapture1.PIP_Sources_SetSourceSettingsAsync(
    index,
    transparency,
    flipX,
    flipY);
```

### Required Dependencies

To use video mixing functionality, ensure you include the appropriate redistributable packages:

- Video capture redistributables:
- [x86 Package](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x86/)
- [x64 Package](https://www.nuget.org/packages/VisioForge.DotNet.Core.Redist.VideoCapture.x64/)

## VideoCaptureCoreX engine

The VideoCaptureCoreX engine is a newer version of the VideoCaptureCore engine that provides additional features and improvements.

### Video Mixing with VideoCaptureCoreX

The VideoCaptureCoreX engine offers a more flexible and powerful approach to video mixing through the `VideoMixerSourceSettings` class. This allows for precise control over multiple video sources and their layout.

#### Basic Setup

```
using System;
using System.Threading.Tasks;
using VisioForge.Core.Types.MediaInfo;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.VideoCapture;

// Create a video mixer with 1080p resolution at 30fps
var videoMixer = new VideoMixerSourceSettings(1920, 1080, VideoFrameRate.FPS_30);

// Initialize the VideoCaptureCoreX engine
var captureX = new VideoCaptureCoreX();
captureX.Video_Source = videoMixer;
```

#### Adding Multiple Sources

You can add various video sources to the mixer, positioning each one exactly where needed:

```
// Rect uses (left, top, right, bottom) — NOT (left, top, width, height). Width and
// Height are computed as Right-Left / Bottom-Top, so passing width/height here yields
// negative dimensions for any non-origin rectangle.

// Add a camera as the first source (full-screen background, 1920×1080 canvas).
var cameraSource = new VideoCaptureDeviceSourceSettings();

// Configure camera settings
// ...

videoMixer.Add(cameraSource, new Rect(0, 0, 1920, 1080));

// Add a screen capture source in the top-right corner, 640×480 region.
var screenSource = new ScreenCaptureDX9SourceSettings();
screenSource.CaptureCursor = true;
screenSource.FrameRate = VideoFrameRate.FPS_30;

// left = 1280, top = 0, right = 1280+640 = 1920, bottom = 0+480 = 480.
videoMixer.Add(screenSource, new Rect(1280, 0, 1920, 480));
```

#### Reconfiguring sources before Start

`VideoMixerSourceSettings` is configuration — its sources are baked in at `StartAsync`. To change the layout you mutate the settings list (via `Get`/`RemoveAt`/`Add`) **before** starting the pipeline:

```
// Inspect a source at index 1 (returns a Tuple<IVideoMixerSource, Rect, ChromaKeySettingsX>).
var (source, currentRect, chromaKey) = videoMixer.Get(1);

// Swap its rectangle by removing and re-adding in place.
videoMixer.RemoveAt(1);
videoMixer.Add(source, new Rect(0, 0, 1280, 720), chromaKey);
```

The same entries are also reachable directly as `videoMixer.Sources`, a `List<VideoMixerSourceStream>` where each item carries its `Source`, `Rectangle` and optional `ChromaKeySettings`. That list is what gets written when the settings are saved into a Media Blocks pipeline document, so a saved composition is restored with its sources, their positions and their chroma keys.

For true **runtime** layout changes (update position while the pipeline is live), drop down to Media Blocks: build your pipeline around a `VideoMixerBlock` and use its `Input_Get(Guid)` / `Input_Update(VideoMixerStream)` methods to mutate stream position, size, alpha, or z-order without restarting. See [Media Blocks video-processing reference](../../../mediablocks/VideoProcessing/) for the `VideoMixerBlock` API.

#### Output Configuration

Configure the output destination for your mixed video:

```
// Set up MP4 recording
captureX.Outputs_Add(new MP4Output("output.mp4"));

// Start capturing
await captureX.StartAsync();

// Stop after some time
await Task.Delay(TimeSpan.FromMinutes(5));
await captureX.StopAsync();
```

### Comparison with VideoCaptureCore Engine

| Feature | VideoCaptureCore | VideoCaptureCoreX |
| --- | --- | --- |
| API Style | Method-based approach | Object-oriented with settings classes |
| Flexibility | Predefined layouts | Fully customizable source positioning |
| Source Management | Fixed API for adding sources | Add any source implementing IVideoMixerSource |
| Performance | Good | Enhanced with optimized rendering pipeline |
| Real-time Changes | Limited | Comprehensive source manipulation |

### Required Dependencies

Check the main [Deployment](../../deployment/) page for the latest dependencies.

## Advanced Usage Scenarios

The video mixing capabilities enable numerous application scenarios:

- Multi-camera security monitoring
- Video conferencing with screen sharing
- Broadcasting with commentator overlay
- Educational presentations with multiple inputs
- Gaming streams with player camera

## Troubleshooting Tips

- Ensure hardware resources are sufficient for the number of streams
- Monitor CPU and memory usage during operation
- Consider lower resolutions for smoother performance with many sources
- Test different layout configurations for optimal visual results

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page for additional code samples and implementation examples.

---END OF PAGE---


## Blackmagic Decklink Video Capture and Playback in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-sources/decklink/
**Description:** Capture video from Blackmagic Decklink cards in .NET using VisioForge Video Capture SDK. Device enumeration, format selection, and C# code examples.
**Tags:** Video Capture SDK, .NET, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, Capture, Decklink, C#
**API:** VideoCaptureCoreX, DeviceEnumerator, DecklinkVideoSourceSettings, DecklinkAudioSourceSettings, DecklinkSourceSettings

# Integrating Blackmagic Decklink Devices with .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [VideoCaptureCoreX](#) [VideoCaptureCore](#)

## What Are Decklink Devices?

Blackmagic Design's Decklink devices represent industry-standard capture and playback cards designed for professional video production environments. These high-performance hardware solutions deliver exceptional capabilities for developers integrating video capture functionality into .NET applications.

Decklink cards are renowned for their superior technical specifications:

- Support for high-resolution video formats including 4K, 8K, and HD
- Multiple input/output connection options (SDI, HDMI) for flexible integration
- Low-latency performance crucial for real-time broadcasting applications
- Cross-compatibility with major video production software platforms
- Developer-friendly APIs that integrate seamlessly with various programming languages

For .NET developers building professional video applications, Decklink integration provides a reliable foundation for handling broadcast-quality video signal processing.

## Programmatic Device Detection

The first step in implementing Decklink functionality is proper device enumeration. The following code samples demonstrate how to detect available Decklink hardware in your .NET application.

### Enumerating Available Devices

VideoCaptureCoreVideoCaptureCoreX

```
foreach (var device in (await VideoCapture1.Decklink_CaptureDevicesAsync()))
{
    cbDecklinkCaptureDevice.Items.Add(device.Name);
}
```

```
var videoCaptureDevices = await DeviceEnumerator.Shared.DecklinkVideoSourcesAsync();
if (videoCaptureDevices.Length > 0)
{
    foreach (var item in videoCaptureDevices)
    {
        cbVideoInput.Items.Add(item.Name);
    }

    cbVideoInput.SelectedIndex = 0;
}
```

When working with VideoCaptureCoreX, you'll also need to enumerate audio sources separately:

```
var audioCaptureDevices = await DeviceEnumerator.Shared.DecklinkAudioSourcesAsync();
if (audioCaptureDevices.Length > 0)
{
    foreach (var item in audioCaptureDevices)
    {
        cbAudioInput.Items.Add(item.Name);
    }

    cbAudioInput.SelectedIndex = 0;
}
```

## Working with Video Formats and Frame Rates

After enumerating devices, the next step involves determining available video formats and frame rates. Decklink cards support numerous professional formats, but the specific options depend on the connected input source.

### Retrieving Format Information

VideoCaptureCoreVideoCaptureCoreX

```
// Enumerate and filter by device name
var deviceItem = (await VideoCapture1.Decklink_CaptureDevicesAsync()).Find(device => device.Name == cbDecklinkCaptureDevice.Text);
if (deviceItem != null)
{
    // Read video formats and add to combobox
    foreach (var format in (await deviceItem.GetVideoFormatsAsync()))
    {
        cbDecklinkCaptureVideoFormat.Items.Add(format.Name);
    }

    // If format does not exist, add a message
    if (cbDecklinkCaptureVideoFormat.Items.Count == 0)
    {
        cbDecklinkCaptureVideoFormat.Items.Add("No input connected");
    }
}
```

This approach provides valuable diagnostic information. If no formats are returned, it typically indicates that no active input is connected to the Decklink device. Implementing this check helps users troubleshoot connection issues directly from your application interface.

With VideoCaptureCoreX, you'll work with predefined modes from the DecklinkMode enumeration:

```
var decklinkModes = Enum.GetValues(typeof(DecklinkMode));
foreach (var item in decklinkModes)
{
    cbVideoMode.Items.Add(item.ToString());
}
```

This approach uses standardized mode settings that must be configured on your Decklink hardware.

## Configuring Decklink as Video Source

Once you've detected devices and identified available formats, you need to configure the Decklink hardware as your capture source. This critical step establishes the connection between hardware and software.

### Setting Source Parameters

VideoCaptureCoreVideoCaptureCoreX

```
VideoCapture1.Decklink_Source = new DecklinkSourceSettings
{
    Name = cbDecklinkCaptureDevice.Text,
    VideoFormat = cbDecklinkCaptureVideoFormat.Text
};

// Select the Decklink mode before StartAsync:
//   DecklinkSourcePreview — real-time monitoring with minimal processing.
//   DecklinkSourceCapture — high-quality recording with enhanced buffering.
VideoCapture1.Mode = VideoCaptureMode.DecklinkSourcePreview;   // or VideoCaptureMode.DecklinkSourceCapture

await VideoCapture1.StartAsync();
```

- `DecklinkSourcePreview`: Optimized for real-time monitoring with minimal processing
- `DecklinkSourceCapture`: Configured for high-quality recording with enhanced buffering

VideoCaptureCoreX requires separate configuration of video and audio sources:

```
// Create settings for the video source
DecklinkVideoSourceSettings videoSourceSettings = null;

// Device name from the combo box
var deviceName = cbVideoInput.Text;

// Mode from the combobox
var mode = cbVideoMode.Text;
if (!string.IsNullOrEmpty(deviceName) && !string.IsNullOrEmpty(mode))
{
    // Find device
    var device = (await DeviceEnumerator.Shared.DecklinkVideoSourcesAsync()).FirstOrDefault(x => x.Name == deviceName);
    if (device != null)
    {
        // Create video source settings using device and mode
        videoSourceSettings = new DecklinkVideoSourceSettings(device)
        {
            Mode = (DecklinkMode)Enum.Parse(typeof(DecklinkMode), mode, true)
        };
    }
}

// Set the video source to the VideoCaptureCoreX object
VideoCapture1.Video_Source = videoSourceSettings;
```

For audio configuration:

```
// Create settings for the audio source
DecklinkAudioSourceSettings audioSourceSettings = null;

// Device name from the combobox
deviceName = cbAudioInput.Text;
if (!string.IsNullOrEmpty(deviceName))
{
    // Find device
    var device = (await DeviceEnumerator.Shared.DecklinkAudioSourcesAsync()).FirstOrDefault(x => x.Name == deviceName);
    if (device != null)
    {
        // Create settings for the audio source using device
        audioSourceSettings = new DecklinkAudioSourceSettings(device);
    }
}

// Set the audio source to the VideoCaptureCoreX object
VideoCapture1.Audio_Source = audioSourceSettings;
```

This separation offers greater flexibility for advanced scenarios where you might need to process video and audio independently.

## Performance Considerations

When implementing Decklink capture in production environments, consider these performance factors:

1. **Buffer management:** Professional video formats require substantial memory allocation, especially for 4K+ resolutions
2. **CPU utilization:** Real-time encoding of Decklink streams can be processor-intensive
3. **Disk I/O:** When capturing to storage, ensure your write speeds support the data rate of your selected format
4. **Memory bandwidth:** High-resolution uncompressed streams demand significant system resources

Implementing proper error handling around device connection and format detection will improve your application's resilience in production environments.

## Sample Applications and Implementation Examples

Examining working examples provides valuable insights into effective implementation patterns. The SDK includes numerous sample applications demonstrating Decklink integration.

### Reference Applications

VideoCaptureCoreVideoCaptureCoreX

- [Main sample with DeckLink input, video/audio processing and many output formats (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/WPF/CSharp/Main_Demo)
- [Main sample for WinForms](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/WinForms/CSharp/Main%20Demo)
- [Simple sample with DeckLink input and many output formats (WinForms)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/WinForms/CSharp/Decklink%20Demo)

- [Video preview and capture to MP4 or WebM file (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WPF/CSharp/Decklink%20Demo%20X)

## Best Practices for Integration

Based on extensive field testing and customer implementation experiences, we recommend these best practices:

1. **Always verify device connectivity:** Check for available formats to confirm proper signal connection
2. **Implement graceful fallbacks:** Provide meaningful error messages when expected devices are unavailable
3. **Test with multiple frame rates:** Some applications may behave differently with varied input formats
4. **Manage memory effectively:** High-resolution capture requires proper resource management
5. **Monitor CPU usage:** Encoding operations can be processor-intensive during capture
6. **Provide format details to users:** Give clear information about detected formats and connection status

These recommendations help ensure robust implementations that perform reliably across different hardware configurations and operating conditions.

## Conclusion

Integrating Blackmagic Decklink devices with .NET applications provides powerful capabilities for professional video capture scenarios. By following the implementation patterns outlined in this guide, developers can create stable, high-performance applications that leverage the full capabilities of Decklink hardware.

The Video Capture SDK offers a streamlined approach to working with these professional devices, abstracting much of the complexity while providing the flexibility needed for advanced customization.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to access additional code samples and implementation resources.

---END OF PAGE---


## DV Camcorder Control in C# - Video Capture SDK .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-sources/dv-camcorder-control/
**Description:** Implement DV/HDV camcorder control in C# apps with essential commands, implementation patterns, and practical code examples for .NET.
**Tags:** Video Capture SDK, .NET, VideoCaptureCore, Windows, Capture, DV Camera, C#

# DV Camcorder Control for .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [VideoCaptureCore](#)

## Introduction to DV Camcorder Integration

Digital Video (DV) camcorders remain valuable tools for high-quality video capture in professional and semi-professional environments. Integrating DV camcorder control into your .NET applications allows for programmatic device management, enabling automated workflows and enhanced user experiences. This guide provides everything you need to implement DV camcorder control in your C# applications.

The VideoCaptureCore component provides a robust API for controlling DV/HDV camcorders through simple, asynchronous method calls. This functionality supports a wide range of camcorder models and can be implemented in WPF, WinForms, and console applications.

## Getting Started with DV Camcorder Control

### Prerequisites

Before implementing DV camcorder control features, ensure you have:

1. A compatible DV/HDV camcorder connected to your system
2. The Video Capture SDK .NET installed in your project
3. Proper device drivers installed on your development machine

### Initial Setup

To begin working with a DV camcorder, you must first:

1. Select the DV camcorder as your video source
2. Configure appropriate source parameters
3. Initialize the video preview or capture functionality

For detailed instructions on selecting and configuring a DV camcorder as your video source, refer to our [video capture device guide](../video-capture-devices/).

## Core DV Camcorder API Methods

The SDK provides several methods for controlling and querying DV camcorders:

### Sending Commands

Control your DV device using the `DV_SendCommandAsync` method (or `DV_SendCommand` for synchronous operations). This method accepts a `DVCommand` enumeration value representing the specific operation to perform.

```
// Asynchronous command execution
await VideoCapture1.DV_SendCommandAsync(DVCommand.Play);

// Synchronous command execution
VideoCapture1.DV_SendCommand(DVCommand.Play);
```

### Getting Current Mode

Retrieve the current operation mode of your DV device:

```
// Asynchronous mode retrieval
DVCommand currentMode = await VideoCapture1.DV_GetModeAsync();

// Synchronous mode retrieval
DVCommand currentMode = VideoCapture1.DV_GetMode();

// Check current mode
if (currentMode == DVCommand.Play)
{
    // Camcorder is currently playing
}
```

### Reading Timecode Information

Access the current timecode position of your DV tape:

```
// Asynchronous timecode retrieval
Tuple<TimeSpan, uint> timecodeInfo = await VideoCapture1.DV_GetTimecodeAsync();

// Synchronous timecode retrieval
Tuple<TimeSpan, uint> timecodeInfo = VideoCapture1.DV_GetTimecode();

if (timecodeInfo != null)
{
    // Timecode as TimeSpan (hours, minutes, seconds)
    TimeSpan timecode = timecodeInfo.Item1;
    // Frame count
    uint frameCount = timecodeInfo.Item2;

    // Display timecode information
    string timecodeDisplay = $"{timecode.Hours:D2}:{timecode.Minutes:D2}:{timecode.Seconds:D2}:{frameCount:D2}";
}
```

## Basic Playback Commands

The following commands represent the essential playback operations supported by most DV camcorders:

### Pause Operation

Temporarily halt the current playback or recording operation:

```
await VideoCapture1.DV_SendCommandAsync(DVCommand.Pause);
```

### Play Operation

Begin or resume playback from the current position:

```
await VideoCapture1.DV_SendCommandAsync(DVCommand.Play);
```

### Stop Operation

Completely stop the current operation:

```
await VideoCapture1.DV_SendCommandAsync(DVCommand.Stop);
```

## Navigation Commands

Navigate through recorded content with these commands:

### Fast Forward

Rapidly advance through recorded content:

```
await VideoCapture1.DV_SendCommandAsync(DVCommand.FastForward);
```

### Rewind

Move backward through recorded content:

```
await VideoCapture1.DV_SendCommandAsync(DVCommand.Rew);
```

## Advanced DV Camcorder Control

### Frame-by-Frame Navigation

For precise control over playback position, use these frame-accurate navigation commands:

```
// Move forward by one frame
await VideoCapture1.DV_SendCommandAsync(DVCommand.StepFw);

// Move backward by one frame
await VideoCapture1.DV_SendCommandAsync(DVCommand.StepRev);
```

### Variable Speed Playback

The SDK supports multiple playback speeds in both forward and reverse directions:

#### Slow Motion Forward Playback

Six levels of slow motion forward playback are available:

```
// Slowest forward playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowFwd6);

// Slightly faster slow motion
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowFwd5);

// Medium slow motion
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowFwd4);

// Moderately slow playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowFwd3);

// Slightly slow playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowFwd2);

// Mildly slow playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowFwd1);
```

#### Fast Forward Playback

Six levels of accelerated forward playback:

```
// Mildly fast playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastFwd1);

// Moderately fast playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastFwd2);

// High speed playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastFwd3);

// Very high speed playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastFwd4);

// Extremely fast playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastFwd5);

// Maximum speed playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastFwd6);
```

#### Slow Motion Reverse Playback

Six levels of slow motion reverse playback:

```
// Slowest reverse playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowRev6);

// Slightly faster slow reverse
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowRev5);

// Medium slow reverse
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowRev4);

// Moderately slow reverse
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowRev3);

// Slightly slow reverse
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowRev2);

// Mildly slow reverse
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlaySlowRev1);
```

#### Fast Reverse Playback

Six levels of accelerated reverse playback:

```
// Mildly fast reverse
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastRev1);

// Moderately fast reverse
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastRev2);

// High speed reverse
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastRev3);

// Very high speed reverse
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastRev4);

// Extremely fast reverse
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastRev5);

// Maximum speed reverse
await VideoCapture1.DV_SendCommandAsync(DVCommand.PlayFastRev6);
```

#### Extreme Speed Controls

For the fastest possible navigation:

```
// Fastest possible forward speed
await VideoCapture1.DV_SendCommandAsync(DVCommand.FastestFwd);

// Slowest possible forward speed
await VideoCapture1.DV_SendCommandAsync(DVCommand.SlowestFwd);

// Fastest possible reverse speed
await VideoCapture1.DV_SendCommandAsync(DVCommand.FastestRev);

// Slowest possible reverse speed
await VideoCapture1.DV_SendCommandAsync(DVCommand.SlowestRev);
```

### Reverse Playback Control

Standard reverse playback operations:

```
// Normal reverse playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.Reverse);

// Paused reverse playback
await VideoCapture1.DV_SendCommandAsync(DVCommand.ReversePause);
```

### Recording Management

Control recording operations programmatically:

```
// Begin recording
await VideoCapture1.DV_SendCommandAsync(DVCommand.Record);

// Pause recording
await VideoCapture1.DV_SendCommandAsync(DVCommand.RecordPause);
```

## Implementation Patterns

### Real-Time Status Monitoring

Use the provided methods to continuously monitor DV camcorder status and position:

```
private async Task MonitorDVStatus()
{
    while (isMonitoring)
    {
        // Get current mode
        DVCommand mode = await VideoCapture1.DV_GetModeAsync();

        // Get current timecode
        var timecodeInfo = await VideoCapture1.DV_GetTimecodeAsync();

        if (timecodeInfo != null)
        {
            TimeSpan timecode = timecodeInfo.Item1;
            uint frameCount = timecodeInfo.Item2;

            // Update UI with current status
            UpdateStatusDisplay(mode, timecode, frameCount);
        }

        // Brief delay to prevent excessive polling
        await Task.Delay(500);
    }
}

private void UpdateStatusDisplay(DVCommand mode, TimeSpan timecode, uint frameCount)
{
    // Format timecode for display (HH:MM:SS:FF)
    string timecodeText = $"{timecode.Hours:D2}:{timecode.Minutes:D2}:{timecode.Seconds:D2}:{frameCount:D2}";

    // Update UI controls
    statusLabel.Text = $"Mode: {mode}, Timecode: {timecodeText}";

    // Enable/disable UI controls based on current mode
    recordButton.Enabled = (mode != DVCommand.Record);
    pauseButton.Enabled = (mode == DVCommand.Play || mode == DVCommand.Record);
    // Additional UI logic...
}
```

### Asynchronous Command Execution

All DV commands are executed asynchronously to prevent UI freezing. Follow these best practices:

```
// Button click handler for play command
private async void PlayButton_Click(object sender, EventArgs e) {
    try {
        await VideoCapture1.DV_SendCommandAsync(DVCommand.Play);
        StatusLabel.Text = "Playing";
    }
    catch(Exception ex) {
        LogError("Play command failed", ex);
        StatusLabel.Text = "Command failed";
    }
}
```

### Command Sequencing

Some operations require specific command sequences. For example, to capture a specific segment:

```
private async Task CaptureSegmentAsync()
{
    // Rewind to beginning
    await VideoCapture1.DV_SendCommandAsync(DVCommand.Rew);

    // Poll DV_GetModeAsync until the deck reports Stop (no dedicated DVDeviceStatus enum —
    // DVCommand values are reused for both issuing commands and reading current mode).
    while (await VideoCapture1.DV_GetModeAsync() != DVCommand.Stop)
    {
        await Task.Delay(100);
    }

    // Begin playback
    await VideoCapture1.DV_SendCommandAsync(DVCommand.Play);

    // Start capture — VideoCaptureCore lifecycle methods are StartAsync / StopAsync (no
    // separate StartCaptureAsync). Configure Mode / Output_Filename before calling StartAsync.
    await VideoCapture1.StartAsync();

    // Wait for desired duration
    await Task.Delay(captureTimeMs);

    // Stop capture
    await VideoCapture1.StopAsync();

    // Stop playback
    await VideoCapture1.DV_SendCommandAsync(DVCommand.Stop);
}
```

### Seeking to Specific Timecode

This example demonstrates how to navigate to a specific timecode position by monitoring the current position:

```
private async Task SeekToTimecode(TimeSpan targetTimecode)
{
    // Get current position
    var currentTimecodeInfo = await VideoCapture1.DV_GetTimecodeAsync();
    if (currentTimecodeInfo == null) return;

    TimeSpan currentTimecode = currentTimecodeInfo.Item1;

    // Determine if we need to go forward or backward
    if (currentTimecode < targetTimecode)
    {
        // Need to go forward
        await VideoCapture1.DV_SendCommandAsync(DVCommand.FastForward);

        // Monitor position until we reach target
        while (true)
        {
            var info = await VideoCapture1.DV_GetTimecodeAsync();
            if (info == null) break;

            if (info.Item1 >= targetTimecode)
            {
                // We've reached or passed the target
                await VideoCapture1.DV_SendCommandAsync(DVCommand.Stop);
                break;
            }

            await Task.Delay(100);
        }
    }
    else if (currentTimecode > targetTimecode)
    {
        // Need to go backward
        await VideoCapture1.DV_SendCommandAsync(DVCommand.Rew);

        // Monitor position until we reach target
        while (true)
        {
            var info = await VideoCapture1.DV_GetTimecodeAsync();
            if (info == null) break;

            if (info.Item1 <= targetTimecode)
            {
                // We've reached or passed the target
                await VideoCapture1.DV_SendCommandAsync(DVCommand.Stop);
                break;
            }

            await Task.Delay(100);
        }
    }

    // Fine-tune position if needed
    await VideoCapture1.DV_SendCommandAsync(DVCommand.Play);
}
```

### Error Handling

DV device control can encounter various issues including device disconnection, command failure, or timing problems. Implement robust error handling:

```
private async Task ExecuteDVCommandWithRetryAsync(DVCommand command, int maxRetries = 3) {
    int attempts = 0;
    bool success = false;

    while(!success && attempts < maxRetries) {
        try {
            await VideoCapture1.DV_SendCommandAsync(command);
            success = true;
        }
        catch(Exception ex) {
            LogError($"Command {command} failed", ex);
            throw; // Rethrow other exceptions
        }
    }

    if(!success) {
        throw new Exception($"Command {command} failed after {maxRetries} attempts");
    }
}
```

## Sample Applications

The following sample applications demonstrate complete DV camcorder control implementations:

- [DV capture (WinForms)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/WinForms/CSharp/DV%20Capture)
- [DV capture (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/WPF/CSharp/DV_Capture)

## Troubleshooting Common Issues

- **Device Not Responding**: Ensure proper USB/FireWire connection and driver installation
- **Command Timeout**: Some devices require longer response times for certain operations
- **Unsupported Commands**: Not all DV devices support the full command set
- **Inconsistent Behavior**: Different models may have subtle implementation differences
- **Invalid Timecode**: If `DV_GetTimecode` returns null, the device may not support timecode reading or the tape may not have timecode recorded

## Conclusion

Implementing DV camcorder control in your .NET applications provides powerful capabilities for multimedia software. The VideoCaptureCore component simplifies the integration process through its intuitive async API.

For more code samples and advanced implementation techniques, visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples).

---END OF PAGE---


## Video Sources — Webcam, IP Camera, Screen in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-sources/
**Description:** Configure webcam, IP camera, screen capture, Decklink, and industrial camera inputs with VisioForge Video Capture SDK. Device enumeration and C# examples.
**Tags:** Video Capture SDK, .NET, Streaming

# Video Sources for .NET Developers

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net)

## Introduction to Video Input Sources

The Video Capture SDK for .NET provides robust support for virtually every standard video input source available in modern development environments. This flexibility allows developers to build applications that can capture, process, and manipulate video content from a wide variety of hardware devices and network streams.

Whether you're developing professional video editing software, creating custom surveillance solutions, or building medical imaging applications, understanding the available video source options is crucial for implementing the right solution for your specific requirements.

## Quick Start — Pick and assign a video source

Every source plugs into `VideoCaptureCoreX.Video_Source` via a settings class. The pattern is the same across source types — only the settings class changes:

```
using VisioForge.Core;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.VideoCaptureX;

VisioForgeX.InitSDK();
var videoCapture = new VideoCaptureCoreX(videoView as IVideoView);

// Pick ONE of the following sources:

// --- Webcam / USB camera / virtual camera
var camera = (await DeviceEnumerator.Shared.VideoSourcesAsync()).First();
videoCapture.Video_Source = new VideoCaptureDeviceSourceSettings(camera);

// --- Screen capture (Direct3D 11 on Windows)
videoCapture.Video_Source = new ScreenCaptureD3D11SourceSettings
{
    FrameRate = new VideoFrameRate(30),
    CaptureCursor = true
};

// --- Blackmagic Decklink
var dl = (await DeviceEnumerator.Shared.DecklinkVideoSourcesAsync()).First();
videoCapture.Video_Source = new DecklinkVideoSourceSettings(dl);

// --- IP / RTSP camera (use the async factory — ctor is private)
videoCapture.Video_Source = await RTSPSourceSettings.CreateAsync(
    uri: new Uri("rtsp://192.168.1.100:554/stream"),
    login: "admin", password: "password", audioEnabled: true);

// --- NDI (cross-platform, requires NDI runtime)
var ndi = (await DeviceEnumerator.Shared.NDISourcesAsync()).First();
videoCapture.Video_Source = await NDISourceSettings.CreateAsync(videoCapture.GetContext(), ndi);

// Then add an output and start as usual.
videoCapture.Outputs_Add(new MP4Output("output.mp4"), true);
await videoCapture.StartAsync();
```

## USB and Integrated Webcams

### Device Compatibility

The SDK supports all standard video capture devices that comply with common driver interfaces, including:

- USB webcams (USB 2.0, 3.0, and USB-C connected devices)
- Integrated laptop and tablet cameras
- External USB video capture adapters and dongles
- Virtual camera software devices

### Implementation Features

When working with USB and integrated cameras, developers can:

- Access and enumerate all connected devices
- Select from available video formats and resolutions
- Control camera-specific parameters (focus, exposure, white balance)
- Apply real-time video processing filters
- Capture raw frames for custom image analysis
- Configure brightness, contrast, and color settings programmatically

## Professional Blackmagic Decklink Hardware

### Supported Models and Features

The SDK provides native integration with Blackmagic Design's professional Decklink video capture hardware:

- Full support for all Decklink product lines:
- Decklink Mini series (compact, cost-effective capture)
- Decklink Studio models (mid-range broadcast functionality)
- Decklink 4K and 8K series (high-resolution production)
- Decklink Duo and Quad variants (multi-input capture)

### Technical Capabilities

- Support for both SDI (Serial Digital Interface) and HDMI input connections
- Compatible with standard broadcast resolutions:
- SD (PAL/NTSC)
- HD (720p, 1080i, 1080p)
- UHD/4K (2160p)
- 8K where hardware supports it
- Access to all embedded audio channels (up to 16 channels)
- Timecode interpretation and synchronization
- Frame buffer control for consistent capture performance
- Access to video metadata and ancillary data

## Network Video Sources

### IP Camera and Stream Support

The SDK enables applications to connect directly to networked video sources:

- RTSP (Real-Time Streaming Protocol) streams with various transport options:
- UDP transport (low latency, potentially less reliable)
- TCP transport (reliable, potentially higher latency)
- HTTP tunneling for firewall traversal
- RTMP (Real-Time Messaging Protocol) sources:
- Support for live streams
- Compatibility with RTMP servers
- Flash Media Server compatibility
- HTTP-based streaming:
- MJPEG streams
- HTTP progressive download sources
- Industry-standard streaming formats:
- HLS (HTTP Live Streaming)
- DASH (Dynamic Adaptive Streaming over HTTP)
- SRT (Secure Reliable Transport)
- WebRTC integration for browser-based video communication

### Implementation Details

- Authentication support for secured streams (Basic, Digest, NTLM)
- Configurable buffer settings to balance latency vs. smoothness
- Automatic reconnection logic for unstable network conditions
- NAT traversal techniques for complex network environments
- Traffic statistics for monitoring bandwidth usage
- Multi-bitrate adaptation for variable network conditions

## Screen and Window Capture

### Desktop Capture Options

For scenarios requiring screen recording or application capture:

- Full-screen content capture with support for:
- Single monitor setups
- Multi-monitor configurations with selectable target displays
- Various scaling options to optimize performance
- Window-specific capture capabilities:
- Capture by window handle
- Application-specific targeting
- Borderless window capturing
- Region-of-interest selection:
- Custom rectangular area selection
- Dynamic region tracking
- Coordinate-based positioning

### Technical Implementation

- Hardware-accelerated capture where available
- Cursor inclusion/exclusion options
- Frame rate control to balance quality vs. system load
- Mouse click visualization options for tutorial recordings
- DirectX/OpenGL content compatibility
- Layered window handling for complex desktop compositions

## Legacy and Specialized Devices

### DV Camcorder Integration

The SDK maintains support for Digital Video (DV) format cameras:

- FireWire/IEEE 1394 connectivity support
- Compatibility with standard DV, DVCAM, and HDV formats
- Frame-accurate capture with timecode preservation
- Device control features (when supported by hardware):
- Play/pause/stop controls
- Fast-forward and rewind functions
- Recording initiation

### Industrial and Scientific Cameras

For specialized development scenarios, the SDK supports industrial vision cameras through multiple standards:

- USB3 Vision compliant devices featuring:
- High-speed image acquisition
- Device feature discovery and enumeration
- Event handling for triggered capture
- GigE Vision compatible hardware with:
- Network discovery protocols
- High-bandwidth image streaming
- Device configuration access
- GenICam standard interface support:
- Standardized parameter naming conventions
- Feature access consistency across manufacturers
- XML descriptor-based device configuration
- Control over specialized camera parameters:
- Exposure and gain adjustments
- Triggering options (software/hardware)
- Region of interest (ROI) definition
- Various pixel formats and bit depths

## Performance Optimization Techniques

When working with video sources, performance considerations are critical. The SDK provides several optimization paths:

- Hardware acceleration options:
- DirectX-accelerated processing
- GPU-based encoding/decoding
- SIMD instruction utilization
- Memory management strategies:
- Buffer pooling to reduce allocation overhead
- Direct memory access where supported
- Pre-allocated frame buffers
- Multi-threaded processing:
- Parallel processing of video frames
- Thread-pool utilization for filter chains
- Background processing for non-realtime scenarios

## Conclusion

The extensive video source support in Video Capture SDK .NET empowers developers to create versatile video applications with minimal constraints on input hardware. By understanding the capabilities and limitations of each source type, you can design more effective and efficient video processing solutions.

For detailed API references and implementation examples for specific video source types, refer to the class documentation and method guides in the SDK reference materials.

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## IP Camera Integration in C# .NET — RTSP/ONVIF Guides
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-sources/ip-cameras/
**Description:** Connect IP cameras over RTSP and ONVIF in C# / .NET. Authentication, multi-stream, discovery, reconnect. Complete samples for all major brands.
**Tags:** Video Capture SDK, .NET, Windows, macOS, Linux, Android, iOS, Capture, Streaming
**API:** VideoCaptureCoreX, VideoCaptureCore, IPCameraSourceSettings, RTSPSourceSettings, IPSourceEngine

# Complete Guide to IP Cameras and Network Sources Integration

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [VideoCaptureCoreX](#) [VideoCaptureCore](#)

Cross-platform support

The `VideoCaptureCoreX` engine runs on **Windows, macOS, Linux, Android, and iOS** via GStreamer. The classic `VideoCaptureCore` engine is Windows-only. See the [platform support matrix](../../../platform-matrix/) for codec and hardware-acceleration details, and the [Linux deployment guide](../../../deployment-x/Ubuntu/) for Ubuntu / NVIDIA Jetson / Raspberry Pi setup.

## Platform Support

| Source type | `VideoCaptureCore` (Windows) | `VideoCaptureCoreX` (cross-platform) |
| --- | --- | --- |
| RTSP | ✅ | ✅ Windows · macOS · Linux · Android · iOS |
| HTTP MJPEG | ✅ | ✅ Windows · macOS · Linux · Android · iOS |
| ONVIF | ✅ | ✅ via `RTSPSourceSettings.CreateAsync` |
| NDI | ✅ | ✅ requires NDI runtime per platform |
| SRT | ✅ | ✅ Windows · macOS · Linux · Android · iOS |
| VNC | ⛔ | ✅ |
| UDP | ✅ | ✅ |

For MAUI cross-platform apps (single codebase → Windows · macOS · iOS · Android) see the [4×4 multi-camera RTSP grid guide](../../../mediablocks/Guides/multi-camera-rtsp-grid/). For handling camera drops, reconnect logic, and automatic `FallbackSwitch` (text / image / alternate stream) across every SDK, see the [RTSP reconnection & fallback guide](../../../general/network-sources/reconnection-and-fallback/).

## Introduction to Network Video Sources

Modern video applications often require integration with various network video sources. The Video Capture SDK for .NET provides robust support for diverse IP camera types and network video streams, allowing developers to easily incorporate live network video into .NET applications.

This comprehensive guide covers all supported network sources and provides clear implementation examples for both VideoCaptureCore and VideoCaptureCoreX frameworks.

## Supported IP Camera Types and Network Sources

The SDK offers extensive compatibility with various network video sources, including:

- [ONVIF-compliant cameras](onvif/) - Industry standard for IP-based security products
- [RTSP cameras](rtsp/) - Real-Time Streaming Protocol cameras
- HTTP MJPEG cameras - Motion JPEG streaming over HTTP
- UDP cameras and streams - User Datagram Protocol-based streams
- [NDI cameras](ndi/) - Network Device Interface technology cameras
- SRT servers and cameras - Secure Reliable Transport protocol
- VNC servers - Virtual Network Computing for screen capture
- RTMP streams - Real-Time Messaging Protocol sources
- HLS streams - HTTP Live Streaming sources
- HTTP video sources - Various HTTP-based video streams

Each protocol offers specific advantages depending on your application requirements, from low-latency needs to high-quality video transmission.

Looking for RTSP URLs for a specific camera brand? Browse our [IP camera brands directory](../../../camera-brands/) for connection guides covering 60+ manufacturers including Hikvision, Dahua, Axis, Reolink, and more.

## Universal Source Implementation for Network Protocols

Our SDK provides a universal approach to handling most network video sources including RTSP, RTMP, HTTP, and others. This flexibility allows developers to focus on application logic rather than protocol-specific implementation details.

VideoCaptureCoreVideoCaptureCoreX

### Implementing Universal Source in VideoCaptureCore

For VideoCaptureCore applications, you can use the IPCameraSourceSettings class to define your network video source:

```
// Create and configure the network source
VideoCapture1.IP_Camera_Source = new IPCameraSourceSettings
{
    URL = new Uri("rtsp://192.168.1.100:554/stream1"), // The stream URL (Uri, not string)
    Login = "admin", // Optional authentication credentials
    Password = "password123",
    AudioCapture = true, // Set to true to include audio from the source
    Type = IPSourceEngine.Auto_VLC // The processing engine to use
};
```

#### Available Engine Types

The SDK supports multiple underlying engines for processing network streams, providing flexibility for different scenarios:

- `Auto_VLC` - Uses the VLC engine, offering broad protocol support and compatibility
- `Auto_FFMPEG` - Uses the FFMPEG engine, providing extensive format support and customization
- `Auto_LAV` - Uses the LAV engine, optimized for Windows environments

### Customizing FFMPEG Settings for Advanced Users

The SDK allows fine-grained control over FFMPEG settings when using the FFMPEG engine. This provides advanced users with extensive customization options:

```
// Configure custom FFMPEG parameters
VideoCapture1.IP_Camera_Source.FFMPEG_CustomOptions.Add("rtsp_transport", "tcp"); // Force TCP transport
VideoCapture1.IP_Camera_Source.FFMPEG_CustomOptions.Add("timeout", "3000000"); // Set timeout in microseconds
VideoCapture1.IP_Camera_Source.FFMPEG_CustomOptions.Add("buffer_size", "1000000"); // Adjust buffer size
VideoCapture1.IP_Camera_Source.FFMPEG_CustomOptions.Add("max_delay", "500000"); // Set maximum allowed delay
```

These parameters are passed directly to the avformat\_open\_input function in FFMPEG, providing deep customization options for network streaming performance.

### Implementing Universal Source in VideoCaptureCoreX

For VideoCaptureCoreX applications, the approach uses the modern async patterns:

```
// Prepare the source URL with authentication if needed
var uri = new Uri("rtsp://192.168.1.100:554/stream1");
if (!string.IsNullOrEmpty(login) && !string.IsNullOrEmpty(password))
{
    uri = new UriBuilder(uri) { UserName = login, Password = password }.Uri;
}

// Create the universal source with desired settings
var source = await UniversalSourceSettings.CreateAsync(
    uri,
    renderAudio: true); // Include audio stream

// Apply the source to the capture object
VideoCapture1.Video_Source = source;
```

The VideoCaptureCoreX approach provides a more modern, task-based asynchronous pattern, making it ideal for responsive UI applications.

## Low-Latency MJPEG Implementation

For applications requiring minimal latency, such as security monitoring or real-time control systems, the SDK offers a specialized low-latency MJPEG implementation with typical latency under 100ms.

VideoCaptureCoreVideoCaptureCoreX

### Configuring Low-Latency MJPEG in VideoCaptureCore

```
// Create settings object
var settings = new IPCameraSourceSettings
{
    URL = new Uri("http://192.168.1.100/video.mjpg"),
    Login = "admin",
    Password = "pass123",
    // Use the dedicated low-latency MJPEG engine
    Type = IPSourceEngine.HTTP_MJPEG_LowLatency
};

// Apply settings to the VideoCaptureCore object
VideoCapture1.IP_Camera_Source = settings;
```

This specialized mode bypasses unnecessary processing to minimize latency, making it ideal for time-sensitive applications.

### Configuring Low-Latency MJPEG in VideoCaptureCoreX

```
// Create specialized HTTP MJPEG source settings
var mjpeg = await HTTPMJPEGSourceSettings.CreateAsync(
    new Uri("http://192.168.1.100/video.mjpg"),
    "admin", // Username
    "pass123"
);

// Apply settings to the VideoCaptureCoreX object
VideoCapture1.Video_Source = mjpeg;
```

The low-latency MJPEG implementation is particularly useful for surveillance systems, remote monitoring, and industrial applications where minimizing delay is critical.

## Secure Reliable Transport (SRT) Implementation

SRT is a modern protocol designed for reliable video streaming over unpredictable networks. It's especially valuable for maintaining quality in challenging network conditions.

VideoCaptureCoreX

### Implementing SRT Source in VideoCaptureCoreX

```
// Create SRT source settings with the server URL — CreateAsync takes System.Uri, not string.
var srt = await SRTSourceSettings.CreateAsync(new Uri("srt://streaming-server.example.com:7001"));

// Apply the SRT source to the capture object
VideoCapture1.Video_Source = srt;
```

SRT provides significant advantages for reliable streaming across challenging networks, offering built-in security, error correction, and congestion control.

## Network Disconnect Handling

Robust network source implementations must handle connection interruptions gracefully. The SDK provides built-in mechanisms for detecting and responding to network disconnections.

VideoCaptureCore

### Implementing Network Disconnect Handling in VideoCaptureCore

```
// DisconnectEventInterval lives on IPCameraSourceSettings (accessed via VideoCapture1.IP_Camera_Source),
// not on VideoCaptureCore itself. Configure it before starting the preview/capture.
VideoCapture1.IP_Camera_Source.DisconnectEventInterval = TimeSpan.FromSeconds(5); // Check every 5 seconds

// The disconnect event IS on VideoCaptureCore
VideoCapture1.OnNetworkSourceDisconnect += VideoCapture1_OnNetworkSourceDisconnect;

// Implement the disconnect event handler
private void VideoCapture1_OnNetworkSourceDisconnect(object sender, EventArgs e)
{
    Invoke((Action)(
        async () =>
        {
            await VideoCapture1.StopAsync();

            // Notify the user
            MessageBox.Show(this, "Network source disconnected!");
        }));
}
```

Implementing proper disconnect handling improves application reliability and user experience during network fluctuations.

## VNC Source Implementation

Virtual Network Computing (VNC) allows capturing remote desktop screens as video sources, useful for screen recording and remote assistance applications.

VideoCaptureCoreX

### Implementing VNC Source in VideoCaptureCoreX

```
// Create VNC source settings object
var vncSettings = new VNCSourceSettings();

// Configure using host and port
vncSettings.Host = "remote-server.example.com";
vncSettings.Port = 5900; // Default VNC port

// Or configure using URI format
// vncSettings.Uri = "vnc://remote-server.example.com:5900";

// Set authentication credentials
vncSettings.Password = "secure-password";

// Optional: configure advanced VNC behavior
vncSettings.Shared = true;        // Share desktop with other clients
vncSettings.ViewOnly = true;      // View only, don't send input events
vncSettings.Incremental = true;   // Use incremental framebuffer updates
vncSettings.RFBVersion = "3.8";   // RFB protocol version

// Apply the settings to the capture object
VideoCapture1.Video_Source = vncSettings;
```

The VNC source implementation provides a complete solution for remote desktop capture with customizable quality and performance settings.

- [Complete VNC source sample (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WPF/CSharp/VNC%20Source%20Demo)

## Best Practices for Network Sources

For optimal performance when working with network video sources:

1. **Buffer Management**: Adjust buffering based on source stability and latency requirements
2. **Error Handling**: Implement comprehensive error handling for network interruptions
3. **Authentication**: Always use secure credentials storage for camera authentication
4. **Connection Pooling**: Reuse connections when accessing multiple streams from the same device
5. **Bandwidth Consideration**: Monitor and manage bandwidth consumption, especially with multiple sources

## Conclusion

The Video Capture SDK for .NET provides comprehensive support for IP cameras and network sources, enabling developers to build sophisticated video applications. With support for multiple protocols and flexible configuration options, it accommodates a wide range of use cases from security surveillance to media streaming applications.

For additional implementation examples and advanced usage scenarios, explore our GitHub repository with complete code samples.

## See also

- [Pre-Event Recording](../../guides/pre-event-recording/) — circular buffer recording with motion detection for IP cameras and webcams
- [IP Camera Capture to MP4](../../video-tutorials/ip-camera-capture-mp4/) — save IP camera video to MP4 file
- [Barcode & QR Code Scanner](../../../mediablocks/Guides/barcode-qr-reader-guide/) — scan barcodes and QR codes from IP camera video streams

---

Visit our [GitHub repository](https://github.com/visioforge/.Net-SDK-s-samples) for more comprehensive code samples and demo applications.

---END OF PAGE---


## NDI Video Capture and Source Integration in C# .NET
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-sources/ip-cameras/ndi/
**Description:** Discover, connect, preview, and capture NDI video sources using VisioForge Video Capture SDK. Includes Android and MAUI NDI player guidance for C# .NET.
**Tags:** Video Capture SDK, .NET, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Streaming, IP Camera, NDI Source, RTSP, ONVIF, NDI, C#
**API:** VideoCaptureCoreX, VideoCaptureCore, NDISourceSettings, NDISourceInfo, DeviceEnumerator, IPCameraSourceSettings

# Implementing NDI Video Sources in .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [VideoCaptureCoreX](#) [VideoCaptureCore](#)

Cross-platform support

The `VideoCaptureCoreX` engine with NDI runs on **Windows, macOS, Linux, Android, and iOS** via GStreamer; install the NDI runtime for each target platform. The classic `VideoCaptureCore` NDI source is Windows-only. See the [platform support matrix](../../../../platform-matrix/) and the [Linux deployment guide](../../../../deployment-x/Ubuntu/).

## Introduction to NDI Technology

Network Device Interface (NDI) is a high-performance standard for IP-based production workflows, developed by NewTek. It allows video-compatible products to communicate, deliver, and receive broadcast-quality video over a standard network connection with low latency.

Our SDK provides robust support for NDI sources, enabling your .NET applications to seamlessly integrate with NDI cameras and NDI-enabled software. This makes it ideal for live production environments, streaming applications, video conferencing solutions, and any system requiring high-quality network video integration.

### Prerequisites for NDI Integration

Before implementing NDI functionality in your application, you'll need to install one of the following:

- [NDI SDK](https://ndi.video/for-developers/ndi-sdk/#download) - Recommended for developers building professional applications
- NDI Tools - Sufficient for basic testing and development

These tools provide the necessary runtime components required for NDI communication. After installation, your system will be able to discover and connect to NDI sources on your network.

For Android playback, install the **NDI Advanced SDK for Android** and package the ABI-specific `libndi.so` files with your APK. The Android and MAUI NDI Player samples look for the SDK `Lib` directory using the `NdiAndroidSdkLib` MSBuild property, then the `NDI_ANDROID_SDK_LIB` environment variable, then `C:\Program Files\NDI\NDI 6 SDK (Android)\Lib`.

Android applications that discover NDI sources should request these permissions:

```
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />
```

## Discovering NDI Sources on Your Network

The first step in working with NDI is to enumerate available sources. Our SDK makes this process straightforward with dedicated methods to scan your network for NDI-enabled devices and applications.

### Enumerating Available NDI Sources

VideoCaptureCoreVideoCaptureCoreX

```
var lst = await VideoCapture1.IP_Camera_NDI_ListSourcesAsync();
foreach (var uri in lst)
{
    cbIPCameraURL.Items.Add(uri);
}
```

```
var lst = await DeviceEnumerator.Shared.NDISourcesAsync();
foreach (var uri in lst)
{
    cbIPCameraURL.Items.Add(uri.URL);
}
```

The asynchronous enumeration methods scan your network and return a list of available NDI sources. Each source has a unique identifier that you'll use to establish a connection. The enumeration process typically takes a few seconds, depending on network conditions and the number of available sources.

For player UI, subscribe to `NDISourcesChanged` and start the watcher so the source list reflects senders that appear or disappear after the initial scan:

```
DeviceEnumerator.Shared.NDISourcesChanged += OnNDISourcesChanged;
DeviceEnumerator.Shared.StartNDISourceWatch();
```

Stop the watcher and unsubscribe during shutdown.

## Connecting to NDI Sources

Once you've identified the NDI sources on your network, the next step is to establish a connection. This involves creating the appropriate settings object and configuring it for your specific requirements.

### Configuring NDI Source Settings

VideoCaptureCoreVideoCaptureCoreX

```
// Create an IP camera source settings object
settings = new IPCameraSourceSettings
{
    URL = new Uri("ndi://HOSTNAME/SourceName")
};

// Set the source type to NDI
settings.Type = IPSourceEngine.NDI;

// Enable or disable audio capture
settings.AudioCapture = false;

// Set login information if needed
settings.Login = "username";
settings.Password = "password";

// Set the source to the VideoCaptureCore object
VideoCapture1.IP_Camera_Source = settings;

// Select the operating mode before StartAsync:
//   IPPreview — live preview only (no file output).
//   IPCapture — preview + record to the configured Output_Format target.
VideoCapture1.Mode = VideoCaptureMode.IPPreview;   // or VideoCaptureMode.IPCapture

await VideoCapture1.StartAsync();
```

In VideoCaptureCoreX, you have two options for creating NDI source settings:

**Option 1: Using the NDI source URL**

```
var ndiSettings = await NDISourceSettings.CreateAsync(VideoCapture1.GetContext(), null, "NDI URL");
```

**Option 2: Using the NDI source name**

```
var ndiSettings = await NDISourceSettings.CreateAsync(VideoCapture1.GetContext(), cbIPURL.Text, null);
```

Finally, set the source to the VideoCaptureCoreX object:

```
VideoCapture1.Video_Source = ndiSettings;
```

## Android and MAUI NDI Player Pattern

The `Video Capture SDK X` Android and MAUI NDI Player demos use `VideoCaptureCoreX` as a simple NDI receiver/player. The same flow works for full-screen players, monitoring tools, and preview panels:

1. Initialize the SDK.
2. Enumerate NDI sources with `DeviceEnumerator.Shared.NDISourcesAsync()`.
3. Keep the list fresh with `NDISourcesChanged` and `StartNDISourceWatch()`.
4. Create `NDISourceSettings` from the selected `NDISourceInfo`.
5. Assign the settings to `VideoCaptureCoreX.Video_Source`.
6. Enable audio playback only when the selected source exposes audio streams.
7. Stop and dispose the core when playback stops or the view closes.

```
var sources = await DeviceEnumerator.Shared.NDISourcesAsync();
var info = sources[0];

var settings = await NDISourceSettings.CreateAsync(null, info);
if (settings == null || !settings.IsValid())
{
    throw new InvalidOperationException("Failed to create NDI source settings.");
}

var core = new VideoCaptureCoreX(videoView);
core.Video_Source = settings;
core.Audio_Play = settings.GetInfo()?.AudioStreams?.Count > 0;

await core.StartAsync();
```

### Android Native UI

The Android sample uses `VisioForge.Core.UI.Android.VideoViewGL` as the renderer surface:

```
var core = new VideoCaptureCoreX(videoView);
```

On Android, request the network and multicast permissions before discovery. If the app builds without `libndi.so` for the current ABI, playback fails at runtime with `DllNotFoundException`, so verify the NDI Advanced SDK `Lib` path before packaging.

### .NET MAUI UI

The MAUI sample registers VisioForge handlers in `MauiProgram`:

```
builder
    .UseMauiApp<App>()
    .ConfigureMauiHandlers(handlers => handlers.AddVisioForgeHandlers());
```

Create `VideoCaptureCoreX` with the platform view from the MAUI `VideoView`:

```
var core = new VideoCaptureCoreX(videoView.GetVideoView());
```

During shutdown, cancel pending source refreshes, unsubscribe from `NDISourcesChanged`, call `StopNDISourceWatch()`, stop/dispose `VideoCaptureCoreX`, and destroy the SDK if your app owns SDK lifetime.

## Advanced NDI Configuration Options

### Optimizing Performance

When working with NDI sources, performance considerations are important, especially in professional environments. Here are some tips to optimize your NDI implementation:

1. **Network Bandwidth**: Ensure your network has sufficient bandwidth for NDI streams. A typical HD NDI stream requires approximately 100-150 Mbps.
2. **Hardware Acceleration**: Enable hardware acceleration when available to reduce CPU usage and improve performance.
3. **Frame Rate Control**: Consider limiting the frame rate if you don't need the maximum quality, which can reduce network load.
4. **Resolution Settings**: Choose appropriate resolution settings based on your application's needs and available bandwidth.

### Managing Multiple NDI Sources

For applications that need to handle multiple NDI sources simultaneously:

1. Create separate capture instances for each NDI source
2. Implement resource pooling to efficiently manage system resources
3. Consider using a producer/consumer pattern for processing multiple streams
4. Monitor system performance and adjust settings as needed

## Error Handling and Troubleshooting

When implementing NDI functionality, it's important to handle potential issues gracefully:

### Common NDI Connection Issues

1. **Source Not Found**: Verify that the NDI source is active and on the same network
2. **Connection Timeout**: Check network configuration and firewall settings
3. **Authentication Failure**: Ensure credentials are correct if authentication is required
4. **Performance Issues**: Monitor CPU and network usage during capture

### Implementing Robust Error Handling

```
// The SDK does not expose NDI-specific exception types — the underlying GStreamer elements
// surface failures as generic Exception. Branch on the discovery result (null / empty) for
// "source not found", and on CreateAsync failure for connection issues.
try
{
    var discovered = await DeviceEnumerator.Shared.NDISourcesAsync();
    var match = discovered.FirstOrDefault(s => s.URL == ndiUrl);
    if (match == null)
    {
        Log.Error($"NDI source not found on the network: {ndiUrl}");
        return;
    }

    var ndiSettings = await NDISourceSettings.CreateAsync(VideoCapture1.GetContext(), match);
    VideoCapture1.Video_Source = ndiSettings;
}
catch (Exception ex)
{
    // All failures (discovery, settings creation, GStreamer element init, etc.)
    Log.Error($"Failed to connect to NDI source: {ex.Message}");
}
```

## Integration with Video Processing Workflows

NDI sources can be seamlessly integrated with other components of your video processing pipeline:

1. **Recording**: Capture NDI streams to various file formats
2. **Live Streaming**: Forward NDI content to streaming services
3. **Video Processing**: Apply filters and effects to NDI sources in real-time
4. **Multi-view Composition**: Combine multiple NDI sources into a single output

## Sample Applications and Code References

To help you get started with NDI implementation, we provide several sample applications that demonstrate different aspects of NDI functionality.

VideoCaptureCoreVideoCaptureCoreX

- [NDI source capture to MP4 format (WinForms)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/WinForms/CSharp/NDI%20Source)
- [Main SDK sample (WinForms)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/WinForms/CSharp/Main%20Demo)
- [NDI and other source sample (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/WPF/CSharp/IP_Capture)
- [Main SDK sample (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK/WPF/CSharp/Main_Demo)

- [NDI source preview (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WPF/CSharp/NDI%20Source%20Demo)
- [NDI (and other sources) preview and capture (WPF)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WPF/CSharp/IP%20Capture)
- [NDI Player (Android)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/Android/NDIPlayer)
- [NDI Player (MAUI)](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/MAUI/NDIPlayer)

## Best Practices for NDI Implementation

To ensure optimal performance and reliability when working with NDI sources:

1. **Perform Regular Source Enumeration**: Network conditions and available sources can change; re-enumerate sources periodically.
2. **Implement Connection Retry Logic**: Network disruptions can occur; implement automatic reconnection attempts.
3. **Monitor Stream Health**: Track frame rates, latency, and connection stability to detect potential issues.
4. **Handle Source Disconnections Gracefully**: Implement event handlers for unexpected disconnections.
5. **Test With Various NDI Sources**: Different NDI implementations may have slight variations; test with various sources.
6. **Package Android Native Libraries Per ABI**: For Android receivers, include `libndi.so` for every ABI you ship. Missing ABI libraries produce runtime failures even if the APK builds.
7. **Respect Mobile Lifecycle**: Stop playback when Android activities stop or MAUI pages/windows close, dispose the core, cancel source enumeration, and remove watcher event handlers.

## Conclusion

NDI technology offers powerful capabilities for network video integration in .NET applications. With our SDK, you can easily incorporate high-quality, low-latency video from NDI sources into your software projects. Whether you're building a live production system, a video conferencing application, or any solution requiring network video, our NDI implementation provides the tools you need for success.

The code samples provided demonstrate the essential patterns for working with NDI sources, from enumeration and connection to capture and processing. By following these patterns and best practices, you can create robust NDI-enabled applications that deliver exceptional performance and reliability.

## Related Documentation

- [IP cameras overview](../) — RTSP, ONVIF, and NDI source types at a glance
- [RTSP camera source configuration](../rtsp/) — most common IP camera protocol
- [ONVIF IP camera integration](../onvif/) — standards-based IP camera discovery and PTZ control
- [IP camera live preview tutorial](../../../video-tutorials/ip-camera-preview/) — minimal working preview example
- [RTSP protocol deep-dive](../../../../general/network-streaming/rtsp/) — streaming protocol internals
- [NDI streaming output guide](../../../../general/network-streaming/ndi/) — sending cameras, capture devices, and files to NDI

---

Visit our [GitHub](https://github.com/visioforge/.Net-SDK-s-samples) page to get more code samples.

---END OF PAGE---


## ONVIF IP Camera in C# .NET — Discovery & PTZ Control
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-sources/ip-cameras/onvif/
**Description:** Auto-discover ONVIF cameras via WS-Discovery, control PTZ presets, and record streams using VisioForge Video Capture SDK. C# examples and troubleshooting.
**Tags:** Video Capture SDK, Media Blocks SDK, .NET, DirectShow, MediaBlocksPipeline, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Streaming, Decoding, Webcam, IP Camera, NDI Source, RTSP, ONVIF, NDI, H.264, C#
**API:** RTSPSourceSettings, ONVIFClientX, VideoCaptureCoreX, MediaBlocksPipeline, RTSPSourceBlock

# ONVIF IP Camera Integration - Complete Guide

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [Media Blocks SDK .Net](https://www.visioforge.com/media-blocks-sdk-net)

Cross-platform support

ONVIF discovery and PTZ control work on both `VideoCaptureCore` (Windows-only, classic DirectShow) and `VideoCaptureCoreX` / Media Blocks SDK (cross-platform: **Windows, macOS, Linux, Android, and iOS** via GStreamer). See the [platform support matrix](../../../../platform-matrix/) and the [Linux deployment guide](../../../../deployment-x/Ubuntu/).

AI coding agents: use the VisioForge MCP server

Building this with **Claude Code**, **Cursor**, or another AI coding agent? Connect to the public [VisioForge MCP server](../../../../general/mcp-server-usage/) at `https://mcp.visioforge.com/mcp` for structured API lookups, runnable code samples, and deployment guides — more accurate than grepping `llms.txt`. No authentication required.

Claude Code: `claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp`

## Table of Contents

- [ONVIF IP Camera Integration - Complete Guide](#onvif-ip-camera-integration-complete-guide)
- [Table of Contents](#table-of-contents)
- [What is ONVIF?](#what-is-onvif)
- [Benefits of ONVIF Integration](#benefits-of-onvif-integration)
- [Camera Discovery and Enumeration](#camera-discovery-and-enumeration)
  - [Discovering ONVIF Cameras on Your Network](#discovering-onvif-cameras-on-your-network)
  - [Querying Camera Capabilities](#querying-camera-capabilities)
- [Connecting to ONVIF Cameras](#connecting-to-onvif-cameras)
  - [Basic Connection](#basic-connection)
- [Working with Media Profiles](#working-with-media-profiles)
- [Video Preview](#video-preview)
  - [Basic Preview Setup](#basic-preview-setup)
  - [Low-Latency Preview](#low-latency-preview)
- [PTZ (Pan-Tilt-Zoom) Control](#ptz-pan-tilt-zoom-control)
  - [Basic PTZ Operations](#basic-ptz-operations)
  - [PTZ Presets](#ptz-presets)
  - [Absolute Positioning](#absolute-positioning)
- [Camera Actions and Capabilities](#camera-actions-and-capabilities)
  - [Query Camera Capabilities](#query-camera-capabilities)
  - [Reboot Camera](#reboot-camera)
  - [Get System Date and Time](#get-system-date-and-time)
- [Turn Local Camera into ONVIF Source](#turn-local-camera-into-onvif-source)
- [Best Practices](#best-practices)
  - [Connection Management](#connection-management)
  - [Performance Optimization](#performance-optimization)
  - [Network Considerations](#network-considerations)
  - [Security](#security)
  - [Error Handling](#error-handling)
- [Troubleshooting](#troubleshooting)
  - [Common Issues](#common-issues)
  - ["Unable to connect to ONVIF camera"](#unable-to-connect-to-onvif-camera)
  - ["No cameras discovered"](#no-cameras-discovered)
  - ["Stream won't play"](#stream-wont-play)
  - ["High CPU usage during recording"](#high-cpu-usage-during-recording)
  - ["PTZ commands not working"](#ptz-commands-not-working)
  - [Diagnostic Tools](#diagnostic-tools)
  - [Enable Debug Logging](#enable-debug-logging)
  - [Test RTSP Connection](#test-rtsp-connection)
  - [Getting Help](#getting-help)
  - [Related Demos](#related-demos)

## What is ONVIF?

ONVIF (Open Network Video Interface Forum) is an industry standard protocol that enables seamless interoperability between network video products from different manufacturers. This protocol defines a common interface for IP-based security devices including cameras, NVRs (Network Video Recorders), and access control systems.

**Key Benefits:** - **Vendor Independence**: Work with cameras from different manufacturers using a unified API - **Standardized Communication**: Consistent methods for device discovery, streaming, and control - **Future-Proof**: New ONVIF-compliant devices work with existing applications - **Rich Feature Set**: Access to profiles, media streams, events, PTZ, and more

## Benefits of ONVIF Integration

- **Vendor Neutrality**: Build applications that work with cameras from multiple manufacturers
- **Future-Proof Development**: As new ONVIF-compliant cameras enter the market, your application will support them
- **Standardized Communication**: Consistent methods for device discovery, video streaming, and PTZ controls
- **Reduced Development Time**: No need to implement proprietary APIs for each camera brand
- **Advanced Features**: Access to profiles, media streams, events, and device management

## Camera Discovery and Enumeration

### Discovering ONVIF Cameras on Your Network

The first step in working with ONVIF cameras is discovering them on your local network using the WS-Discovery protocol.

```
using VisioForge.Core.ONVIFDiscovery;
using VisioForge.Core.ONVIFDiscovery.Models;

private Discovery _onvifDiscovery = new Discovery();
private CancellationTokenSource _cts;

// Discover cameras for 5 seconds
_cts = new CancellationTokenSource();

try
{
    await _onvifDiscovery.Discover(5, (device) =>
    {
        if (device.XAdresses?.Any() == true)
        {
            var address = device.XAdresses.FirstOrDefault();
            if (!string.IsNullOrEmpty(address))
            {
                Console.WriteLine($"Found camera at: {address}");
                // Add to your UI list, etc.
            }
        }
    }, _cts.Token);
}
catch (OperationCanceledException)
{
    // Discovery cancelled
}
```

**Key Features:** - **WS-Discovery Protocol**: Automatically discovers ONVIF-compliant cameras on the local network - **Timeout Control**: Specify discovery duration in seconds - **Async Callback**: Receive discovered devices in real-time as they respond - **Cancellation Support**: Cancel discovery using CancellationToken

### Querying Camera Capabilities

Once discovered, you can connect to a camera and query its capabilities:

```
using VisioForge.Core.ONVIFX;

var onvifClient = new ONVIFClientX();
var result = await onvifClient.ConnectAsync(cameraUrl, username, password);

if (result)
{
    // Get device information
    var deviceInfo = onvifClient.DeviceInformation;
    Console.WriteLine($"Camera: {deviceInfo?.Model}, S/N: {deviceInfo?.SerialNumber}");

    // Get available profiles
    var profiles = await onvifClient.GetProfilesAsync();
    if (profiles != null)
    {
        foreach (var profile in profiles)
        {
            var mediaUri = await onvifClient.GetStreamUriAsync(profile);
            if (mediaUri != null)
            {
                Console.WriteLine($"Profile: {profile.Name}, URI: {mediaUri.Uri}");
            }
        }
    }
}
```

## Connecting to ONVIF Cameras

### Basic Connection

```
using VisioForge.Core.ONVIFX;

// Connect to ONVIF camera
var onvifClient = new ONVIFClientX();
var connected = await onvifClient.ConnectAsync(
    "http://192.168.1.100:80/onvif/device_service",
    "admin",
    "password");

if (connected)
{
    Console.WriteLine("Successfully connected to camera");
}
else
{
    Console.WriteLine("Connection failed");
}
```

## Working with Media Profiles

ONVIF cameras typically provide multiple media profiles with different resolutions, codecs, and frame rates.

```
// Get all available profiles
var profiles = await onvifClient.GetProfilesAsync();

if (profiles != null && profiles.Length > 0)
{
    foreach (var profile in profiles)
    {
        Console.WriteLine($"Profile: {profile.Name}");
        Console.WriteLine($"Token: {profile.token}");

        // Get stream URI for this profile
        var mediaUri = await onvifClient.GetStreamUriAsync(profile);
        if (mediaUri != null)
        {
            Console.WriteLine($"  Stream URI: {mediaUri.Uri}");
        }
    }

    // Use the first profile
    var selectedProfile = profiles[0];
    var streamUri = await onvifClient.GetStreamUriAsync(selectedProfile);
}
```

## Video Preview

### Basic Preview Setup

Media Blocks SDKVideo Capture SDK

```
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.MediaBlocks.AudioRendering;
using VisioForge.Core.Types.X.Sources;

// Create pipeline
var pipeline = new MediaBlocksPipeline();

// Get RTSP URL from ONVIF profile
var streamUri = await onvifClient.GetStreamUriAsync(profile);

// Create RTSP source
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri(streamUri.Uri),
    username,
    password,
    true); // enable audio

var rtspSource = new RTSPSourceBlock(rtspSettings);

// Create video renderer
var videoRenderer = new VideoRendererBlock(pipeline, videoView);

// Connect blocks
pipeline.Connect(rtspSource.VideoOutput, videoRenderer.Input);

// Optional: Add audio rendering
var audioRenderer = new AudioRendererBlock();
pipeline.Connect(rtspSource.AudioOutput, audioRenderer.Input);

// Start preview
await pipeline.StartAsync();
```

```
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.VideoCaptureX;

// Create video capture engine
var videoCapture = new VideoCaptureCoreX(videoView);

// Get stream URI from ONVIF
var streamUri = await onvifClient.GetStreamUriAsync(profile);

// Create RTSP source settings
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri(streamUri.Uri),
    username,
    password,
    true); // enable audio

// Set video source
videoCapture.Video_Source = rtspSettings;

// Configure audio
videoCapture.Audio_Record = true;
videoCapture.Audio_Play = true;

// Start preview
await videoCapture.StartAsync();
```

### Low-Latency Preview

For real-time surveillance and monitoring applications, enable low-latency mode:

Media Blocks SDKVideo Capture SDK

```
// Create RTSP source with low latency
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri(streamUri.Uri),
    username,
    password,
    true);

// Enable low latency mode (150ms jitter buffer vs the default 500ms)
rtspSettings.LowLatencyMode = true;

var rtspSource = new RTSPSourceBlock(rtspSettings);
var videoRenderer = new VideoRendererBlock(pipeline, videoView);

// Disable sync for even lower latency
videoRenderer.IsSync = false;

pipeline.Connect(rtspSource.VideoOutput, videoRenderer.Input);
await pipeline.StartAsync();
```

```
// Create RTSP source
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri(streamUri.Uri),
    username,
    password,
    true);

// Enable low latency mode
rtspSettings.LowLatencyMode = true;

videoCapture.Video_Source = rtspSettings;
videoCapture.Audio_Record = true;
videoCapture.Audio_Play = true;

await videoCapture.StartAsync();
```

## PTZ (Pan-Tilt-Zoom) Control

### Basic PTZ Operations

```
using VisioForge.Core.ONVIFX;
using VisioForge.Core.ONVIFX.PTZ;

// Connect to camera
var onvifClient = new ONVIFClientX();
await onvifClient.ConnectAsync(cameraUrl, username, password);

// Get profile token
var profiles = await onvifClient.GetProfilesAsync();
var profileToken = profiles[0].token;

// The lightweight scalar overload of ContinuousMoveAsync takes pan/tilt/zoom
// speed floats directly (range -1.0..1.0; 0 = no motion on that axis).

// Pan right
await onvifClient.ContinuousMoveAsync(profileToken, pan: 0.5f, tilt: 0f, zoom: 0f);

// Pan left
await onvifClient.ContinuousMoveAsync(profileToken, pan: -0.5f, tilt: 0f, zoom: 0f);

// Tilt up
await onvifClient.ContinuousMoveAsync(profileToken, pan: 0f, tilt: 0.5f, zoom: 0f);

// Tilt down
await onvifClient.ContinuousMoveAsync(profileToken, pan: 0f, tilt: -0.5f, zoom: 0f);

// Zoom in
await onvifClient.ContinuousMoveAsync(profileToken, pan: 0f, tilt: 0f, zoom: 0.5f);

// Zoom out
await onvifClient.ContinuousMoveAsync(profileToken, pan: 0f, tilt: 0f, zoom: -0.5f);

// Stop movement on both axes
await onvifClient.StopMoveAsync(profileToken, panTilt: true, zoom: true);
```

### PTZ Presets

```
// Get available presets
var presets = await onvifClient.GetPresetsAsync(profileToken);

foreach (var preset in presets)
{
    Console.WriteLine($"Preset: {preset.Name}, Token: {preset.token}");
}

// Go to preset (home position)
if (presets != null && presets.Length > 0)
{
    await onvifClient.GoToPresetAsync(
        profileToken,
        presets[0].token,
        panSpeed:  1.0f,
        tiltSpeed: 1.0f,
        zoomSpeed: 1.0f);
}

// Set current position as preset
await onvifClient.SetPresetAsync(profileToken, "MyPreset");
```

### Absolute Positioning

```
// Move to absolute pan + tilt + zoom position with per-axis speeds
await onvifClient.AbsoluteMoveAsync(
    profileToken,
    pan:       0.5f,
    tilt:      0.3f,
    zoom:      0.7f,
    panSpeed:  1.0f,
    tiltSpeed: 1.0f,
    zoomSpeed: 1.0f);
```

## Camera Actions and Capabilities

### Query Camera Capabilities

```
using VisioForge.Core.ONVIFX;

var onvifClient = new ONVIFClientX();
await onvifClient.ConnectAsync(cameraUrl, username, password);

// Get device information
var deviceInfo = onvifClient.DeviceInformation;
Console.WriteLine($"Manufacturer: {deviceInfo?.Manufacturer}");
Console.WriteLine($"Model: {deviceInfo?.Model}");
Console.WriteLine($"Firmware: {deviceInfo?.FirmwareVersion}");
Console.WriteLine($"Serial Number: {deviceInfo?.SerialNumber}");
Console.WriteLine($"Hardware ID: {deviceInfo?.HardwareId}");

// Get service capabilities
var capabilities = await onvifClient.GetCapabilitiesAsync();

// Check for PTZ support
if (capabilities?.PTZ != null)
{
    Console.WriteLine("PTZ supported");
}

// Check for analytics
if (capabilities?.Analytics != null)
{
    Console.WriteLine("Analytics supported");
}

// Check for events
if (capabilities?.Events != null)
{
    Console.WriteLine("Events supported");
}
```

### Reboot Camera

```
await onvifClient.SystemRebootAsync();
```

### Get System Date and Time

```
var dateTime = await onvifClient.GetSystemDateAndTimeAsync();
Console.WriteLine($"Camera time: {dateTime}");
```

## Turn Local Camera into ONVIF Source

Convert your local USB/webcam into an IP stream that ONVIF clients can consume. The `RTSP Webcam Server` console demo included with the Media Blocks SDK exposes a DirectShow camera as an RTSP endpoint that ONVIF recorders and VMS software can ingest.

Media Blocks SDKVideo Capture SDK

```
using System;
using System.Threading;
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.VideoCapture;

Console.WriteLine("Initializing VisioForge SDK.");
VisioForgeX.InitSDK();

var cameras = DeviceEnumerator.Shared.VideoSources();
Console.WriteLine("Select the web camera");
for (int i = 0; i < cameras.Length; i++)
{
    Console.WriteLine($"{i + 1}: {cameras[i].DisplayName}");
}

Console.Write("Enter the number of the camera: ");
VideoCaptureDeviceInfo cameraInfo = null;
if (int.TryParse(Console.ReadLine(), out int cameraIndex) && cameraIndex > 0 && cameraIndex <= cameras.Length)
{
    cameraInfo = cameras[cameraIndex - 1];
    Console.WriteLine($"Selected camera: {cameraInfo.DisplayName}");
}
else
{
    Console.WriteLine("Invalid selection. Exiting.");

    VisioForgeX.DestroySDK();
    return;
}

var pipeline = new MediaBlocksPipeline();

var videoSourceSettings = new VideoCaptureDeviceSourceSettings(cameraInfo);
videoSourceSettings.Format = cameraInfo.GetHDVideoFormatAndFrameRate(out var frameRate).ToFormat();
videoSourceSettings.Format.FrameRate = frameRate;

var cameraSource = new SystemVideoSourceBlock(videoSourceSettings);

var rtspServerSettings = new RTSPServerSettings(H264EncoderBlock.GetDefaultSettings(), null)
{
    Port = 8554,
};

var rtspBlock = new RTSPServerBlock(rtspServerSettings);

Console.WriteLine("RTSP Server URL: " + rtspBlock.Settings.URL);

pipeline.Connect(cameraSource.Output, rtspBlock.Input);

Console.WriteLine("Starting the pipeline...");

new Thread(() =>
{
    pipeline.Start();
}).Start();

Console.WriteLine("Pipeline started. Press any key to stop the server and exit.");
Console.ReadKey();

Console.WriteLine("Stopping the pipeline...");

pipeline.Stop();

Console.WriteLine("Pipeline stopped.");

pipeline.Dispose();

VisioForgeX.DestroySDK();
```

```
// ONVIF/RTSP server functionality is provided by the Media Blocks SDK.
```

## Best Practices

### Connection Management

1. **Always dispose of ONVIF clients properly:**

   ```
   using (var onvifClient = new ONVIFClientX())
   {
       await onvifClient.ConnectAsync(url, username, password);
       // ... use client ...
   } // Automatically disposed
   ```
2. **Handle connection failures gracefully:**

   ```
   var maxRetries = 3;
   var retryCount = 0;

   while (retryCount < maxRetries)
   {
       try
       {
           var connected = await onvifClient.ConnectAsync(url, user, pass);
           if (connected)
               break;
       }
       catch (Exception ex)
       {
           Console.WriteLine($"Connection attempt {retryCount + 1} failed: {ex.Message}");
       }

       retryCount++;
       await Task.Delay(2000); // Wait before retry
   }
   ```
3. **Use cancellation tokens for discovery:**

   ```
   var cts = new CancellationTokenSource();
   cts.CancelAfter(TimeSpan.FromSeconds(10));

   await _onvifDiscovery.Discover(10, callback, cts.Token);
   ```

### Performance Optimization

1. **Use RTSPRAWSourceBlock for recording without re-encoding** - significantly reduces CPU usage
2. **Enable low-latency mode only when needed** - trades stability for speed
3. **Limit concurrent streams** based on your hardware capabilities
4. **Use hardware decoders** when available:

   ```
   rtspSettings.UseGPUDecoder = true;
   ```

### Network Considerations

1. **Use TCP for reliable connections** (`AllowedProtocols` is a `RTSPSourceProtocol` flag-enum — set it to force a specific transport):

   ```
   rtspSettings.AllowedProtocols = RTSPSourceProtocol.TCP;
   ```
2. **Tune jitter-buffer latency** (there is no standalone `Timeout` property; `Latency` controls the RTSP jitter-buffer — higher values trade latency for stability over lossy networks):

   ```
   rtspSettings.Latency = TimeSpan.FromMilliseconds(1000);
   ```
3. **Monitor for disconnections:**

   ```
   pipeline.OnError += (sender, e) =>
   {
       if (e.Message.Contains("disconnect"))
       {
           // Attempt reconnection
       }
   };
   ```

### Security

1. **Never hardcode credentials** - use configuration files or secure storage
2. **Use HTTPS for web streaming** when possible
3. **Implement authentication** for streaming endpoints
4. **Validate user input** when constructing URLs
5. **Keep credentials in memory for minimal time**

### Error Handling

1. **Log all errors for diagnostics:**

   ```
   pipeline.OnError += (sender, e) =>
   {
       Logger.Error($"Pipeline error: {e.Message}");
   };
   ```
2. **Enable debug mode during development:**

   ```
   pipeline.Debug_Mode = true;
   pipeline.Debug_Dir = @"C:\Logs\VisioForge";
   ```
3. **Handle stream interruptions:**

   ```
   // Implement auto-reconnect logic
   var reconnectAttempts = 0;
   const int maxReconnects = 5;

   pipeline.OnError += async (sender, e) =>
   {
       if (reconnectAttempts < maxReconnects)
       {
           reconnectAttempts++;
           await Task.Delay(5000);
           await pipeline.StopAsync();
           await pipeline.StartAsync();
       }
   };
   ```

## Troubleshooting

### Common Issues

#### "Unable to connect to ONVIF camera"

**Possible causes:** - Incorrect URL format (should be: `http://IP:PORT/onvif/device_service`) - Wrong credentials - Network firewall blocking connection - Camera's ONVIF service disabled

**Solutions:**

```
// Try different URL formats
var urls = new[]
{
    "http://192.168.1.100:80/onvif/device_service",
    "http://192.168.1.100:8080/onvif/device_service",
    "http://192.168.1.100/onvif/device_service"
};

foreach (var url in urls)
{
    if (await onvifClient.ConnectAsync(url, user, pass))
    {
        Console.WriteLine($"Connected using: {url}");
        break;
    }
}
```

#### "No cameras discovered"

**Possible causes:** - Cameras on different subnet - Multicast blocked by network - Firewall blocking WS-Discovery

**Solutions:** 1. Check network configuration 2. Try direct connection with known IP 3. Verify camera ONVIF support is enabled 4. Increase discovery timeout

#### "Stream won't play"

**Possible causes:** - Codec not supported - Network bandwidth insufficient - Incorrect stream URL

**Solutions:**

```
// Read and cache stream info before starting the pipeline. ReadInfoAsync
// probes the camera; GetInfo() returns the cached MediaFileInfo afterwards.
var info = await rtspSettings.ReadInfoAsync();
if (info == null)
{
    Console.WriteLine("Cannot get stream info - check URL");
    return;
}

Console.WriteLine($"Video codec: {info.VideoStreams[0].Codec}");
Console.WriteLine($"Resolution: {info.VideoStreams[0].Width}x{info.VideoStreams[0].Height}");
Console.WriteLine($"Bitrate: {info.VideoStreams[0].Bitrate}");
```

#### "High CPU usage during recording"

**Possible causes:** - Re-encoding when not necessary - Too many concurrent streams - Software decoding instead of hardware

**Solutions:** 1. Use `RTSPRAWSourceBlock` for recording without re-encoding 2. Enable hardware decoder:

```
rtspSettings.UseGPUDecoder = true;
```

3. Limit concurrent streams 4. Lower resolution/bitrate at camera

#### "PTZ commands not working"

**Possible causes:** - Camera doesn't support PTZ - Wrong profile selected - PTZ service not enabled

**Solutions:**

```
// Check PTZ capabilities
var capabilities = await onvifClient.GetCapabilitiesAsync();
if (capabilities?.PTZ != null)
{
    Console.WriteLine("PTZ is supported");

    // Get PTZ configuration
    var profiles = await onvifClient.GetProfilesAsync();
    foreach (var profile in profiles)
    {
        Console.WriteLine($"Profile: {profile.Name}, Token: {profile.token}");
    }
}
else
{
    Console.WriteLine("PTZ not supported by this camera");
}
```

### Diagnostic Tools

#### Enable Debug Logging

Media Blocks SDKVideo Capture SDK

```
pipeline.Debug_Mode = true;
pipeline.Debug_Dir = Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
    "VisioForge",
    "Logs");
```

```
videoCapture.Debug_Mode = true;
videoCapture.Debug_Dir = Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
    "VisioForge",
    "Logs");
```

#### Test RTSP Connection

```
// Test if RTSP URL is valid
var rtspSettings = await RTSPSourceSettings.CreateAsync(
    new Uri(rtspUrl),
    username,
    password,
    true);

var info = await rtspSettings.ReadInfoAsync();
if (info != null)
{
    Console.WriteLine("✓ RTSP connection successful");
    Console.WriteLine($"  Video streams: {info.VideoStreams.Count}");
    Console.WriteLine($"  Audio streams: {info.AudioStreams.Count}");

    foreach (var stream in info.VideoStreams)
    {
        Console.WriteLine($"  Video: {stream.Codec} {stream.Width}x{stream.Height}");
    }
}
else
{
    Console.WriteLine("✗ RTSP connection failed");
}
```

### Getting Help

- **Sample Code**: [GitHub Samples Repository](https://github.com/visioforge/.Net-SDK-s-samples)
- **Documentation**: [VisioForge Documentation](https://www.visioforge.com/help/)
- **Support Forum**: [VisioForge Support](https://support.visioforge.com)

### Related Demos

- [RTSP MultiView Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WinForms/CSharp/RTSP%20MultiView%20Demo) - Recording multiple cameras without re-encoding
- [RTSP Preview Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Media%20Blocks%20SDK/WPF/CSharp/RTSP%20Preview%20Demo) - Preview and recording with postprocessing
- [IP Capture Demo](https://github.com/visioforge/.Net-SDK-s-samples/tree/master/Video%20Capture%20SDK%20X/WPF/CSharp/IP%20Capture) - Comprehensive IP camera integration with PTZ control
- [IP Camera Brands Directory](../../../../camera-brands/) - RTSP URLs and connection guides for 60+ camera manufacturers

### Related Documentation

- [RTSP camera source configuration](../rtsp/) — `IPCameraSourceSettings` and `RTSPSourceSettings` reference with UDP/TCP tuning
- [RTSP protocol deep-dive](../../../../general/network-streaming/rtsp/) — protocol internals and streaming architecture
- [NDI source integration](../ndi/) — professional video-over-IP alternative to ONVIF/RTSP
- [IP camera live preview tutorial](../../../video-tutorials/ip-camera-preview/) — video walkthrough with a minimal C# example
- [Record RTSP to MP4 tutorial](../../../video-tutorials/ip-camera-capture-mp4/) — capture ONVIF-discovered cameras to file
- [Media Blocks RTSP player](../../../../mediablocks/Guides/rtsp-player-csharp/) — pipeline-based RTSP playback
- [Multi-camera RTSP grid (NVR wall)](../../../../mediablocks/Guides/multi-camera-rtsp-grid/) — 4×4 live preview wall for WPF and MAUI, with ONVIF-discovered cameras
- [RTSP reconnection and fallback switch](../../../../general/network-sources/reconnection-and-fallback/) — handle camera drops with disconnect events and automatic `FallbackSwitch`

---END OF PAGE---


## RTSP Camera Streaming in C# .NET — UDP and TCP Modes
**URL:** https://www.visioforge.com/help/docs/dotnet/videocapture/video-sources/ip-cameras/rtsp/
**Description:** Connect to RTSP camera streams using VisioForge Video Capture SDK. Low-latency configuration, UDP/TCP transport options, and C# code examples.
**Tags:** Video Capture SDK, .NET, VideoCaptureCoreX, Windows, macOS, Linux, Android, iOS, GStreamer, Capture, Streaming, IP Camera, NDI Source, RTSP, ONVIF, NDI, UDP, C#
**API:** VideoCaptureCoreX, VideoCaptureCore, RTSPSourceSettings, IPCameraSourceSettings, IPSourceEngine

# Integrating RTSP Camera Streams in .NET Applications

[Video Capture SDK .Net](https://www.visioforge.com/video-capture-sdk-net) [VideoCaptureCoreX](#) [VideoCaptureCore](#)

Cross-platform support

The `VideoCaptureCoreX` engine runs on **Windows, macOS, Linux, Android, and iOS** via GStreamer; the classic `VideoCaptureCore` engine is Windows-only. See the [platform support matrix](../../../../platform-matrix/) for codec and hardware-acceleration details, and the [Linux deployment guide](../../../../deployment-x/Ubuntu/) for Ubuntu / NVIDIA Jetson / Raspberry Pi setup.

## Setting Up Standard RTSP Camera Sources

Implementing RTSP camera streams in your .NET applications provides flexible access to network cameras and video streams. This powerful capability allows real-time monitoring, surveillance features, and video processing directly within your application.

VideoCaptureCoreVideoCaptureCoreX

For additional connection options and alternative protocols, please reference our detailed [IP cameras](../) documentation which covers a wide range of camera integration approaches.

```
// Create RTSP source settings object
var rtsp = await RTSPSourceSettings.CreateAsync(new Uri("rtsp://192.168.1.1:554/live"), "login", "password", true /*capture audio?*/);

// Set source to the VideoCaptureCoreX object
VideoCapture1.Video_Source = rtsp;
```

## Optimizing for Low-Latency RTSP Streaming

Low latency is critical for many real-time applications including security monitoring, interactive systems, and live broadcasting. Our SDK provides specialized configurations to minimize delay between capture and display.

VideoCaptureCoreVideoCaptureCoreX

Our SDK includes a dedicated mode specifically engineered for low-latency RTSP streaming. When properly configured, this mode typically achieves latency under 250 milliseconds, making it ideal for time-sensitive applications.

```
// Create the source settings object.
var settings = new IPCameraSourceSettings();

// Configure IP address, username, password, etc.
// ...

// Set RTSP LowLatency mode.
settings.Type = IPSourceEngine.RTSP_LowLatency;

// Set UDP or TCP mode.
settings.RTSP_LowLatency_UseUDP = false; // true to use UDP, f