@siteed/expo-audio-stream 1.0.2 → 1.0.3

package/build/workers/inlineAudioWebWorker.web.js

@@ -0,0 +1,243 @@
+export const InlineAudioWebWorker = `
+const DEFAULT_BIT_DEPTH = 32;
+const DEFAULT_SAMPLE_RATE = 44100;
+
+class RecorderProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.recordedBuffers = []; // Float32Array
+    this.newRecBuffer = []; // Float32Array
+    this.resampledBuffer = []; // Float32Array
+    this.exportIntervalSamples = 0;
+    this.samplesSinceLastExport = 0;
+    this.recordSampleRate = DEFAULT_SAMPLE_RATE; // To be overwritten
+    this.exportSampleRate = DEFAULT_SAMPLE_RATE; // To be overwritten
+    this.recordBitDepth = DEFAULT_BIT_DEPTH; // Default to 32-bit depth
+    this.exportBitDepth = DEFAULT_BIT_DEPTH; // To be overwritten
+    this.numberOfChannels = 1; // Default to 1 channel (mono)
+    this.isRecording = true;
+    this.port.onmessage = this.handleMessage.bind(this);
+  }
+
+  handleMessage(event) {
+    switch (event.data.command) {
+      case "init":
+        this.recordSampleRate = event.data.recordSampleRate;
+        this.exportSampleRate =
+          event.data.exportSampleRate || event.data.recordSampleRate;
+        this.exportIntervalSamples =
+          this.recordSampleRate * (event.data.interval / 1000);
+        if (event.data.numberOfChannels) {
+          this.numberOfChannels = event.data.numberOfChannels;
+        }
+        if (event.data.recordBitDepth) {
+          this.recordBitDepth = event.data.recordBitDepth;
+        }
+        this.exportBitDepth =
+          event.data.exportBitDepth || this.recordBitDepth || DEFAULT_BIT_DEPTH;
+        break;
+      case "stop":
+        this.isRecording = false;
+        this.getAllRecordedData()
+          .then((fullRecordedData) => {
+            this.port.postMessage({
+              command: "recordedData",
+              recordedData: fullRecordedData,
+              bitDepth: this.exportBitDepth,
+              sampleRate: this.exportSampleRate,
+            });
+            return fullRecordedData;
+          })
+          .catch((error) => {
+            console.error("Error extracting recorded data:", error);
+          });
+        break;
+    }
+  }
+
+  process(inputs, outputs, parameters) {
+    if (!this.isRecording) return true;
+    const input = inputs[0];
+    if (input.length > 0) {
+      const newBuffer = new Float32Array(input[0]);
+      this.newRecBuffer.push(newBuffer);
+      this.recordedBuffers.push(newBuffer);
+      this.samplesSinceLastExport += newBuffer.length;
+
+      if (this.samplesSinceLastExport >= this.exportIntervalSamples) {
+        this.exportNewData();
+        this.samplesSinceLastExport = 0;
+      }
+    }
+    return true;
+  }
+
+  mergeBuffers(bufferArray, recLength) {
+    const result = new Float32Array(recLength);
+    let offset = 0;
+    for (let i = 0; i < bufferArray.length; i++) {
+      result.set(bufferArray[i], offset);
+      offset += bufferArray[i].length;
+    }
+    return result;
+  }
+
+  floatTo16BitPCM(input) {
+    const output = new Int16Array(input.length);
+    for (let i = 0; i < input.length; i++) {
+      const s = Math.max(-1, Math.min(1, input[i]));
+      output[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
+    }
+    console.debug(
+      "Float to 16-bit PCM conversion complete. Output byte length:",
+      output.byteLength,
+    );
+    return output;
+  }
+
+  floatTo32BitPCM(input) {
+    const output = new Int32Array(input.length);
+    for (let i = 0; i < input.length; i++) {
+      const s = Math.max(-1, Math.min(1, input[i]));
+      output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff;
+    }
+    console.debug(
+      "Float to 32-bit PCM conversion complete. Output byte length:",
+      output.byteLength,
+    );
+    return output;
+  }
+
+  resample(samples, targetSampleRate) {
+    if (this.recordSampleRate === targetSampleRate) {
+      return samples;
+    }
+    const resampledBuffer = new Float32Array(
+      (samples.length * targetSampleRate) / this.recordSampleRate,
+    );
+    const ratio = this.recordSampleRate / targetSampleRate;
+    let offset = 0;
+    for (let i = 0; i < resampledBuffer.length; i++) {
+      const nextOffset = Math.floor((i + 1) * ratio);
+      let accum = 0;
+      let count = 0;
+      for (let j = offset; j < nextOffset && j < samples.length; j++) {
+        accum += samples[j];
+        count++;
+      }
+      resampledBuffer[i] = accum / count;
+      offset = nextOffset;
+    }
+    return resampledBuffer;
+  }
+
+  async resampleBuffer(buffer, targetSampleRate) {
+    if (typeof OfflineAudioContext === "undefined") {
+      return this.resample(buffer, targetSampleRate);
+    }
+
+    if (this.recordSampleRate === targetSampleRate) {
+      return buffer;
+    }
+    const offlineContext = new OfflineAudioContext(
+      this.numberOfChannels,
+      buffer.length,
+      this.recordSampleRate,
+    );
+    const sourceBuffer = offlineContext.createBuffer(
+      this.numberOfChannels,
+      buffer.length,
+      this.recordSampleRate,
+    );
+    sourceBuffer.copyToChannel(buffer, 0);
+
+    const bufferSource = offlineContext.createBufferSource();
+    bufferSource.buffer = sourceBuffer;
+    bufferSource.connect(offlineContext.destination);
+    bufferSource.start();
+
+    const renderedBuffer = await offlineContext.startRendering();
+
+    const resampledBuffer = new Float32Array(renderedBuffer.length);
+    renderedBuffer.copyFromChannel(resampledBuffer, 0);
+
+    return resampledBuffer;
+  }
+
+  async exportNewData() {
+    // Calculate the total length of the new recorded buffers
+    const length = this.newRecBuffer.reduce(
+      (acc, buffer) => acc + buffer.length,
+      0,
+    );
+
+    // Merge all new recorded buffers into a single buffer
+    const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length);
+
+    const resampledBuffer = await this.resampleBuffer(
+      mergedBuffer,
+      this.exportSampleRate,
+    );
+
+    let finalBuffer = resampledBuffer; // Float32Array
+    if (this.recordBitDepth !== this.exportBitDepth) {
+      if (this.exportBitDepth === 16) {
+        finalBuffer = this.floatTo16BitPCM(resampledBuffer);
+      } else if (this.exportBitDepth === 32) {
+        finalBuffer = this.floatTo32BitPCM(resampledBuffer);
+      }
+    }
+
+    const originalSize = mergedBuffer.byteLength;
+    const resampledSize = resampledBuffer.byteLength;
+    const finalSize = finalBuffer.byteLength;
+
+    // Clear the new recorded buffers after they have been processed
+    this.newRecBuffer.length = 0;
+
+    // Post the message to the main thread
+    // The first argument is the message data, containing the encoded WAV buffer
+    // The second argument is the transfer list, which transfers ownership of the ArrayBuffer
+    // to the main thread, avoiding the need to copy the buffer and improving performance
+    // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);
+    this.port.postMessage({
+      command: "newData",
+      recordedData: finalBuffer.buffer,
+      sampleRate: this.exportSampleRate,
+      bitDepth: this.exportBitDepth,
+    });
+  }
+
+  async getAllRecordedData() {
+    const length = this.recordedBuffers.reduce(
+      (acc, buffer) => acc + buffer.length,
+      0,
+    );
+    const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length);
+    const resampledBuffer = await this.resampleBuffer(
+      mergedBuffer,
+      this.exportSampleRate,
+    );
+    // Convert to the desired bit depth if necessary
+    let finalBuffer = resampledBuffer;
+    if (this.recordBitDepth !== this.exportBitDepth) {
+      if (this.exportBitDepth === 16) {
+        finalBuffer = this.floatTo16BitPCM(resampledBuffer);
+      } else if (this.exportBitDepth === 32) {
+        finalBuffer = this.floatTo32BitPCM(resampledBuffer);
+      }
+    }
+
+    const originalSize = mergedBuffer.byteLength;
+    const resampledSize = resampledBuffer.byteLength;
+    const finalSize = finalBuffer.byteLength;
+
+    this.recordedBuffers.length = 0; // Clear the buffers after extraction
+
+    return finalBuffer.buffer;
+  }
+}
+
+registerProcessor("recorder-processor", RecorderProcessor);
+`;
+//# sourceMappingURL=inlineAudioWebWorker.web.js.map

package/build/workers/inlineAudioWebWorker.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineAudioWebWorker.web.js","sourceRoot":"","sources":["../../src/workers/inlineAudioWebWorker.web.tsx"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiPnC,CAAC","sourcesContent":["export const InlineAudioWebWorker = `\nconst DEFAULT_BIT_DEPTH = 32;\nconst DEFAULT_SAMPLE_RATE = 44100;\n\nclass RecorderProcessor extends AudioWorkletProcessor {\n  constructor() {\n    super();\n    this.recordedBuffers = []; // Float32Array\n    this.newRecBuffer = []; // Float32Array\n    this.resampledBuffer = []; // Float32Array\n    this.exportIntervalSamples = 0;\n    this.samplesSinceLastExport = 0;\n    this.recordSampleRate = DEFAULT_SAMPLE_RATE; // To be overwritten\n    this.exportSampleRate = DEFAULT_SAMPLE_RATE; // To be overwritten\n    this.recordBitDepth = DEFAULT_BIT_DEPTH; // Default to 32-bit depth\n    this.exportBitDepth = DEFAULT_BIT_DEPTH; // To be overwritten\n    this.numberOfChannels = 1; // Default to 1 channel (mono)\n    this.isRecording = true;\n    this.port.onmessage = this.handleMessage.bind(this);\n  }\n\n  handleMessage(event) {\n    switch (event.data.command) {\n      case \"init\":\n        this.recordSampleRate = event.data.recordSampleRate;\n        this.exportSampleRate =\n          event.data.exportSampleRate || event.data.recordSampleRate;\n        this.exportIntervalSamples =\n          this.recordSampleRate * (event.data.interval / 1000);\n        if (event.data.numberOfChannels) {\n          this.numberOfChannels = event.data.numberOfChannels;\n        }\n        if (event.data.recordBitDepth) {\n          this.recordBitDepth = event.data.recordBitDepth;\n        }\n        this.exportBitDepth =\n          event.data.exportBitDepth || this.recordBitDepth || DEFAULT_BIT_DEPTH;\n        break;\n      case \"stop\":\n        this.isRecording = false;\n        this.getAllRecordedData()\n          .then((fullRecordedData) => {\n            this.port.postMessage({\n              command: \"recordedData\",\n              recordedData: fullRecordedData,\n              bitDepth: this.exportBitDepth,\n              sampleRate: this.exportSampleRate,\n            });\n            return fullRecordedData;\n          })\n          .catch((error) => {\n            console.error(\"Error extracting recorded data:\", error);\n          });\n        break;\n    }\n  }\n\n  process(inputs, outputs, parameters) {\n    if (!this.isRecording) return true;\n    const input = inputs[0];\n    if (input.length > 0) {\n      const newBuffer = new Float32Array(input[0]);\n      this.newRecBuffer.push(newBuffer);\n      this.recordedBuffers.push(newBuffer);\n      this.samplesSinceLastExport += newBuffer.length;\n\n      if (this.samplesSinceLastExport >= this.exportIntervalSamples) {\n        this.exportNewData();\n        this.samplesSinceLastExport = 0;\n      }\n    }\n    return true;\n  }\n\n  mergeBuffers(bufferArray, recLength) {\n    const result = new Float32Array(recLength);\n    let offset = 0;\n    for (let i = 0; i < bufferArray.length; i++) {\n      result.set(bufferArray[i], offset);\n      offset += bufferArray[i].length;\n    }\n    return result;\n  }\n\n  floatTo16BitPCM(input) {\n    const output = new Int16Array(input.length);\n    for (let i = 0; i < input.length; i++) {\n      const s = Math.max(-1, Math.min(1, input[i]));\n      output[i] = s < 0 ? s * 0x8000 : s * 0x7fff;\n    }\n    console.debug(\n      \"Float to 16-bit PCM conversion complete. Output byte length:\",\n      output.byteLength,\n    );\n    return output;\n  }\n\n  floatTo32BitPCM(input) {\n    const output = new Int32Array(input.length);\n    for (let i = 0; i < input.length; i++) {\n      const s = Math.max(-1, Math.min(1, input[i]));\n      output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff;\n    }\n    console.debug(\n      \"Float to 32-bit PCM conversion complete. Output byte length:\",\n      output.byteLength,\n    );\n    return output;\n  }\n\n  resample(samples, targetSampleRate) {\n    if (this.recordSampleRate === targetSampleRate) {\n      return samples;\n    }\n    const resampledBuffer = new Float32Array(\n      (samples.length * targetSampleRate) / this.recordSampleRate,\n    );\n    const ratio = this.recordSampleRate / targetSampleRate;\n    let offset = 0;\n    for (let i = 0; i < resampledBuffer.length; i++) {\n      const nextOffset = Math.floor((i + 1) * ratio);\n      let accum = 0;\n      let count = 0;\n      for (let j = offset; j < nextOffset && j < samples.length; j++) {\n        accum += samples[j];\n        count++;\n      }\n      resampledBuffer[i] = accum / count;\n      offset = nextOffset;\n    }\n    return resampledBuffer;\n  }\n\n  async resampleBuffer(buffer, targetSampleRate) {\n    if (typeof OfflineAudioContext === \"undefined\") {\n      return this.resample(buffer, targetSampleRate);\n    }\n\n    if (this.recordSampleRate === targetSampleRate) {\n      return buffer;\n    }\n    const offlineContext = new OfflineAudioContext(\n      this.numberOfChannels,\n      buffer.length,\n      this.recordSampleRate,\n    );\n    const sourceBuffer = offlineContext.createBuffer(\n      this.numberOfChannels,\n      buffer.length,\n      this.recordSampleRate,\n    );\n    sourceBuffer.copyToChannel(buffer, 0);\n\n    const bufferSource = offlineContext.createBufferSource();\n    bufferSource.buffer = sourceBuffer;\n    bufferSource.connect(offlineContext.destination);\n    bufferSource.start();\n\n    const renderedBuffer = await offlineContext.startRendering();\n\n    const resampledBuffer = new Float32Array(renderedBuffer.length);\n    renderedBuffer.copyFromChannel(resampledBuffer, 0);\n\n    return resampledBuffer;\n  }\n\n  async exportNewData() {\n    // Calculate the total length of the new recorded buffers\n    const length = this.newRecBuffer.reduce(\n      (acc, buffer) => acc + buffer.length,\n      0,\n    );\n\n    // Merge all new recorded buffers into a single buffer\n    const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length);\n\n    const resampledBuffer = await this.resampleBuffer(\n      mergedBuffer,\n      this.exportSampleRate,\n    );\n\n    let finalBuffer = resampledBuffer; // Float32Array\n    if (this.recordBitDepth !== this.exportBitDepth) {\n      if (this.exportBitDepth === 16) {\n        finalBuffer = this.floatTo16BitPCM(resampledBuffer);\n      } else if (this.exportBitDepth === 32) {\n        finalBuffer = this.floatTo32BitPCM(resampledBuffer);\n      }\n    }\n\n    const originalSize = mergedBuffer.byteLength;\n    const resampledSize = resampledBuffer.byteLength;\n    const finalSize = finalBuffer.byteLength;\n\n    // Clear the new recorded buffers after they have been processed\n    this.newRecBuffer.length = 0;\n\n    // Post the message to the main thread\n    // The first argument is the message data, containing the encoded WAV buffer\n    // The second argument is the transfer list, which transfers ownership of the ArrayBuffer\n    // to the main thread, avoiding the need to copy the buffer and improving performance\n    // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);\n    this.port.postMessage({\n      command: \"newData\",\n      recordedData: finalBuffer.buffer,\n      sampleRate: this.exportSampleRate,\n      bitDepth: this.exportBitDepth,\n    });\n  }\n\n  async getAllRecordedData() {\n    const length = this.recordedBuffers.reduce(\n      (acc, buffer) => acc + buffer.length,\n      0,\n    );\n    const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length);\n    const resampledBuffer = await this.resampleBuffer(\n      mergedBuffer,\n      this.exportSampleRate,\n    );\n    // Convert to the desired bit depth if necessary\n    let finalBuffer = resampledBuffer;\n    if (this.recordBitDepth !== this.exportBitDepth) {\n      if (this.exportBitDepth === 16) {\n        finalBuffer = this.floatTo16BitPCM(resampledBuffer);\n      } else if (this.exportBitDepth === 32) {\n        finalBuffer = this.floatTo32BitPCM(resampledBuffer);\n      }\n    }\n\n    const originalSize = mergedBuffer.byteLength;\n    const resampledSize = resampledBuffer.byteLength;\n    const finalSize = finalBuffer.byteLength;\n\n    this.recordedBuffers.length = 0; // Clear the buffers after extraction\n\n    return finalBuffer.buffer;\n  }\n}\n\nregisterProcessor(\"recorder-processor\", RecorderProcessor);\n`;\n"]}

package/ios/AudioStreamManager.swift

@@ -32,6 +32,8 @@ class AudioStreamManager: NSObject {
     internal var recordingFileURL: URL?
     private var audioProcessor: AudioProcessor?
     private var startTime: Date?
+    private var pauseStartTime: Date?
+
     internal var lastEmissionTime: Date?
     internal var lastEmittedSize: Int64 = 0
     private var emissionInterval: TimeInterval = 1.0 // Default to 1 second
@@ -144,8 +146,8 @@ class AudioStreamManager: NSObject {
         
         // Calculate the duration in seconds
         let durationInSeconds = Double(totalDataSize) / (sampleRate * channels * (bitDepth / 8))
-        let durationInMilliseconds = Int(durationInSeconds * 1000)
-        
+        let durationInMilliseconds = Int(durationInSeconds * 1000) - Int(pausedDuration * 1000)
+
         return [
             "durationMs": durationInMilliseconds,
             "isRecording": isRecording,
@@ -192,6 +194,8 @@ class AudioStreamManager: NSObject {
         lastEmissionTime = Date()
         accumulatedData.removeAll()
         totalDataSize = 0
+        pausedDuration = 0
+        isPaused = false
         
         let session = AVAudioSession.sharedInstance()
         do {
@@ -283,6 +287,39 @@ class AudioStreamManager: NSObject {
         }
     }
     
+    /// Pauses the current audio recording.
+    func pauseRecording() {
+        guard isRecording && !isPaused else {
+            Logger.debug("Recording is not in progress or already paused.")
+            return
+        }
+        
+        audioEngine.pause()
+        isPaused = true
+        pauseStartTime = Date()
+        
+        Logger.debug("Recording paused.")
+    }
+    
+    /// Resumes the current audio recording.
+    func resumeRecording() {
+        guard isRecording && isPaused else {
+            Logger.debug("Recording is not in progress or not paused.")
+            return
+        }
+        
+        audioEngine.prepare()
+        do {
+            try audioEngine.start()
+            isPaused = false
+            if let pauseStartTime = pauseStartTime {
+                pausedDuration += Int(Date().timeIntervalSince(pauseStartTime))
+            }
+            Logger.debug("Recording resumed.")
+        } catch {
+            Logger.debug("Error: Failed to resume recording: \(error.localizedDescription)")
+        }
+    }
     
     /// Describes the format of the given audio format.
     /// - Parameter format: The AVAudioFormat object to describe.

package/ios/ExpoAudioStreamModule.swift

@@ -178,6 +178,16 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
             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:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siteed/expo-audio-stream",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "stream audio crossplatform",
   "license": "MIT",
   "main": "build/index.js",
@@ -30,18 +30,18 @@
     "prepublishOnly": "expo-module prepublishOnly",
     "expo-module": "expo-module",
     "open:ios": "open -a \"Xcode\" ../../apps/playground/ios",
-    "open:android": "open -a \"Android Studio\" ../../apps/playground/android"
-  },
-  "dependencies": {
-    "react-native-quick-base64": "^2.1.2"
+    "open:android": "open -a \"Android Studio\" ../../apps/playground/android",
+    "size": "bundle-size && size-limit"
   },
   "devDependencies": {
     "@expo/config-plugins": "^7.9.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",
@@ -52,7 +52,8 @@
     "expo-module-scripts": "^3.5.2",
     "expo-modules-core": "^1.12.19",
     "prettier": "^3.2.5",
-    "react-native": "^0.74.3"
+    "react-native": "^0.74.3",
+    "size-limit": "^11.1.4"
   },
   "peerDependencies": {
     "expo": "*",

package/plugin/tsconfig.json

@@ -5,7 +5,7 @@
     "rootDir": "src"
   },
   "include": [
-    "./src"
+    "./src",
   ],
   "exclude": [
     "**/__mocks__/*",

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;
+}

package/src/AudioAnalysis/extractAudioAnalysis.ts

@@ -0,0 +1,136 @@
+// packages/expo-audio-stream/src/AudioAnalysis/extractAudioAnalysis.ts
+import { AudioAnalysisData } from "./AudioAnalysis.types";
+import ExpoAudioStreamModule from "../ExpoAudioStreamModule";
+import { isWeb } from "../constants";
+import { getLogger } from "../logger";
+import { ExtractMetadataProps } from "../useAudioRecorder";
+import { convertPCMToFloat32 } from "../utils/convertPCMToFloat32";
+import { getWavFileInfo } from "../utils/getWavFileInfo";
+import { InlineFeaturesExtractor } from "../workers/InlineFeaturesExtractor.web";
+
+const logger = getLogger("extractAudioAnalysis");
+
+export const extractAudioAnalysis = async ({
+  fileUri,
+  pointsPerSecond = 20,
+  arrayBuffer,
+  bitDepth,
+  skipWavHeader,
+  durationMs,
+  sampleRate,
+  numberOfChannels,
+  algorithm = "rms",
+  features,
+  featuresExtratorUrl,
+}: ExtractMetadataProps): Promise<AudioAnalysisData> => {
+  if (isWeb) {
+    if (!arrayBuffer && !fileUri) {
+      throw new Error("Either arrayBuffer or fileUri must be provided");
+    }
+
+    if (!arrayBuffer) {
+      logger.log(`fetching fileUri`, fileUri);
+      const response = await fetch(fileUri!);
+
+      if (!response.ok) {
+        throw new Error(`Failed to fetch fileUri: ${response.statusText}`);
+      }
+
+      arrayBuffer = (await response.arrayBuffer()).slice(0);
+      logger.log(`fetched fileUri`, arrayBuffer.byteLength, arrayBuffer);
+    }
+
+    // Create a new copy of the ArrayBuffer to avoid detachment issues
+    const bufferCopy = arrayBuffer.slice(0);
+    logger.log(
+      `extractAudioAnalysis skipWavHeader=${skipWavHeader} bitDepth=${bitDepth} len=${bufferCopy.byteLength}`,
+      bufferCopy.slice(0, 100),
+    );
+
+    let actualBitDepth = bitDepth;
+    if (!actualBitDepth) {
+      logger.log(
+        `extractAudioAnalysis bitDepth not provided -- getting wav file info`,
+      );
+      const fileInfo = await getWavFileInfo(bufferCopy);
+      actualBitDepth = fileInfo.bitDepth;
+    }
+    logger.log(`extractAudioAnalysis actualBitDepth=${actualBitDepth}`);
+    // let copyChannelData: Float32Array;
+    // try {
+    //   const audioContext = new (window.AudioContext ||
+    //     // @ts-ignore
+    //     window.webkitAudioContext)();
+    //   const audioBuffer = await audioContext.decodeAudioData(bufferCopy);
+    //   const channelData = audioBuffer.getChannelData(0); // Use only the first channel
+    //   copyChannelData = new Float32Array(channelData); // Create a new Float32Array
+    // } catch (error) {
+    //   console.warn("Failed to decode audio data:", error);
+    //   // Fall back to creating a new Float32Array from the ArrayBuffer if decoding fails
+    //   copyChannelData = new Float32Array(arrayBuffer);
+    // }
+
+    const {
+      pcmValues: channelData,
+      min,
+      max,
+    } = convertPCMToFloat32({
+      buffer: arrayBuffer,
+      bitDepth: actualBitDepth,
+      skipWavHeader,
+    });
+    logger.log(
+      `extractAudioAnalysis skipWaveHeader=${skipWavHeader} convertPCMToFloat32 length=${channelData.length} range: [ ${min} :: ${max} ]`,
+    );
+
+    return new Promise((resolve, reject) => {
+      let worker: Worker;
+      if (featuresExtratorUrl) {
+        worker = new Worker(new URL(featuresExtratorUrl, window.location.href));
+      } else {
+        const blob = new Blob([InlineFeaturesExtractor], {
+          type: "application/javascript",
+        });
+        const url = URL.createObjectURL(blob);
+        worker = new Worker(url);
+      }
+
+      worker.onmessage = (event) => {
+        resolve(event.data.result);
+      };
+
+      worker.onerror = (error) => {
+        reject(error);
+      };
+
+      worker.postMessage({
+        command: "process",
+        channelData,
+        sampleRate,
+        pointsPerSecond,
+        algorithm,
+        bitDepth,
+        fullAudioDurationMs: durationMs,
+        numberOfChannels,
+      });
+    });
+  } else {
+    if (!fileUri) {
+      throw new Error("fileUri is required");
+    }
+    logger.log(`extractAudioAnalysis`, {
+      fileUri,
+      pointsPerSecond,
+      algorithm,
+    });
+    const res = await ExpoAudioStreamModule.extractAudioAnalysis({
+      fileUri,
+      pointsPerSecond,
+      skipWavHeader,
+      algorithm,
+      features,
+    });
+    logger.log(`extractAudioAnalysis`, res);
+    return res;
+  }
+};

package/src/AudioAnalysis/extractWaveform.ts

@@ -0,0 +1,25 @@
+import ExpoAudioStreamModule from "../ExpoAudioStreamModule";
+import { getLogger } from "../logger";
+
+const logger = getLogger("extractWaveform");
+export interface ExtractWaveformProps {
+  fileUri: string;
+  numberOfSamples: number;
+  offset?: number;
+  length?: number;
+}
+export const extractWaveform = async ({
+  fileUri,
+  numberOfSamples,
+  offset = 0,
+  length,
+}: ExtractWaveformProps): Promise<unknown> => {
+  const res = await ExpoAudioStreamModule.extractAudioAnalysis({
+    fileUri,
+    numberOfSamples,
+    offset,
+    length,
+  });
+  logger.log(`extractWaveform`, res);
+  return res;
+};