@siteed/expo-audio-stream 1.0.1 → 1.0.3

package/build/workers/inlineAudioWebWorker.web.d.ts

@@ -0,0 +1,2 @@
+export declare 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";
+//# sourceMappingURL=inlineAudioWebWorker.web.d.ts.map

package/build/workers/inlineAudioWebWorker.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineAudioWebWorker.web.d.ts","sourceRoot":"","sources":["../../src/workers/inlineAudioWebWorker.web.tsx"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,4/PAiPhC,CAAC"}

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/expo-module.config.json

@@ -1,9 +1,18 @@
 {
-  "platforms": ["ios", "tvos", "android", "web"],
+  "platforms": [
+    "ios",
+    "tvos",
+    "android",
+    "web"
+  ],
   "ios": {
-    "modules": ["ExpoAudioStreamModule"]
+    "modules": [
+      "ExpoAudioStreamModule"
+    ]
   },
   "android": {
-    "modules": ["net.siteed.audiostream.ExpoAudioStreamModule"]
+    "modules": [
+      "net.siteed.audiostream.ExpoAudioStreamModule"
+    ]
   }
-}
+}

package/ios/AudioAnalysisData.swift

@@ -0,0 +1,39 @@
+//
+//  AudioAnalysisData.swift
+//  ExpoAudioStream
+//
+//  Created by Arthur Breton on 23/6/2024.
+//
+
+import Foundation
+
+public struct AudioAnalysisData {
+    public var pointsPerSecond: Int
+    public var durationMs: Float
+    public var bitDepth: Int
+    public var numberOfChannels: Int
+    public var sampleRate: Float
+    public var samples: Int
+    public var dataPoints: [DataPoint]
+    public var amplitudeRange: (min: Float, max: Float)
+    public var speakerChanges: [(timestamp: Float, speaker: Int)]?
+    public var extractionTimeMs: Float
+}
+
+extension AudioAnalysisData {
+    func toDictionary() -> [String: Any] {
+        let dataPointsArray = dataPoints.map { $0.toDictionary() }
+        return [
+            "pointsPerSecond": pointsPerSecond,
+            "durationMs": durationMs,
+            "bitDepth": bitDepth,
+            "numberOfChannels": numberOfChannels,
+            "sampleRate": sampleRate,
+            "samples": samples,
+            "dataPoints": dataPointsArray,
+            "amplitudeRange": ["min": amplitudeRange.min, "max": amplitudeRange.max],
+            "speakerChanges": speakerChanges?.map { ["timestamp": $0.timestamp, "speaker": $0.speaker] } ?? [],
+            "extractionTimeMs": extractionTimeMs
+        ]
+    }
+}

package/ios/AudioProcessingHelpers.swift

@@ -0,0 +1,59 @@
+// AudioProcessingHelpers.swift
+
+import Accelerate
+
+func extractMFCC(from segment: [Float], sampleRate: Float) -> [Float] {
+    // Placeholder for MFCC extraction logic
+    return []
+}
+
+func extractSpectralCentroid(from segment: [Float], sampleRate: Float) -> Float {
+    Logger.debug("Extracting Spectral Centroid from segment of length \(segment.count)")
+    return 0.0 // TODO: Implement spectral centroid extraction logic
+}
+
+func extractSpectralFlatness(from segment: [Float]) -> Float {
+    Logger.debug("Extracting Spectral Flatness from segment of length \(segment.count)")
+    
+    var mean: Float = 0.0
+    var geometricMean: Float = 1.0
+    let count = vDSP_Length(segment.count)
+    
+    vDSP_meamgv(segment, 1, &mean, count)
+    
+    var sumLogValues: Float = 0.0
+    for value in segment {
+        let adjustedValue = max(value, 1e-10)
+        sumLogValues += log(adjustedValue)
+    }
+    geometricMean = exp(sumLogValues / Float(count))
+    
+    let spectralFlatness = mean > 0 ? geometricMean / mean : 0.0
+    Logger.debug("Spectral Flatness: \(spectralFlatness)")
+    return spectralFlatness
+}
+
+func extractSpectralRollOff(from segment: [Float], sampleRate: Float) -> Float {
+    // Implement spectral roll-off extraction logic
+    return 0.0
+}
+
+func extractSpectralBandwidth(from segment: [Float], sampleRate: Float) -> Float {
+    // Implement spectral bandwidth extraction logic
+    return 0.0
+}
+
+func extractChromagram(from segment: [Float], sampleRate: Float) -> [Float] {
+    // Implement chromagram extraction logic
+    return []
+}
+
+func extractTempo(from segment: [Float], sampleRate: Float) -> Float {
+    // Implement tempo extraction logic
+    return 0.0
+}
+
+func extractHNR(from segment: [Float]) -> Float {
+    // Implement harmonic-to-noise ratio extraction logic
+    return 0.0
+}