@ai-coustics/aic-sdk 0.6.3

package/dist/index.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * Node.js bindings for ai-coustics speech enhancement SDK
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = exports.Parameter = exports.ModelType = exports.ErrorCode = void 0;
+exports.getSdkVersion = getSdkVersion;
+// Load the native addon
+const binding = require('../build/Release/aic_binding.node');
+/**
+ * Error codes returned by the SDK
+ */
+var ErrorCode;
+(function (ErrorCode) {
+    /** Operation completed successfully */
+    ErrorCode[ErrorCode["SUCCESS"] = 0] = "SUCCESS";
+    /** Required pointer argument was NULL */
+    ErrorCode[ErrorCode["NULL_POINTER"] = 1] = "NULL_POINTER";
+    /** License key format is invalid or corrupted */
+    ErrorCode[ErrorCode["LICENSE_INVALID"] = 2] = "LICENSE_INVALID";
+    /** License key has expired */
+    ErrorCode[ErrorCode["LICENSE_EXPIRED"] = 3] = "LICENSE_EXPIRED";
+    /** Audio configuration is not supported by the model */
+    ErrorCode[ErrorCode["UNSUPPORTED_AUDIO_CONFIG"] = 4] = "UNSUPPORTED_AUDIO_CONFIG";
+    /** Process was called with a different audio buffer configuration than initialized */
+    ErrorCode[ErrorCode["AUDIO_CONFIG_MISMATCH"] = 5] = "AUDIO_CONFIG_MISMATCH";
+    /** Model must be initialized before this operation */
+    ErrorCode[ErrorCode["NOT_INITIALIZED"] = 6] = "NOT_INITIALIZED";
+    /** Parameter value is outside acceptable range */
+    ErrorCode[ErrorCode["PARAMETER_OUT_OF_RANGE"] = 7] = "PARAMETER_OUT_OF_RANGE";
+    /** SDK activation failed */
+    ErrorCode[ErrorCode["SDK_ACTIVATION_ERROR"] = 8] = "SDK_ACTIVATION_ERROR";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+/**
+ * Available model types for audio enhancement
+ */
+var ModelType;
+(function (ModelType) {
+    /** Native sample rate: 48 kHz, Native num frames: 480, Processing latency: 30ms */
+    ModelType[ModelType["QUAIL_L48"] = 0] = "QUAIL_L48";
+    /** Native sample rate: 16 kHz, Native num frames: 160, Processing latency: 30ms */
+    ModelType[ModelType["QUAIL_L16"] = 1] = "QUAIL_L16";
+    /** Native sample rate: 8 kHz, Native num frames: 80, Processing latency: 30ms */
+    ModelType[ModelType["QUAIL_L8"] = 2] = "QUAIL_L8";
+    /** Native sample rate: 48 kHz, Native num frames: 480, Processing latency: 30ms */
+    ModelType[ModelType["QUAIL_S48"] = 3] = "QUAIL_S48";
+    /** Native sample rate: 16 kHz, Native num frames: 160, Processing latency: 30ms */
+    ModelType[ModelType["QUAIL_S16"] = 4] = "QUAIL_S16";
+    /** Native sample rate: 8 kHz, Native num frames: 80, Processing latency: 30ms */
+    ModelType[ModelType["QUAIL_S8"] = 5] = "QUAIL_S8";
+    /** Native sample rate: 48 kHz, Native num frames: 480, Processing latency: 10ms */
+    ModelType[ModelType["QUAIL_XS"] = 6] = "QUAIL_XS";
+    /** Native sample rate: 48 kHz, Native num frames: 480, Processing latency: 10ms */
+    ModelType[ModelType["QUAIL_XXS"] = 7] = "QUAIL_XXS";
+})(ModelType || (exports.ModelType = ModelType = {}));
+/**
+ * Configurable parameters for audio enhancement
+ */
+var Parameter;
+(function (Parameter) {
+    /**
+     * Controls the intensity of speech enhancement processing.
+     * Range: 0.0 to 1.0
+     * - 0.0: Bypass mode - original signal passes through unchanged
+     * - 1.0: Full enhancement - maximum noise reduction
+     * Default: 1.0
+     */
+    Parameter[Parameter["ENHANCEMENT_LEVEL"] = 0] = "ENHANCEMENT_LEVEL";
+    /**
+     * Compensates for perceived volume reduction after noise removal.
+     * Range: 0.1 to 4.0 (linear amplitude multiplier)
+     * - 0.1: Significant volume reduction (-20 dB)
+     * - 1.0: No gain change (0 dB, default)
+     * - 2.0: Double amplitude (+6 dB)
+     * - 4.0: Maximum boost (+12 dB)
+     * Default: 1.0
+     */
+    Parameter[Parameter["VOICE_GAIN"] = 1] = "VOICE_GAIN";
+    /**
+     * Enables/disables a noise gate as a post-processing step.
+     * Valid values: 0.0 or 1.0
+     * - 0.0: Noise gate disabled
+     * - 1.0: Noise gate enabled
+     * Default: 0.0
+     */
+    Parameter[Parameter["NOISE_GATE_ENABLE"] = 2] = "NOISE_GATE_ENABLE";
+})(Parameter || (exports.Parameter = Parameter = {}));
+/**
+ * High-level interface for the ai-coustics speech enhancement model
+ */
+class Model {
+    /**
+     * Creates a new audio enhancement model instance
+     * @param modelType - The enhancement algorithm variant to use
+     * @param licenseKey - Your license key
+     * @throws Error if model creation fails
+     */
+    constructor(modelType, licenseKey) {
+        this._isInitialized = false;
+        const result = binding.createModel(modelType, licenseKey);
+        if (result.error !== ErrorCode.SUCCESS) {
+            throw new Error(`Failed to create model: ${this.getErrorMessage(result.error)}`);
+        }
+        this.handle = result.model;
+    }
+    /**
+     * Configures the model for a specific audio format
+     * Must be called before processing any audio
+     * @param config - Audio configuration parameters
+     * @throws Error if initialization fails
+     */
+    initialize(config) {
+        const error = binding.initialize(this.handle, config.sampleRate, config.numChannels, config.numFrames);
+        if (error !== ErrorCode.SUCCESS) {
+            throw new Error(`Failed to initialize model: ${this.getErrorMessage(error)}`);
+        }
+        this._isInitialized = true;
+    }
+    /**
+     * Clears all internal state and buffers
+     * Call this when the audio stream is interrupted
+     * @throws Error if reset fails
+     */
+    reset() {
+        const error = binding.reset(this.handle);
+        if (error !== ErrorCode.SUCCESS) {
+            throw new Error(`Failed to reset model: ${this.getErrorMessage(error)}`);
+        }
+    }
+    /**
+     * Processes audio with interleaved channel data (in-place)
+     * @param audio - Float32Array containing interleaved audio data
+     * @param numChannels - Number of channels (must match initialization)
+     * @param numFrames - Number of frames (must match initialization)
+     * @throws Error if processing fails
+     */
+    processInterleaved(audio, numChannels, numFrames) {
+        const error = binding.processInterleaved(this.handle, audio, numChannels, numFrames);
+        if (error !== ErrorCode.SUCCESS) {
+            throw new Error(`Failed to process audio: ${this.getErrorMessage(error)}`);
+        }
+    }
+    /**
+     * Processes audio with separate buffers for each channel (in-place)
+     * Maximum of 16 channels
+     * @param audio - Array of Float32Array, one per channel
+     * @param numChannels - Number of channels (must match initialization)
+     * @param numFrames - Number of frames per channel (must match initialization)
+     * @throws Error if processing fails
+     */
+    processPlanar(audio, numChannels, numFrames) {
+        const error = binding.processPlanar(this.handle, audio, numChannels, numFrames);
+        if (error !== ErrorCode.SUCCESS) {
+            throw new Error(`Failed to process audio: ${this.getErrorMessage(error)}`);
+        }
+    }
+    /**
+     * Sets a model parameter
+     * @param parameter - The parameter to modify
+     * @param value - New parameter value
+     * @throws Error if setting parameter fails
+     */
+    setParameter(parameter, value) {
+        const error = binding.setParameter(this.handle, parameter, value);
+        if (error !== ErrorCode.SUCCESS) {
+            throw new Error(`Failed to set parameter: ${this.getErrorMessage(error)}`);
+        }
+    }
+    /**
+     * Gets the current value of a parameter
+     * @param parameter - The parameter to query
+     * @returns Current parameter value
+     * @throws Error if getting parameter fails
+     */
+    getParameter(parameter) {
+        const result = binding.getParameter(this.handle, parameter);
+        if (result.error !== ErrorCode.SUCCESS) {
+            throw new Error(`Failed to get parameter: ${this.getErrorMessage(result.error)}`);
+        }
+        return result.value;
+    }
+    /**
+     * Returns the total output delay in samples for the current audio configuration
+     * @returns Delay in samples
+     * @throws Error if getting delay fails
+     */
+    getOutputDelay() {
+        const result = binding.getOutputDelay(this.handle);
+        if (result.error !== ErrorCode.SUCCESS) {
+            throw new Error(`Failed to get output delay: ${this.getErrorMessage(result.error)}`);
+        }
+        return result.delay;
+    }
+    /**
+     * Gets the native sample rate of the selected model
+     * @returns Optimal sample rate in Hz
+     * @throws Error if getting sample rate fails
+     */
+    getOptimalSampleRate() {
+        const result = binding.getOptimalSampleRate(this.handle);
+        if (result.error !== ErrorCode.SUCCESS) {
+            throw new Error(`Failed to get optimal sample rate: ${this.getErrorMessage(result.error)}`);
+        }
+        return result.sampleRate;
+    }
+    /**
+     * Gets the native number of frames for the selected model
+     * @returns Optimal frame count
+     * @throws Error if getting frame count fails
+     */
+    getOptimalNumFrames() {
+        const result = binding.getOptimalNumFrames(this.handle);
+        if (result.error !== ErrorCode.SUCCESS) {
+            throw new Error(`Failed to get optimal num frames: ${this.getErrorMessage(result.error)}`);
+        }
+        return result.numFrames;
+    }
+    /**
+     * Checks if the model has been initialized
+     */
+    get isInitialized() {
+        return this._isInitialized;
+    }
+    /**
+     * Releases all resources associated with the model
+     */
+    destroy() {
+        if (this.handle) {
+            binding.destroyModel(this.handle);
+            this.handle = null;
+            this._isInitialized = false;
+        }
+    }
+    getErrorMessage(errorCode) {
+        const messages = {
+            [ErrorCode.SUCCESS]: 'Operation completed successfully',
+            [ErrorCode.NULL_POINTER]: 'Required pointer argument was NULL',
+            [ErrorCode.LICENSE_INVALID]: 'License key format is invalid or corrupted',
+            [ErrorCode.LICENSE_EXPIRED]: 'License key has expired',
+            [ErrorCode.UNSUPPORTED_AUDIO_CONFIG]: 'Audio configuration is not supported by the model',
+            [ErrorCode.AUDIO_CONFIG_MISMATCH]: 'Process was called with a different audio buffer configuration',
+            [ErrorCode.NOT_INITIALIZED]: 'Model must be initialized before this operation',
+            [ErrorCode.PARAMETER_OUT_OF_RANGE]: 'Parameter value is outside acceptable range',
+            [ErrorCode.SDK_ACTIVATION_ERROR]: 'SDK activation failed',
+        };
+        return messages[errorCode] || `Unknown error code: ${errorCode}`;
+    }
+}
+exports.Model = Model;
+/**
+ * Returns the version of the SDK
+ */
+function getSdkVersion() {
+    return binding.getSdkVersion();
+}
+// Export for CommonJS compatibility
+exports.default = {
+    Model,
+    ModelType,
+    Parameter,
+    ErrorCode,
+    getSdkVersion,
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@ai-coustics/aic-sdk",
+  "version": "0.6.3",
+  "description": "Node.js bindings for ai-coustics speech enhancement SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "install": "node scripts/download-sdk.js && node-gyp rebuild",
+    "build": "tsc",
+    "prepare": "npm run build",
+    "test": "node test-basic.js",
+    "test:full": "node test-basic.js && npm run example:js && npm run example:ts",
+    "example:js": "node examples/example.js",
+    "example:ts": "npx ts-node examples/example.ts",
+    "example:ts-compile": "tsc examples/example.ts --outDir examples && node examples/example.js",
+    "clean": "rm -rf build dist sdk"
+  },
+  "keywords": [
+    "audio",
+    "speech",
+    "enhancement",
+    "voice",
+    "ai-coustics"
+  ],
+  "author": "ai-coustics GmbH",
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ai-coustics/aic-sdk-node.git"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "dependencies": {
+    "node-addon-api": "^7.0.0",
+    "node-gyp": "^10.0.0",
+    "tar": "^6.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "binding.gyp",
+    "scripts",
+    "src/binding.cc"
+  ],
+  "gypfile": true
+}

package/scripts/download-sdk.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { pipeline } = require("stream");
+const { promisify } = require("util");
+const tar = require("tar");
+const { exec } = require("child_process");
+
+const pipelineAsync = promisify(pipeline);
+const execAsync = promisify(exec);
+
+const SDK_VERSION = "0.6.3";
+const SDK_BASE_URL = `https://github.com/ai-coustics/aic-sdk-c/releases/download/${SDK_VERSION}`;
+
+// Platform-specific archive filenames
+const PLATFORM_MAP = {
+  "darwin-x64": `aic-sdk-x86_64-apple-darwin-${SDK_VERSION}.tar.gz`,
+  "darwin-arm64": `aic-sdk-aarch64-apple-darwin-${SDK_VERSION}.tar.gz`,
+  "linux-x64": `aic-sdk-x86_64-unknown-linux-gnu-${SDK_VERSION}.tar.gz`,
+  "linux-arm64": `aic-sdk-aarch64-unknown-linux-gnu-${SDK_VERSION}.tar.gz`,
+  "win32-x64": `aic-sdk-x86_64-pc-windows-msvc-${SDK_VERSION}.zip`,
+};
+
+// SHA-256 hashes for each platform archive
+const PLATFORM_HASHES = {
+  "darwin-x64":
+    "a1e8050c8b87b645c2acb5bce396aa964640074b183da54248c2ef9549c41b6b",
+  "darwin-arm64":
+    "35384d0e51733f39276c427a92f13d4a983404634604ec5fbeda10a3debc2860",
+  "linux-x64":
+    "e22593f5cc6241be3d495d4a154c1157f298213e614cbe248a419745fc02e681",
+  "linux-arm64":
+    "3c10d6af456d8d6641f7e0f82e85145f79d7b1b6459c820e489f685296fafc28",
+  "win32-x64":
+    "c6a414e23285e3c2930cae4c942f02aea30175a2986a2871304e6229b83bc91b",
+};
+
+function getPlatformIdentifier() {
+  const platform = process.platform;
+  const arch = process.arch;
+  return `${platform}-${arch}`;
+}
+
+function getDownloadUrl() {
+  const platformId = getPlatformIdentifier();
+  const filename = PLATFORM_MAP[platformId];
+
+  if (!filename) {
+    throw new Error(
+      `Unsupported platform: ${platformId}. Supported platforms: ${Object.keys(PLATFORM_MAP).join(", ")}`,
+    );
+  }
+
+  return `${SDK_BASE_URL}/${filename}`;
+}
+
+function calculateSHA256(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+
+    stream.on("data", (data) => hash.update(data));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+
+function verifyHash(filePath, expectedHash) {
+  return calculateSHA256(filePath).then((actualHash) => {
+    if (actualHash !== expectedHash) {
+      throw new Error(
+        `Hash verification failed!\nExpected: ${expectedHash}\nActual:   ${actualHash}`,
+      );
+    }
+    console.log("Hash verification successful!");
+  });
+}
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    console.log(`Downloading SDK from ${url}...`);
+
+    https
+      .get(url, (response) => {
+        if (response.statusCode === 302 || response.statusCode === 301) {
+          // Follow redirect
+          return downloadFile(response.headers.location, destPath)
+            .then(resolve)
+            .catch(reject);
+        }
+
+        if (response.statusCode !== 200) {
+          reject(
+            new Error(
+              `Failed to download: ${response.statusCode} ${response.statusMessage}`,
+            ),
+          );
+          return;
+        }
+
+        const fileStream = fs.createWriteStream(destPath);
+        let downloadedBytes = 0;
+        const totalBytes = parseInt(response.headers["content-length"], 10);
+
+        response.on("data", (chunk) => {
+          downloadedBytes += chunk.length;
+          const progress = ((downloadedBytes / totalBytes) * 100).toFixed(1);
+          process.stdout.write(`\rDownloading: ${progress}%`);
+        });
+
+        response.pipe(fileStream);
+
+        fileStream.on("finish", () => {
+          fileStream.close();
+          console.log("\nDownload completed!");
+          resolve();
+        });
+
+        fileStream.on("error", (err) => {
+          fs.unlinkSync(destPath);
+          reject(err);
+        });
+      })
+      .on("error", reject);
+  });
+}
+
+async function extractArchive(archivePath, destDir) {
+  console.log("Extracting SDK...");
+
+  const ext = path.extname(archivePath);
+
+  if (ext === ".gz") {
+    // Extract tar.gz
+    await tar.x({
+      file: archivePath,
+      cwd: destDir,
+    });
+  } else if (ext === ".zip") {
+    // Extract zip (Windows)
+    const unzipper = require("child_process").spawn("powershell.exe", [
+      "-Command",
+      `Expand-Archive -Path "${archivePath}" -DestinationPath "${destDir}" -Force`,
+    ]);
+
+    await new Promise((resolve, reject) => {
+      unzipper.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`Extraction failed with code ${code}`));
+      });
+    });
+  }
+
+  console.log("Extraction completed!");
+}
+
+async function main() {
+  try {
+    const rootDir = path.join(__dirname, "..");
+    const sdkDir = path.join(rootDir, "sdk");
+    const tmpDir = path.join(rootDir, "tmp");
+
+    // Create directories
+    if (!fs.existsSync(tmpDir)) {
+      fs.mkdirSync(tmpDir, { recursive: true });
+    }
+
+    // Check if SDK already exists
+    if (fs.existsSync(sdkDir)) {
+      console.log("SDK already downloaded. Skipping download.");
+      return;
+    }
+
+    const downloadUrl = getDownloadUrl();
+    const filename = path.basename(downloadUrl);
+    const archivePath = path.join(tmpDir, filename);
+
+    // Download SDK
+    await downloadFile(downloadUrl, archivePath);
+
+    // Verify the downloaded file's hash
+    const platformId = getPlatformIdentifier();
+    const expectedHash = PLATFORM_HASHES[platformId];
+    console.log("Verifying download integrity...");
+    await verifyHash(archivePath, expectedHash);
+
+    // Create sdk directory for extraction
+    fs.mkdirSync(sdkDir, { recursive: true });
+
+    // Extract SDK directly into sdk directory
+    await extractArchive(archivePath, sdkDir);
+
+    // Remove unnecessary directories
+    const unnecessaryDirs = ["examples", "docs"];
+    for (const dir of unnecessaryDirs) {
+      const dirPath = path.join(sdkDir, dir);
+      if (fs.existsSync(dirPath)) {
+        fs.rmSync(dirPath, { recursive: true, force: true });
+      }
+    }
+
+    // Clean up
+    fs.unlinkSync(archivePath);
+    fs.rmdirSync(tmpDir);
+
+    console.log("SDK installation completed successfully!");
+  } catch (error) {
+    console.error("Failed to download SDK:", error.message);
+    process.exit(1);
+  }
+}
+
+main();