# Creating Custom Video Output Formats with DirectShow Filters

Video Capture SDK .Net Video Edit SDK .Net

VideoCaptureCore VideoEditCore

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.

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)

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.

There are two primary approaches to implementing custom format output with DirectShow filters:

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.

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);
}

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;

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.

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.

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.

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();

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

To use custom DirectShow filters, ensure you have the appropriate redistributable packages installed:

• x86 Package
• x64 Package

• x86 Package
• x64 Package

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.

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.