NET Vocal Remover API

using OwnaudioNET.Features.Vocalremover;

// Create service with custom options
var options = new SimpleSeparationOptions
{
    Model = InternalModel.Best,
    OutputDirectory = "output",
    ChunkSizeSeconds = 15,
    DisableNoiseReduction = false
};

var service = new SimpleAudioSeparationService(options);
service.Initialize();

// Separate audio file
SimpleSeparationResult result = service.Separate("input.mp3");

Console.WriteLine($"Vocals: {result.VocalsPath}");
Console.WriteLine($"Instrumental: {result.InstrumentalPath}");
Console.WriteLine($"Processing time: {result.ProcessingTime}");

public class SimpleSeparationOptions
{
    // ONNX model file path (optional if using internal models)
    public string? ModelPath { get; set; }

    // Internal model selection (Default, Best, Karaoke)
    public InternalModel Model { get; set; } = InternalModel.Best;

    // Output directory path
    public string OutputDirectory { get; set; } = "separated";

    // Disable noise reduction (enabled by default)
    public bool DisableNoiseReduction { get; set; } = false;

    // Margin size for overlapping chunks (in samples, default: 44100 = 1 second)
    public int Margin { get; set; } = 44100;

    // Chunk size in seconds (0 = process entire file at once)
    public int ChunkSizeSeconds { get; set; } = 15;

    // FFT size for STFT processing
    public int NFft { get; set; } = 6144;

    // Temporal dimension parameter (as power of 2)
    public int DimT { get; set; } = 8;

    // Frequency dimension parameter
    public int DimF { get; set; } = 2048;
}

public class SimpleSeparationProgress
{
    // Current file being processed
    public string CurrentFile { get; set; }

    // Overall progress percentage (0-100)
    public double OverallProgress { get; set; }

    // Current processing step description
    public string Status { get; set; }

    // Number of chunks processed
    public int ProcessedChunks { get; set; }

    // Total number of chunks
    public int TotalChunks { get; set; }
}

public class SimpleSeparationResult
{
    // Path to the vocals output file
    public string VocalsPath { get; set; }

    // Path to the instrumental output file
    public string InstrumentalPath { get; set; }

    // Processing duration
    public TimeSpan ProcessingTime { get; set; }
}

public enum InternalModel
{
    None,      // Use custom model file via ModelPath
    Default,   // Balanced quality and speed
    Best,      // Highest quality, longer processing time
    Karaoke    // Preserve background vocals, remove lead vocal
}

// Usage examples
var options1 = new SimpleSeparationOptions { Model = InternalModel.Default };
var options2 = new SimpleSeparationOptions { Model = InternalModel.Best };
var options3 = new SimpleSeparationOptions { Model = InternalModel.Karaoke };

// Custom model
var options4 = new SimpleSeparationOptions
{
    Model = InternalModel.None,
    ModelPath = @"C:\Models\custom_model.onnx"
};

using OwnaudioNET.Features.HTDemucs;

// Create HTDemucs separator with embedded model
var options = new HTDemucsSeparationOptions
{
    Model = InternalModel.HTDemucs,  // Use embedded resource
    OutputDirectory = "output_htdemucs",
    ChunkSizeSeconds = 10,           // Chunk size (10-30s recommended)
    OverlapFactor = 0.25f,           // Overlap between chunks (0.25 = 25%)
    EnableGPU = true,                // Use GPU acceleration
    TargetStems = HTDemucsStem.All   // Extract all stems
};

using var separator = new HTDemucsAudioSeparator(options);
separator.Initialize();

// Progress tracking
separator.ProgressChanged += (s, progress) =>
{
    Console.WriteLine($"{progress.Status}: {progress.OverallProgress:F1}%");
    Console.WriteLine($"Chunks: {progress.ProcessedChunks}/{progress.TotalChunks}");
};

// Separate audio into stems
var result = separator.Separate("music.mp3");

Console.WriteLine($"Vocals: {result.VocalsPath}");
Console.WriteLine($"Drums: {result.DrumsPath}");
Console.WriteLine($"Bass: {result.BassPath}");
Console.WriteLine($"Other: {result.OtherPath}");
Console.WriteLine($"Processing time: {result.ProcessingTime}");

// Extract only vocals and other instruments
var options = new HTDemucsSeparationOptions
{
    Model = InternalModel.HTDemucs,
    OutputDirectory = "output",
    TargetStems = HTDemucsStem.Vocals | HTDemucsStem.Other
};

// Extract only drums
var drumsOnly = new HTDemucsSeparationOptions
{
    Model = InternalModel.HTDemucs,
    OutputDirectory = "drums_output",
    TargetStems = HTDemucsStem.Drums
};

// Using helper methods
using var separator = HTDemucsExtensions.CreateDefaultSeparator("output_directory");
separator.Initialize();
var result = separator.Separate("music.mp3");

using OwnaudioNET.Features.Vocalremover;

public class MultiModelSeparationOptions
{
    // List of models to include in the averaging pipeline
    public List<MultiModelInfo> Models { get; set; } = new();

    // Output directory for final and intermediate files
    public string OutputDirectory { get; set; } = "separated_multimodel";

    // Enable GPU acceleration (CUDA on Windows/Linux, CoreML on macOS)
    public bool EnableGPU { get; set; } = true;

    // Overlap margin in samples between chunks (default: 44100 = 1 s)
    public int Margin { get; set; } = 44100;

    // Chunk size in seconds (0 = process entire file at once)
    public int ChunkSizeSeconds { get; set; } = 15;

    // Save individual model outputs to disk (useful for debugging)
    public bool SaveAllIntermediateResults { get; set; } = false;
}

public class MultiModelInfo
{
    // Human-readable name shown in progress events and output filenames
    public string Name { get; set; } = "Model";

    // ONNX model file path (leave null/empty to use an embedded InternalModel)
    public string? ModelPath { get; set; }

    // Embedded model selection (Default, Best, Karaoke, …)
    public InternalModel Model { get; set; } = InternalModel.None;

    // FFT size for STFT (0 = auto-detect from ONNX metadata)
    public int NFft { get; set; } = 6144;

    // Time dimension as power of 2 (2^DimT frames)
    public int DimT { get; set; } = 8;

    // Frequency dimension
    public int DimF { get; set; } = 2048;

    // Disable noise reduction for this specific model
    public bool DisableNoiseReduction { get; set; } = false;

    // Save this model's individual output (independent of SaveAllIntermediateResults)
    public bool SaveIntermediateOutput { get; set; } = false;

    // Explicit output type — leave null for auto-detection
    public ModelOutputType? OutputType { get; set; } = null;
}

public enum ModelOutputType
{
    // Model directly outputs the instrumental track.
    // Vocals = Original − Instrumental
    Instrumental,

    // Model directly outputs the vocal track.
    // Instrumental = Original − Vocals
    Vocals
}

public class MultiModelSeparationProgress
{
    public string CurrentFile { get; set; }        // File being processed
    public double OverallProgress { get; set; }    // 0–100 %
    public string Status { get; set; }             // Human-readable step description
    public int CurrentModelIndex { get; set; }     // 1-based model index
    public int TotalModels { get; set; }           // Total number of models
    public string CurrentModelName { get; set; }   // Name of the active model
    public int ProcessedChunks { get; set; }       // Chunks done for current model
    public int TotalChunks { get; set; }           // Total chunks for current model
}

public class MultiModelSeparationResult
{
    public string OutputPath { get; set; }         // Same as InstrumentalPath
    public string VocalsPath { get; set; }         // Averaged vocals WAV file
    public string InstrumentalPath { get; set; }   // Averaged instrumental WAV file
    public Dictionary<string, string> IntermediatePaths { get; set; }  // Per-model outputs
    public TimeSpan ProcessingTime { get; set; }   // Wall-clock processing duration
    public int ModelsProcessed { get; set; }       // Number of models that contributed
}

using OwnaudioNET.Features.Vocalremover;

// Convenience factory: creates a 2-model averaging pipeline
using var separator = MultiModelExtensions.CreateSimplePipeline(
    model1: InternalModel.Best,
    model2: InternalModel.Karaoke,
    outputDirectory: "output"
);

separator.ProgressChanged += (s, p) =>
    Console.WriteLine($"[Model {p.CurrentModelIndex}/{p.TotalModels}] {p.OverallProgress:F1}%");

separator.Initialize();
var result = separator.Separate("song.mp3");

Console.WriteLine($"Vocals:       {result.VocalsPath}");
Console.WriteLine($"Instrumental: {result.InstrumentalPath}");
Console.WriteLine($"Time:         {result.ProcessingTime}");

using var separator = MultiModelExtensions.CreateTriplePipeline(
    model1: InternalModel.Best,
    model2: InternalModel.Default,
    model3: InternalModel.Karaoke,
    outputDirectory: "output_triple"
);

separator.Initialize();
var result = separator.Separate("song.flac");

// Final averaged outputs
Console.WriteLine($"Vocals:       {result.VocalsPath}");
Console.WriteLine($"Instrumental: {result.InstrumentalPath}");

// Intermediate per-model outputs (saved because the helper enables it)
foreach (var kv in result.IntermediatePaths)
    Console.WriteLine($"  {kv.Key}: {kv.Value}");

var options = new MultiModelSeparationOptions
{
    Models = new List<MultiModelInfo>
    {
        new MultiModelInfo
        {
            Name = "Step1_BestQuality",
            Model = InternalModel.Best,
            NFft = 6144, DimT = 8, DimF = 2048,
            DisableNoiseReduction = false,
            SaveIntermediateOutput = true
        },
        new MultiModelInfo
        {
            Name = "Step2_Karaoke",
            Model = InternalModel.Karaoke,
            NFft = 6144, DimT = 8, DimF = 2048,
            DisableNoiseReduction = true
        }
    },
    OutputDirectory = "output_custom",
    EnableGPU = true,
    ChunkSizeSeconds = 15,
    Margin = 44100,
    SaveAllIntermediateResults = true
};

using var separator = new MultiModelAudioSeparator(options);

separator.ProgressChanged += (s, p) =>
{
    Console.Write($"\r[{p.CurrentModelName}] chunk {p.ProcessedChunks}/{p.TotalChunks} ({p.OverallProgress:F1}%)");
};

separator.Initialize();
var result = separator.Separate("input.wav");

var options = new MultiModelSeparationOptions
{
    Models = new List<MultiModelInfo>
    {
        new MultiModelInfo
        {
            Name = "VocalModel",
            ModelPath = @"models/vocal_model.onnx",
            OutputType = ModelOutputType.Vocals       // outputs vocal track directly
        },
        new MultiModelInfo
        {
            Name = "InstrumentalModel",
            ModelPath = @"models/instrumental_model.onnx",
            OutputType = ModelOutputType.Instrumental // outputs instrumental track directly
        }
    },
    OutputDirectory = "output_mixed",
    EnableGPU = true
};

// The averaging pipeline:
// - Vocal complement from model 2: original − instrumental
// - Instrumental complement from model 1: original − vocals
// - Final vocals:       (V₁ + V₂) / 2
// - Final instrumental: (I₁ + I₂) / 2

using var separator = new MultiModelAudioSeparator(options);
separator.Initialize();
var result = separator.Separate("song.mp3");

// OutputType is inferred from model filename:
//   "Voc_FT.onnx"   → contains "Voc"  → Vocals
//   "Inst_HQ.onnx"  → contains "Inst" → Instrumental
var options = new MultiModelSeparationOptions
{
    Models = new List<MultiModelInfo>
    {
        new MultiModelInfo { Name = "Voc_FT",  ModelPath = @"models/Voc_FT.onnx" },
        new MultiModelInfo { Name = "Inst_HQ", ModelPath = @"models/Inst_HQ.onnx" }
    },
    OutputDirectory = "output_custom_files",
    EnableGPU = true
};

using var separator = new MultiModelAudioSeparator(options);
separator.Initialize();
var result = separator.Separate("song.wav");

// Automatic GPU detection during initialization
service.Initialize();

// Console output will show:
// "CUDA execution provider enabled." (if GPU available)
// OR
// "Using CPU execution provider." (fallback)

// Processing speed comparison:
// CPU: ~2-5x real-time (depends on CPU cores)
// GPU (CUDA): ~10-30x real-time (depends on GPU model)

// Low memory configuration (suitable for 4GB RAM)
var lowMemOptions = new SimpleSeparationOptions
{
    Model = InternalModel.Default,
    ChunkSizeSeconds = 10,  // Smaller chunks
    Margin = 22050         // 0.5 second margin
};

// High quality configuration (requires 8GB+ RAM)
var highQualityOptions = new SimpleSeparationOptions
{
    Model = InternalModel.Best,
    ChunkSizeSeconds = 30,  // Larger chunks for better quality
    Margin = 88200          // 2 second margin for smoother transitions
};

var service = new SimpleAudioSeparationService(options);

// Subscribe to progress events
service.ProgressChanged += (sender, progress) =>
{
    Console.WriteLine($"[{progress.OverallProgress:F1}%] {progress.Status}");

    if (progress.TotalChunks > 0)
    {
        Console.WriteLine($"Chunk {progress.ProcessedChunks}/{progress.TotalChunks}");
    }
};

// Subscribe to completion event
service.ProcessingCompleted += (sender, result) =>
{
    Console.WriteLine($"\nSeparation completed in {result.ProcessingTime}");
    Console.WriteLine($"Vocals saved to: {result.VocalsPath}");
    Console.WriteLine($"Instrumental saved to: {result.InstrumentalPath}");
};

service.Initialize();
service.Separate("song.mp3");

using OwnaudioNET.Features.Vocalremover;

// Create service with internal model
var service1 = AudioSeparationExtensions.CreateDefaultService(InternalModel.Best);

// Create service with custom model file
var service2 = AudioSeparationExtensions.CreateDefaultService("path/to/model.onnx");

// Create service with custom output directory
var service3 = AudioSeparationExtensions.CreatetService(
    InternalModel.Karaoke,
    @"C:\Output\Karaoke"
);

// Create service with custom model and output
var service4 = AudioSeparationExtensions.CreatetService(
    "custom_model.onnx",
    @"C:\Output\Custom"
);

// Quick initialization and separation
var (service, _, _) = SimpleSeparator.Separator(
    InternalModel.Default,
    "output_folder"
);

var result = service.Separate("input.wav");
service.Dispose();

// Validate audio file format
bool isValid = AudioSeparationExtensions.IsValidAudioFile("song.mp3");
// Supports: .wav, .mp3, .flac

// Estimate processing time
TimeSpan estimate = AudioSeparationExtensions.EstimateProcessingTime("song.wav");
Console.WriteLine($"Estimated processing time: {estimate}");

using OwnaudioNET.Features.Vocalremover;

// Create service with default settings
var options = new SimpleSeparationOptions
{
    Model = InternalModel.Default,
    OutputDirectory = "separated"
};

using var service = new SimpleAudioSeparationService(options);
service.Initialize();

// Separate audio file
var result = service.Separate(@"C:\Music\song.mp3");

Console.WriteLine($"Vocals: {result.VocalsPath}");
Console.WriteLine($"Instrumental: {result.InstrumentalPath}");
Console.WriteLine($"Time: {result.ProcessingTime.TotalSeconds:F1}s");

var options = new SimpleSeparationOptions
{
    Model = InternalModel.Best,
    OutputDirectory = "output_best",
    ChunkSizeSeconds = 20,
    DisableNoiseReduction = false  // Enable noise reduction
};

using var service = new SimpleAudioSeparationService(options);

// Progress tracking
service.ProgressChanged += (s, p) =>
{
    Console.Write($"\r[{p.OverallProgress:F1}%] {p.Status}");
    if (p.TotalChunks > 0)
        Console.Write($" - Chunk {p.ProcessedChunks}/{p.TotalChunks}");
};

service.ProcessingCompleted += (s, r) =>
{
    Console.WriteLine($"\n\nCompleted in {r.ProcessingTime}");
    Console.WriteLine($"Output files:\n  {r.VocalsPath}\n  {r.InstrumentalPath}");
};

service.Initialize();
service.Separate("input_song.flac");

// Use Karaoke model to preserve background vocals
var options = new SimpleSeparationOptions
{
    Model = InternalModel.Karaoke,
    OutputDirectory = "karaoke_tracks"
};

using var service = new SimpleAudioSeparationService(options);
service.Initialize();

// Process multiple songs
string[] songs = Directory.GetFiles(@"C:\Music\Album", "*.mp3");

foreach (var song in songs)
{
    Console.WriteLine($"\nProcessing: {Path.GetFileName(song)}");
    var result = service.Separate(song);
    Console.WriteLine($"Karaoke track created: {result.InstrumentalPath}");
}

// Create service using factory
var service = AudioSeparationExtensions.CreatetService(
    InternalModel.Default,
    @"C:\Output\Vocals_Removed"
);

service.Initialize();

// Process all WAV files in directory
var files = Directory.GetFiles(@"C:\Music", "*.wav");
int count = 0;

foreach (var file in files)
{
    try
    {
        Console.WriteLine($"\n[{++count}/{files.Length}] {Path.GetFileName(file)}");
        var result = service.Separate(file);
        Console.WriteLine($"✓ Completed in {result.ProcessingTime.TotalSeconds:F1}s");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"✗ Error: {ex.Message}");
    }
}

service.Dispose();

// Load custom trained model
var options = new SimpleSeparationOptions
{
    Model = InternalModel.None,
    ModelPath = @"C:\Models\my_custom_separator.onnx",
    OutputDirectory = "custom_output",

    // Adjust STFT parameters if needed for custom model
    NFft = 4096,
    DimF = 1024,
    DimT = 9  // 2^9 = 512 time frames
};

using var service = new SimpleAudioSeparationService(options);
service.Initialize();

// Model parameters are auto-detected from ONNX metadata
var result = service.Separate("test.wav");