Typescript Example

iris-node-demo.ts

import {
  AudioContextRequest,
  ProgressEventType,
  ProgressEvent,
  ResamplerMode,
  cleanup,
  createAudioContext,
  init,
  processOffline,
  releaseAudioContext,
} from 'iris-sdk';
import { writeFile } from 'node:fs/promises';
import {
  checkContextConfig,
  checkContextRequest,
  checkLicenseInfo,
  rawToArray,
} from './demoUtils';

function processCallback(event: ProgressEvent) {
  switch (event.type) {
    case ProgressEventType.START:
      console.log('Processing: started');
      break;
    case ProgressEventType.PROCESS:
      process.stdout.write(`\rProcessing: ${event.percentage.toFixed(2)}%`);
      break;
    case ProgressEventType.END:
      console.log('\nProcessing: ended');
      break;
  }
}

(async () => {
  // 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
  // const licence = await fileToString('/full/path/to/iris.lic');
  // const key = await fileToString('/full/path/to/iris.key');
  // const info = init(licence, key);
  const info = init();

  console.log(`Initialised iris-sdk ${info.version} for ${info.name}`);
  checkLicenseInfo(info);

  const filePath = './breaking_point_f32_48k.raw';
  // Load a raw file;
  const audioIn = await rawToArray(filePath);
  const audioOut = new Float32Array(audioIn).fill(0);

  const contextRequest: AudioContextRequest = {
    processors: ['passthrough'],
    sampleRate: 48000,
    channelCount: 1,
    resamplerMode: ResamplerMode.HQ,
  };
  checkContextRequest(contextRequest);

  const config = createAudioContext(contextRequest);
  checkContextConfig(config);

  // 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 size.
  // If each buffer is the same size, set fixed_frame_count to true in the context request
  // If the stream buffer size is known up front, set the buffer size in the context request
  // streaming pseudocode
  // while new_stream_data_available:
  //   process_in_buffer = get_stream_source()
  //   process_out_buffer = np.zeros_like(process_in_buffer, dtype=np.float32)
  //   iris.sdk.process(config.context_id, process_in_buffer, process_out_buffer, len(process_in_buffer))
  //   put_stream_sink(process_out_buffer)

  console.log(`\nProcessing ${filePath}`);
  processOffline(
    config.contextId,
    audioIn,
    audioOut,
    audioIn.length,
    processCallback
  );
  // save the processed output
  // audacity import raw data -> encoding 32 bit float / sample rate 48000
  await writeFile('./breaking_point_f32_48k_processed.raw', audioOut);

  // Release the context
  console.log('Cleaning up...');
  releaseAudioContext(config.contextId);
  cleanup();
  console.log('Done.');
})();

demoUtils.ts

import {
  AudioContextConfig,
  AudioContextRequest,
  ErrorCodes,
  Info,
} from 'iris-sdk';

import { readFile } from 'node:fs/promises';

export async function rawToArray(filePath: string) {
  const data = await readFile(filePath);
  // Interpret the buffer as Float32 values
  const floatArray = new Float32Array(
    data.buffer,
    data.byteOffset,
    data.byteLength / Float32Array.BYTES_PER_ELEMENT
  );

  // Convert the Float32 array to a string
  return floatArray;
}

export function checkLicenseInfo(info: Info) {
  console.log('\nLicence Info:');
  console.log(`    Name: ${info.name}`);
  console.log(`    SDK Version: ${info.version}`);
  console.log(`    Expiry: ${info.expiry}`);
  console.log(`    Licence status: ${info.status}\n`);
  console.log(`Available processors: ${info.availableProcessors}\n`);

  // Check licence is valid
  if (info.status !== 'Licence valid') {
    throw new Error(`Licence error: ${info.status}`);
  }
}

export function checkContextRequest(request: AudioContextRequest) {
  console.log('Audio Context Request:');
  console.log(`    Sample rate: ${request.sampleRate}`);
  console.log(`    Buffer length: ${request.bufferLength}`);
  console.log(`    Processors: ${request.processors}`);
  console.log(`    Resampler Mode: ${request.resamplerMode}`);
  console.log(`    Optimisation: ${request.optimization}`);
  console.log(`    Fixed frame count: ${request.fixedFrameCount}\n`);
}

export function checkContextConfig(config: AudioContextConfig) {
  console.log(`Audio Context Configuration:`);
  console.log(`    Context ID: ${config.contextId}`);
  console.log(`    Description: ${config.description}`);
  console.log(`    Sample rate: ${config.sampleRate}`);
  console.log(`    Buffer length: ${config.bufferLength}`);
  console.log(`    Channels: ${config.channelCount}`);
  if (config.willResample) {
    console.log(`    Resampling: ${config.willResample}`);
    console.log(`    Resampler Mode: ${config.resamplerMode}`);
  }
  console.log(`    Optimisation: ${config.optimization}`);

  if (config.error === ErrorCodes.NO_ERROR) {
    console.log('    Context Parameters:');
    for (const group of config.parameters) {
      console.log(`        ${group.name}`);
      for (const param of group.parameterDescriptions) {
        console.log(`          -> ${param.name}`);
      }
    }
  } else {
    throw new Error(`Context creation failed: ${config.error}}`);
  }
}