# MOV File Output for .NET Video Applications

Video Capture SDK .Net Video Edit SDK .Net Media Blocks SDK .Net

VideoCaptureCoreX VideoEditCoreX MediaBlocksPipeline

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.

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

The MOVOutput class (API reference) provides the foundation for MOV file generation with VisioForge SDKs. It encapsulates the configuration of video and audio encoders, processing parameters, and sink settings.

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

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.

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.

The MOV output supports these video encoders:

Set a specific video encoder with code like this:

// For NVIDIA hardware-accelerated encoding
movOutput.Video = new NVENCH264EncoderSettings() {
    Bitrate = 5000000,  // 5 Mbps
};

// For software-based encoding with OpenH264
movOutput.Video = new OpenH264EncoderSettings() {
    RateControl = RateControlMode.VBR,
    Bitrate = 2500000  // 2.5 Mbps
};

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 quality is critical for most video applications. The SDK provides several audio encoders optimized for different use cases.

Implementing audio encoding requires minimal code:

// MP3 configuration
movOutput.Audio = new MP3EncoderSettings() {
    Bitrate = 320000,  // 320 kbps high quality
    Channels = 2       // Stereo
};

// Or AAC for better quality (Windows)
movOutput.Audio = new MFAACEncoderSettings() {
    Bitrate = 192000   // 192 kbps
};

// Cross-platform AAC implementation
movOutput.Audio = new VOAACEncoderSettings() {
    Bitrate = 192000,
    SampleRate = 48000
};

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

Beyond basic configuration, VisioForge SDKs enable powerful customization of MOV output through media processing blocks and sink settings.

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

Fine-tune the MOV container settings for specialized requirements:

// Configure sink settings
movOutput.Sink.Filename = "new_output.mov";

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

The MOV output integrates seamlessly with the core SDK components for video capture, editing, and processing.

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

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

For direct media pipeline control:

// Create encoder instances
var aac = new VOAACEncoderSettings();
var h264 = new OpenH264EncoderSettings();

// Configure MOV sink
var movSinkSettings = new MOVSinkSettings("output.mov");

// Create output block
// Note: MP4OutputBlock handles MOV output (MOV is a subset of MP4)
var movOutput = new MP4OutputBlock(movSinkSettings, h264, aac);

// Add to pipeline
pipeline.AddBlock(movOutput);

While VisioForge's MOV implementation is cross-platform, some features are platform-specific:

• MF HEVC video encoder provides optimized encoding on Windows
• MF AAC audio encoder offers hardware acceleration on compatible systems

• OpenH264, NVENC, QSV, and AMF encoders work across operating systems
• VO-AAC and AVENC AAC provide consistent audio encoding everywhere

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 or explore other output formats in our documentation.