@siteed/expo-audio-stream 1.0.1 → 1.0.3

package/ios/ExpoAudioStreamModule.swift

@@ -2,6 +2,7 @@ import ExpoModulesCore
 import AVFoundation
 
 let audioDataEvent: String = "AudioData"
+let audioAnalysisEvent: String = "AudioAnalysis"
 
 public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
     private var streamManager = AudioStreamManager()
@@ -10,13 +11,118 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         Name("ExpoAudioStream")
         
         // Defines event names that the module can send to JavaScript.
-        Events(audioDataEvent)
+        Events([audioDataEvent, audioAnalysisEvent])
         
         OnCreate {
             print("Setting streamManager delegate")
             streamManager.delegate = self
         }
         
+        /// Extracts audio analysis data from an audio file.
+        ///
+        /// - Parameters:
+        ///   - options: A dictionary containing:
+        ///     - `fileUri`: The URI of the audio file.
+        ///     - `pointsPerSecond`: The number of data points to extract per second of audio.
+        ///     - `algorithm`: The algorithm to use for extraction.
+        ///     - `features`: A dictionary specifying which features to extract (e.g., `energy`, `mfcc`, `rms`, etc.).
+        ///   - promise: A promise to resolve with the extracted audio analysis data or reject with an error.
+        /// - Returns: Promise to be resolved with audio analysis data.
+        AsyncFunction("extractAudioAnalysis") { (options: [String: Any], promise: Promise) in
+            guard let fileUri = options["fileUri"] as? String,
+                  let url = URL(string: fileUri),
+                  let pointsPerSecond = options["pointsPerSecond"] as? Int,
+                  let algorithm = options["algorithm"] as? String else {
+                promise.reject("INVALID_ARGUMENTS", "Invalid arguments provided")
+                return
+            }
+            
+            let features = options["features"] as? [String: Bool] ?? [:]
+            let featureOptions = self.extractFeatureOptions(from: features)
+            
+            DispatchQueue.global().async {
+                do {
+                    let audioFile = try AVAudioFile(forReading: url)
+                    let bitDepth = audioFile.fileFormat.settings[AVLinearPCMBitDepthKey] as? Int ?? 16
+                    let numberOfChannels = Int(audioFile.fileFormat.channelCount)
+                    
+                    let audioProcessor = try AudioProcessor(url: url, resolve: { result in
+                        promise.resolve(result)
+                    }, reject: { code, message in
+                        promise.reject(code, message)
+                    })
+                    
+                    if let result = audioProcessor.processAudioData(numberOfSamples: nil, pointsPerSecond: pointsPerSecond, algorithm: algorithm, featureOptions: featureOptions, bitDepth: bitDepth, numberOfChannels: numberOfChannels) {
+                        promise.resolve(result.toDictionary())
+                    } else {
+                        promise.reject("PROCESSING_ERROR", "Failed to process audio data")
+                    }
+                } catch {
+                    promise.reject("PROCESSING_ERROR", "Failed to initialize audio processor: \(error.localizedDescription)")
+                }
+            }
+        }
+        
+        /// Extracts waveform data from an audio file.
+        ///
+        /// - Parameters:
+        ///   - options: A dictionary containing:
+        ///     - `fileUri`: The URI of the audio file.
+        ///     - `numberOfSamples`: The number of samples to extract for the waveform.
+        ///     - `offset`: The optional offset to start reading from. Defaults to 0 if not provided.
+        ///     - `length`: The optional length of the audio to read. Defaults to the entire file if not provided.
+        ///   - promise: A promise to resolve with the extracted waveform data or reject with an error.
+        /// - Returns: Promise to be resolved with waveform data.
+        AsyncFunction("extractWaveform") { (options: [String: Any], promise: Promise) in
+            guard let fileUri = options["fileUri"] as? String,
+                  let url = URL(string: fileUri),
+                  let numberOfSamples = options["numberOfSamples"] as? Int else {
+                promise.reject("INVALID_ARGUMENTS", "Invalid arguments provided")
+                return
+            }
+            
+            let offset = options["offset"] as? Int ?? 0
+            DispatchQueue.global().async {
+                do {
+                    let audioFile = try AVAudioFile(forReading: url)
+                    let bitDepth = audioFile.fileFormat.settings[AVLinearPCMBitDepthKey] as? Int ?? 16
+                    let numberOfChannels = Int(audioFile.fileFormat.channelCount)
+                    
+                    // If length is not provided, default to the entire file length
+                    let length = options["length"] as? UInt ?? UInt(audioFile.length - AVAudioFramePosition(offset))
+                    
+                    let audioProcessor = try AudioProcessor(url: url, resolve: { result in
+                        promise.resolve(result)
+                    }, reject: { code, message in
+                        promise.reject(code, message)
+                    })
+                    
+                    if let result = audioProcessor.processAudioData(numberOfSamples: numberOfSamples, offset: offset, length: length, pointsPerSecond: nil, algorithm: "rms", featureOptions: [:], bitDepth: bitDepth, numberOfChannels: numberOfChannels) {
+                        promise.resolve(result.toDictionary())
+                    } else {
+                        promise.reject("EXTRACTION_ERROR", "Failed to extract waveform")
+                    }
+                } catch {
+                    promise.reject("EXTRACTION_ERROR", "Failed to initialize waveform extractor: \(error.localizedDescription)")
+                }
+            }
+        }
+        
+        
+        /// Asynchronously starts audio recording with the given settings.
+        ///
+        /// - Parameters:
+        ///   - options: A dictionary containing:
+        ///     - `sampleRate`: The sample rate for recording (default is 16000.0).
+        ///     - `channelConfig`: The number of channels (default is 1 for mono).
+        ///     - `audioFormat`: The bit depth for recording (default is 16 bits).
+        ///     - `interval`: The interval in milliseconds at which to emit recording data (default is 1000 ms).
+        ///     - `enableProcessing`: Boolean to enable/disable audio processing (default is false).
+        ///     - `pointsPerSecond`: The number of data points to extract per second of audio (default is 20).
+        ///     - `algorithm`: The algorithm to use for extraction (default is "rms").
+        ///     - `featureOptions`: A dictionary of feature options to extract (default is empty).
+        ///     - `maxRecentDataDuration`: The maximum duration of recent data to keep for processing (default is 10.0 seconds).
+        ///   - promise: A promise to resolve with the recording settings or reject with an error.
         AsyncFunction("startRecording") { (options: [String: Any], promise: Promise) in
             self.checkMicrophonePermission { granted in
                 guard granted else {
@@ -30,7 +136,26 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
                 let bitDepth = options["audioFormat"] as? Int ?? 16 // 16bits
                 let interval = options["interval"] as? Int ?? 1000
                 
-                let settings = RecordingSettings(sampleRate: sampleRate, numberOfChannels: numberOfChannels, bitDepth: bitDepth)
+                // Extract processing options with default values
+                let enableProcessing = options["enableProcessing"] as? Bool ?? false
+                let pointsPerSecond = options["pointsPerSecond"] as? Int ?? 20
+                let algorithm = options["algorithm"] as? String ?? "rms"
+                let featureOptions = options["featureOptions"] as? [String: Bool] ?? [:]
+                let maxRecentDataDuration = options["maxRecentDataDuration"] as? Double ?? 10.0
+                
+                // Create recording settings
+                let settings = RecordingSettings(
+                    sampleRate: sampleRate,
+                    desiredSampleRate: sampleRate,
+                    numberOfChannels: numberOfChannels,
+                    bitDepth: bitDepth,
+                    maxRecentDataDuration: enableProcessing ? maxRecentDataDuration : nil,
+                    enableProcessing: enableProcessing,
+                    pointsPerSecond: enableProcessing ? pointsPerSecond : nil,
+                    algorithm: enableProcessing ? algorithm : nil,
+                    featureOptions: enableProcessing ? featureOptions : nil
+                )
+                
                 if let result = self.streamManager.startRecording(settings: settings, intervalMilliseconds: interval) {
                     let resultDict: [String: Any] = [
                         "fileUri": result.fileUri,
@@ -46,16 +171,33 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
             }
         }
         
+        /// Retrieves the current status of the audio stream.
+        ///
+        /// - Returns: The current status of the audio stream.Ï
         Function("status") {
             return self.streamManager.getStatus()
         }
         
+        /// Pauses audio recording.
+        Function("pauseRecording") {
+            self.streamManager.pauseRecording()
+        }
+        
+        /// Resumes audio recording.
+        Function("resumeRecording") {
+            self.streamManager.resumeRecording()
+        }
+        
+        /// Asynchronously stops audio recording and retrieves the recording result.
+        ///
+        /// - Parameters:
+        ///   - promise: A promise to resolve with the recording result or reject with an error.
         AsyncFunction("stopRecording") { (promise: Promise) in
             if let recordingResult = self.streamManager.stopRecording() {
                 // Convert RecordingResult to a dictionary
                 let resultDict: [String: Any] = [
                     "fileUri": recordingResult.fileUri,
-                    "duration": recordingResult.duration,
+                    "durationMs": recordingResult.duration,
                     "size": recordingResult.size,
                     "channels": recordingResult.channels,
                     "bitDepth": recordingResult.bitDepth,
@@ -68,19 +210,32 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
             }
         }
         
+        /// Asynchronously lists all audio files stored in the document directory.
+        ///
+        /// - Parameters:
+        ///   - promise: A promise to resolve with the list of audio file URIs or reject with an error.
+        /// - Returns: A promise that resolves with the list of audio file URIs or rejects with an error.
         AsyncFunction("listAudioFiles") { (promise: Promise) in
             let files = listAudioFiles()
             promise.resolve(files)
         }
         
+        /// Clears all audio files stored in the document directory.
         Function("clearAudioFiles") {
             clearAudioFiles()
         }
     }
     
+    /// Handles the reception of audio data from the AudioStreamManager.
+    ///
+    /// - Parameters:
+    ///   - manager: The AudioStreamManager instance.
+    ///   - data: The received audio data.
+    ///   - recordingTime: The current recording time.
+    ///   - totalDataSize: The total size of the received audio data.
     func audioStreamManager(_ manager: AudioStreamManager, didReceiveAudioData data: Data, recordingTime: TimeInterval, totalDataSize: Int64) {
         guard let fileURL = manager.recordingFileURL,
-                let settings = manager.recordingSettings else { return }
+              let settings = manager.recordingSettings else { return }
         
         let encodedData = data.base64EncodedString()
         
@@ -93,7 +248,7 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         let channels = Double(settings.numberOfChannels)
         let bitDepth = Double(settings.bitDepth)
         let position = Int((Double(manager.lastEmittedSize) / (sampleRate * channels * (bitDepth / 8))) * 1000)
-
+        
         // Construct the event payload similar to Android
         let eventBody: [String: Any] = [
             "fileUri": fileURL.absoluteString,
@@ -110,6 +265,18 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         sendEvent(audioDataEvent, eventBody)
     }
     
+    func audioStreamManager(_ manager: AudioStreamManager, didReceiveProcessingResult result: AudioAnalysisData?) {
+        // Handle the processed audio data
+        // Emit the processing result event to JavaScript
+        let resultDict = result?.toDictionary() ?? [:]
+        Logger.debug("emitting \(audioAnalysisEvent) event with \(resultDict)")
+        sendEvent(audioAnalysisEvent, resultDict)
+    }
+    
+    /// Checks microphone permission and calls the completion handler with the result.
+    ///
+    /// - Parameters:
+    ///   - completion: A completion handler that receives a boolean indicating whether the microphone permission was granted.
     private func checkMicrophonePermission(completion: @escaping (Bool) -> Void) {
         switch AVAudioSession.sharedInstance().recordPermission {
         case .granted:
@@ -127,6 +294,7 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         }
     }
     
+    /// Clears all audio files stored in the document directory.
     private func clearAudioFiles() {
         let fileURLs = listAudioFiles()  // This now returns full URLs as strings
         fileURLs.forEach { fileURLString in
@@ -141,9 +309,33 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
                 print("Invalid URL string: \(fileURLString)")
             }
         }
-        
     }
     
+    /// Extracts feature options from the provided options dictionary.
+    ///
+    /// - Parameters:
+    ///   - options: The options dictionary containing feature flags.
+    /// - Returns: A dictionary with feature flags and their boolean values.
+    private func extractFeatureOptions(from options: [String: Any]) -> [String: Bool] {
+        return [
+            "energy": options["energy"] as? Bool ?? false,
+            "mfcc": options["mfcc"] as? Bool ?? false,
+            "rms": options["rms"] as? Bool ?? false,
+            "zcr": options["zcr"] as? Bool ?? false,
+            "dB": options["dB"] as? Bool ?? false,
+            "spectralCentroid": options["spectralCentroid"] as? Bool ?? false,
+            "spectralFlatness": options["spectralFlatness"] as? Bool ?? false,
+            "spectralRollOff": options["spectralRollOff"] as? Bool ?? false,
+            "spectralBandwidth": options["spectralBandwidth"] as? Bool ?? false,
+            "chromagram": options["chromagram"] as? Bool ?? false,
+            "tempo": options["tempo"] as? Bool ?? false,
+            "hnr": options["hnr"] as? Bool ?? false
+        ]
+    }
+    
+    /// Lists all audio files stored in the document directory.
+    ///
+    /// - Returns: An array of file URIs as strings.
     func listAudioFiles() -> [String] {
         guard let documentDirectory = try? FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false) else {
             print("Failed to access document directory.")

package/ios/Features.swift

@@ -0,0 +1,44 @@
+//
+//  Features.swift
+//  ExpoAudioStream
+//
+//  Created by Arthur Breton on 23/6/2024.
+//
+
+import Foundation
+
+public struct Features {
+    var energy: Float
+    var mfcc: [Float]
+    var rms: Float
+    var minAmplitude: Float
+    var maxAmplitude: Float
+    var zcr: Float
+    var spectralCentroid: Float
+    var spectralFlatness: Float
+    var spectralRollOff: Float?
+    var spectralBandwidth: Float?
+    var chromagram: [Float]?
+    var tempo: Float?
+    var hnr: Float?
+}
+
+extension Features {
+    func toDictionary() -> [String: Any] {
+        return [
+            "energy": energy,
+            "mfcc": mfcc,
+            "rms": rms,
+            "minAmplitude": minAmplitude,
+            "maxAmplitude": maxAmplitude,
+            "zcr": zcr,
+            "spectralCentroid": spectralCentroid,
+            "spectralFlatness": spectralFlatness,
+            "spectralRollOff": spectralRollOff ?? 0,
+            "spectralBandwidth": spectralBandwidth ?? 0,
+            "chromagram": chromagram ?? [],
+            "tempo": tempo ?? 0,
+            "hnr": hnr ?? 0
+        ]
+    }
+}

package/ios/RecordingResult.swift

@@ -0,0 +1,19 @@
+// RecordingResult.swift
+
+struct RecordingResult {
+    var fileUri: String
+    var mimeType: String
+    var duration: Int64
+    var size: Int64
+    var channels: Int
+    var bitDepth: Int
+    var sampleRate: Double
+}
+
+struct StartRecordingResult {
+    var fileUri: String
+    var mimeType: String
+    var channels: Int
+    var bitDepth: Int
+    var sampleRate: Double
+}

package/ios/RecordingSettings.swift

@@ -0,0 +1,13 @@
+// RecordingSettings.swift
+
+struct RecordingSettings {
+    var sampleRate: Double
+    var desiredSampleRate: Double
+    var numberOfChannels: Int = 1
+    var bitDepth: Int = 16
+    var maxRecentDataDuration: Double? = 10.0 // Default to 10 seconds
+    var enableProcessing: Bool = false // Flag to enable/disable processing
+    var pointsPerSecond: Int? = 1000 // Default value
+    var algorithm: String? = "rms" // Default algorithm
+    var featureOptions: [String: Bool]? = ["rms": true, "zcr": true] // Default features
+}

package/ios/WaveformExtractor.swift

@@ -0,0 +1,105 @@
+// WaveformExtractor.swift
+
+import Accelerate
+import AVFoundation
+
+/// This class is responsible for extracting waveform data from an audio file.
+public class WaveformExtractor {
+    public private(set) var audioFile: AVAudioFile?
+    private var result: (Any) -> Void
+    private var reject: (String, String) -> Void
+    private var waveformData = Array<Float>()
+    private var progress: Float = 0.0
+    private var channelCount: Int = 1
+    private var currentProgress: Float = 0.0
+    private let extractionQueue = DispatchQueue(label: "WaveformExtractor", attributes: .concurrent)
+    private var _abortWaveformExtraction: Bool = false
+
+    /// Indicates whether the waveform extraction process should be aborted.
+    public var abortWaveformExtraction: Bool {
+        get { _abortWaveformExtraction }
+        set { _abortWaveformExtraction = newValue }
+    }
+
+    /// Initializes the waveform extractor with an audio file URL, resolve, and reject callbacks.
+    ///
+    /// - Parameters:
+    ///   - url: The URL of the audio file to be read.
+    ///   - resolve: The callback to be called on successful extraction.
+    ///   - reject: The callback to be called on extraction failure.
+    public init(url: URL, resolve: @escaping (Any) -> Void, reject: @escaping (String, String) -> Void) throws {
+        self.audioFile = try AVAudioFile(forReading: url)
+        self.result = resolve
+        self.reject = reject
+    }
+
+    deinit {
+        audioFile = nil
+    }
+
+    /// Extracts the waveform data from the audio file.
+    ///
+    /// - Parameters:
+    ///   - numberOfSamples: The number of samples to extract for the waveform.
+    ///   - offset: The offset to start reading from.
+    ///   - length: The length of the audio to read.
+    /// - Returns: A 2D array of floats where each sub-array represents waveform data for a specific channel.
+    public func extractWaveform(numberOfSamples: Int?, offset: Int? = 0, length: UInt? = nil) -> [[Float]]? {
+        guard let audioFile = audioFile else { return nil }
+        
+        let numberOfSamples = max(1, numberOfSamples ?? 100)
+        let totalFrameCount = AVAudioFrameCount(audioFile.length)
+        var framesPerBuffer = totalFrameCount / AVAudioFrameCount(numberOfSamples)
+        
+        guard let rmsBuffer = AVAudioPCMBuffer(pcmFormat: audioFile.processingFormat, frameCapacity: AVAudioFrameCount(framesPerBuffer)) else { return nil }
+        
+        channelCount = Int(audioFile.processingFormat.channelCount)
+        var data = Array(repeating: [Float](repeating: 0, count: numberOfSamples), count: channelCount)
+        
+        var startFrame: AVAudioFramePosition = offset == nil ? audioFile.framePosition : Int64(offset! * Int(framesPerBuffer))
+        var end = numberOfSamples
+        if let length = length {
+            end = Int(length)
+        }
+        
+        for i in 0..<end {
+            if abortWaveformExtraction {
+                audioFile.framePosition = startFrame
+                abortWaveformExtraction = false
+                return nil
+            }
+            
+            do {
+                audioFile.framePosition = startFrame
+                try audioFile.read(into: rmsBuffer, frameCount: framesPerBuffer)
+            } catch {
+                reject("AUDIO_READ_ERROR", "Couldn't read into buffer")
+                return nil
+            }
+            
+            guard let floatData = rmsBuffer.floatChannelData else { return nil }
+            
+            for channel in 0..<channelCount {
+                var rms: Float = 0.0
+                vDSP_rmsqv(floatData[channel], 1, &rms, vDSP_Length(rmsBuffer.frameLength))
+                data[channel][i] = rms
+            }
+            
+            currentProgress += 1
+            progress = currentProgress / Float(numberOfSamples)
+            
+            startFrame += AVAudioFramePosition(framesPerBuffer)
+            if startFrame + AVAudioFramePosition(framesPerBuffer) > AVAudioFramePosition(totalFrameCount) {
+                framesPerBuffer = totalFrameCount - AVAudioFrameCount(startFrame)
+                if framesPerBuffer <= 0 { break }
+            }
+        }
+        
+        return data
+    }
+
+    /// Cancels the waveform extraction process.
+    public func cancel() {
+        abortWaveformExtraction = true
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siteed/expo-audio-stream",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "stream audio crossplatform",
   "license": "MIT",
   "main": "build/index.js",
@@ -9,7 +9,8 @@
   "homepage": "https://github.com/deeeed/expo-audio-stream#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/deeeed/expo-audio-stream.git"
+    "url": "git+https://github.com/deeeed/expo-audio-stream.git",
+    "directory": "packages/expo-audio-stream"
   },
   "bugs": {
     "url": "https://github.com/deeeed/expo-audio-stream/issues"
@@ -27,32 +28,32 @@
     "test": "expo-module test",
     "prepare": "expo-module prepare",
     "prepublishOnly": "expo-module prepublishOnly",
-    "release": "release-it",
     "expo-module": "expo-module",
-    "open:ios": "open -a \"Xcode\" example/ios",
-    "open:android": "open -a \"Android Studio\" example/android"
-  },
-  "dependencies": {
-    "react-native-quick-base64": "^2.1.2"
+    "open:ios": "open -a \"Xcode\" ../../apps/playground/ios",
+    "open:android": "open -a \"Android Studio\" ../../apps/playground/android",
+    "size": "bundle-size && size-limit"
   },
   "devDependencies": {
     "@expo/config-plugins": "^7.9.1",
-    "@release-it/conventional-changelog": "^8.0.1",
+    "@size-limit/preset-big-lib": "^11.1.4",
     "@types/debug": "^4.1.12",
     "@types/node": "^20.12.7",
     "@types/react": "^18.0.25",
     "@typescript-eslint/eslint-plugin": "^7.7.0",
     "@typescript-eslint/parser": "^7.7.0",
+    "bundle-size": "^1.1.5",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-universe": "^12.0.0",
+    "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-promise": "^6.1.1",
     "eslint-plugin-react": "^7.34.1",
-    "expo-module-scripts": "^3.4.2",
-    "expo-modules-core": "^1.11.12",
+    "expo-module-scripts": "^3.5.2",
+    "expo-modules-core": "^1.12.19",
     "prettier": "^3.2.5",
-    "release-it": "^17.2.0"
+    "react-native": "^0.74.3",
+    "size-limit": "^11.1.4"
   },
   "peerDependencies": {
     "expo": "*",

package/plugin/tsconfig.json

@@ -1,9 +1,14 @@
 {
-    "extends": "expo-module-scripts/tsconfig.plugin",
-    "compilerOptions": {
-      "outDir": "build",
-      "rootDir": "src"
-    },
-    "include": ["./src"],
-    "exclude": ["**/__mocks__/*", "**/__tests__/*"]
-  }
+  "extends": "expo-module-scripts/tsconfig.plugin",
+  "compilerOptions": {
+    "outDir": "build",
+    "rootDir": "src"
+  },
+  "include": [
+    "./src",
+  ],
+  "exclude": [
+    "**/__mocks__/*",
+    "**/__tests__/*"
+  ]
+}

package/publish.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -e
+# Bump version
+yarn version patch
+version=$(node -p "require('./package.json').version")
+git add .
+git commit -m 'feat: bump version to $version'
+yarn clean && yarn prepare && npm publish

package/src/AudioAnalysis/AudioAnalysis.types.ts

@@ -0,0 +1,85 @@
+// packages/expo-audio-stream/src/AudioAnalysis/AudioAnalysis.types.ts
+
+/**
+ * Represents various audio features extracted from an audio signal.
+ */
+export interface AudioFeatures {
+  energy: number; // The infinite integral of the squared signal, representing the overall energy of the audio.
+  mfcc: number[]; // Mel-frequency cepstral coefficients, describing the short-term power spectrum of a sound.
+  rms: number; // Root mean square value, indicating the amplitude of the audio signal.
+  minAmplitude: number; // Minimum amplitude value in the audio signal.
+  maxAmplitude: number; // Maximum amplitude value in the audio signal.
+  zcr: number; // Zero-crossing rate, indicating the rate at which the signal changes sign.
+  spectralCentroid: number; // The center of mass of the spectrum, indicating the brightness of the sound.
+  spectralFlatness: number; // Measure of the flatness of the spectrum, indicating how noise-like the signal is.
+  spectralRolloff: number; // The frequency below which a specified percentage (usually 85%) of the total spectral energy lies.
+  spectralBandwidth: number; // The width of the spectrum, indicating the range of frequencies present.
+  chromagram: number[]; // Chromagram, representing the 12 different pitch classes of the audio.
+  tempo: number; // Estimated tempo of the audio signal, measured in beats per minute (BPM).
+  hnr: number; // Harmonics-to-noise ratio, indicating the proportion of harmonics to noise in the audio signal.
+}
+
+/**
+ * Options to specify which audio features to extract.
+ */
+export interface AudioFeaturesOptions {
+  energy?: boolean;
+  mfcc?: boolean;
+  rms?: boolean;
+  zcr?: boolean;
+  spectralCentroid?: boolean;
+  spectralFlatness?: boolean;
+  spectralRolloff?: boolean;
+  spectralBandwidth?: boolean;
+  chromagram?: boolean;
+  tempo?: boolean;
+  hnr?: boolean;
+}
+
+/**
+ * Represents a single data point in the audio analysis.
+ */
+export interface DataPoint {
+  id: number;
+  amplitude: number;
+  activeSpeech?: boolean;
+  dB?: number;
+  silent?: boolean;
+  features?: AudioFeatures;
+  startTime?: number;
+  endTime?: number;
+  // start / end position in bytes
+  startPosition?: number;
+  endPosition?: number;
+  // number of audio samples for this point (samples size depends on bit depth)
+  samples?: number;
+  // TODO: speaker detection
+  speaker?: number;
+}
+
+/**
+ * Represents the complete data from the audio analysis.
+ */
+export interface AudioAnalysisData {
+  pointsPerSecond: number; // How many consolidated value per second
+  durationMs: number; // Duration of the audio in milliseconds
+  bitDepth: number; // Bit depth of the audio
+  samples: number; // Size of the audio in bytes
+  numberOfChannels: number; // Number of audio channels
+  sampleRate: number; // Sample rate of the audio
+  dataPoints: DataPoint[]; // Array of data points from the analysis.
+  amplitudeRange: {
+    min: number;
+    max: number;
+  };
+  // TODO: speaker detection
+  speakerChanges?: {
+    timestamp: number; // Timestamp of the speaker change in milliseconds.
+    speaker: number; // Speaker identifier.
+  }[];
+}
+
+export interface AudioAnalysisEventPayload {
+  analysis: AudioAnalysisData;
+  visualizationDuration: number;
+}