C# Example

IrisSdkSample.cs

using System;
using System.IO;

void ProgressCallback(Iris.ProgressEvent ev)
{
    switch (ev.Type)
    {
        case Iris.ProgressEventType.Start:
            Console.WriteLine("Processing: started");
            break;
        case Iris.ProgressEventType.Process:
            Console.Write($"\rProcessing: {ev.Percentage:F2}%");
            break;
        case Iris.ProgressEventType.End:
            Console.WriteLine("\nProcessing: ended");
            break;
    }
}

// Initialise iris sdk. Either pass in the licence and key as strings or let the sdk discover
// them from its default data location. See readme.md for default locations.
// string licence = File.ReadAllText("/full/path/to/iris.lic");
// string key     = File.ReadAllText("/full/path/to/iris.key");
// Iris.LicenceInfo licenceInfo = Iris.Sdk.Init(licence, key);
Iris.LicenceInfo licenceInfo = Iris.Sdk.Init();
Console.WriteLine($"Initialised iris-sdk {licenceInfo.Version} for {licenceInfo.Name}");
SampleUtils.CheckLicenceInfo(licenceInfo);

// Load some source audio and create somewhere to store the result.
// In a real world application this will be an incoming audio stream.
// Adjust sampleRate and channels to match your audio.
int sampleRate = 48000;
int channels   = 1;
string inputFile  = Path.Combine("..", "sample_audio", "breaking_point_f32_48k.raw");
string outputFile = Path.Combine("..", "sample_audio", "breaking_point_f32_48k_processed.raw");

float[] audioIn  = SampleUtils.RawFloatsFromFile(inputFile);
float[] audioOut = new float[audioIn.Length];

// Create an audio processing context request.
var request = new Iris.AudioContextRequest
{
    Processors    = new() { "passthrough" }, // set the processor chain to use
    SampleRate    = sampleRate,              // set the sample rate of the input audio
    ChannelCount  = channels,               // set the channel count of the input audio
    ResamplerMode = Iris.ResamplerMode.HighQuality,
};
SampleUtils.CheckContextRequest(request);

// Create an audio processing context using the context request.
Iris.AudioContextConfig cfg = Iris.Sdk.CreateAudioContext(request);
SampleUtils.CheckContextConfig(cfg);

// Process the entire buffer in one go, accounting for any transport delay.
// If processing a stream, call Iris.Sdk.Process() when each new buffer of stream data arrives instead.
// In the streaming case, frames should be set to the size of the stream buffer.
// If each buffer is the same size, set FixedFrameCount = true in the context request.
// Streaming pseudocode:
//   while (newStreamDataAvailable) {
//     float[] processIn  = GetStreamSource();
//     float[] processOut = new float[processIn.Length];
//     Iris.Sdk.Process(cfg.ContextId, processIn, processOut, (uint)(processIn.Length / channels));
//     PutStreamSink(processOut);
//   }
Console.WriteLine($"Processing {inputFile}");
Iris.Sdk.ProcessOffline(cfg.ContextId, audioIn, audioOut, (uint)(audioIn.Length / channels), ProgressCallback);

// Save the processed output alongside the input file.
Console.WriteLine($"Saving {outputFile}");
SampleUtils.RawFloatsToFile(outputFile, audioOut);

// Release the context.
Console.WriteLine("Cleaning up...");
Iris.Sdk.ReleaseAudioContext(cfg.ContextId);
Iris.Sdk.Cleanup();
Console.WriteLine("Done.");

SampleUtils.cs

using System;
using System.IO;
using System.Runtime.InteropServices;

internal static class SampleUtils
{
    internal static float[] RawFloatsFromFile(string path)
    {
        byte[] bytes = File.ReadAllBytes(path);
        float[] data = new float[bytes.Length / sizeof(float)];
        Buffer.BlockCopy(bytes, 0, data, 0, bytes.Length);
        return data;
    }

    internal static void RawFloatsToFile(string path, float[] data)
    {
        byte[] bytes = new byte[data.Length * sizeof(float)];
        Buffer.BlockCopy(data, 0, bytes, 0, bytes.Length);
        File.WriteAllBytes(path, bytes);
    }

    internal static void CheckLicenceInfo(Iris.LicenceInfo info)
    {
        Console.WriteLine("Licence Info:");
        Console.WriteLine($"  Name:           {info.Name}");
        Console.WriteLine($"  SDK Version:    {info.Version}");
        Console.WriteLine($"  Expiry:         {info.Expiry}");
        Console.WriteLine($"  Licence Status: {info.Status}");
        Console.WriteLine();
        Console.WriteLine("Available processors:");
        foreach (string p in info.AvailableProcessors)
            Console.WriteLine($"  - {p}");
        Console.WriteLine();

        if (info.Status != Iris.LicenceStatus.Valid)
        {
            Console.WriteLine("Invalid licence - exiting");
            Environment.Exit(0);
        }
    }

    internal static void CheckContextRequest(Iris.AudioContextRequest req)
    {
        Console.WriteLine("Audio Context Request:");
        Console.WriteLine($"  Sample Rate:    {req.SampleRate}");
        Console.WriteLine($"  Buffer Length:  {req.BufferLength}");
        Console.Write    (  "  Processors:     ");
        Console.WriteLine(string.Join(", ", req.Processors ?? new()));
        Console.WriteLine($"  Resampler Mode: {req.ResamplerMode}");
        Console.WriteLine($"  Optimization:   {req.Optimization}");
        Console.WriteLine($"  Fixed Frames:   {req.FixedFrameCount}");
        Console.WriteLine();
    }

    internal static void CheckContextConfig(Iris.AudioContextConfig cfg)
    {
        Console.WriteLine("Audio Context Configuration:");
        Console.WriteLine($"  Context Id:     {cfg.ContextId}");
        Console.WriteLine($"  Description:    {cfg.Description}");
        Console.WriteLine($"  Sample Rate:    {cfg.SampleRate}");
        Console.WriteLine($"  Buffer Length:  {cfg.BufferLength}");
        Console.WriteLine($"  Channels:       {cfg.ChannelCount}");
        if (cfg.WillResample)
        {
            Console.WriteLine($"  Resampling:     {cfg.WillResample}");
            Console.WriteLine($"  Resampler Mode: {cfg.ResamplerMode}");
        }
        Console.WriteLine($"  Optimization:   {cfg.Optimization}");
        if (cfg.Error == 0)
        {
            Console.WriteLine("  Context Parameters:");
            foreach (var proc in cfg.Parameters)
            {
                Console.WriteLine($"    {proc.Name}");
                foreach (var param in proc.Parameters)
                    Console.WriteLine($"      -> {param.Name}");
            }
        }
        else
        {
            Console.WriteLine($"  Error: {cfg.Error}");
            Console.WriteLine($"Context creation failed (error {cfg.Error}).");
            Environment.Exit((int)cfg.Error);
        }
        Console.WriteLine();
    }
}