@siteed/expo-audio-stream 1.0.0 → 1.0.2

package/build/inlineAudioWebWorker.js

@@ -0,0 +1,340 @@
+export const SimpleInlineProcessorScript = `
+class RecorderProcessor extends AudioWorkletProcessor {
+  constructor() {
+      super();
+      this.recordedBuffers = []; // Float32Array
+      this.newRecBuffer = []; // Float32Array
+      this.exportIntervalSamples = 0;
+      this.samplesSinceLastExport = 0;
+      this.recordSampleRate = 44100; // To be overwritten
+      this.exportSampleRate = 44100; // To be overwritten
+      this.channels = 1; // Default to 1 channel (mono)
+      this.bitDepth = 32; // Default to 32-bit depth
+      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);
+              break;
+          case 'stop':
+              this.isRecording = false;
+              const fullRecordedData = this.getAllRecordedData();
+              this.port.postMessage({ command: 'recordedData', recordedData: fullRecordedData });
+              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(output, offset, input) {
+      for (let i = 0; i < input.length; i++, offset += 2) {
+          const s = Math.max(-1, Math.min(1, input[i]));
+          output.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7FFF, true);
+      }
+      console.debug('Float to 16-bit PCM conversion complete. Output byte length:', offset);
+  }
+
+  floatTo32BitPCM(output, offset, input) {
+      for (let i = 0; i < input.length; i++, offset += 4) {
+          output.setFloat32(offset, input[i], true);
+      }
+      console.debug('Float to 32-bit PCM (no conversion) complete. Output byte length:', offset);
+  }
+
+  writeString(view, offset, string) {
+      for (let i = 0; i < string.length; i++) {
+          view.setUint8(offset + i, string.charCodeAt(i));
+      }
+  }
+
+  encodeWAV(samples, includeHeader = true) {
+      const sampleCount = samples.length;
+      const buffer = new ArrayBuffer((includeHeader ? 44 : 0) + sampleCount * 4);
+      const view = new DataView(buffer);
+
+      if (includeHeader) {
+          this.writeString(view, 0, 'RIFF');
+          view.setUint32(4, 36 + sampleCount * 4, true); // File size - 8 bytes
+          this.writeString(view, 8, 'WAVE');
+          this.writeString(view, 12, 'fmt ');
+          view.setUint32(16, 16, true); // PCM format
+          view.setUint16(20, 3, true); // Format code 3 for float
+          view.setUint16(22, 1, true); // Mono channel
+          view.setUint32(24, this.recordSampleRate, true); // Sample rate
+          view.setUint32(28, this.recordSampleRate * 4, true); // Byte rate
+          view.setUint16(32, 4, true); // Block align (4 bytes for 32-bit float)
+          view.setUint16(34, 32, true); // Bits per sample (32-bit float)
+          this.writeString(view, 36, 'data');
+          view.setUint32(40, sampleCount * 4, true); // Data chunk size
+      }
+
+      console.debug('Writing PCM samples to DataView. Offset:', includeHeader ? 44 : 0, 'Samples length:', sampleCount);
+      this.floatTo32BitPCM(view, includeHeader ? 44 : 0, samples);
+      // this.floatTo16BitPCM(view, includeHeader ? 44 : 0, samples);
+
+      console.debug('Encoded WAV DataView:', view);
+      console.debug('Encoded WAV length:', view.byteLength);
+
+      return view;
+  }
+
+
+  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);
+
+      // Encode the merged buffer into a WAV format
+      const encodedWav = this.encodeWAV(mergedBuffer, false);
+
+      // 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 }, [encodedWav.buffer]);
+  }
+
+  getAllRecordedData() {
+      const length = this.recordedBuffers.reduce((acc, buffer) => acc + buffer.length, 0);
+      const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length);
+
+
+      // Calculate the duration based on the sample count and sample rate
+      const sampleCount = mergedBuffer.length;
+      const mergedBufferDuration = sampleCount / this.recordSampleRate;
+
+      const encodedWav = this.encodeWAV(mergedBuffer, true);
+
+      // Calculate and log the duration for encodedWav.buffer based on sample count
+      const encodedWavBufferDuration = sampleCount / this.recordSampleRate;
+
+      this.recordedBuffers.length = 0; // Clear the buffers after extraction
+
+      // Returning both for testing, comment one of the returns based on your test
+      console.debug('mergedBuffer:', mergedBuffer);
+      console.debug('encodedWav.buffer:', encodedWav.buffer);
+
+      // Uncomment the appropriate return for testing
+      // return mergedBuffer; // This works when played
+      return encodedWav.buffer; // This doesn't work when played
+  }
+}
+
+registerProcessor('recorder-processor', RecorderProcessor);
+`;
+// Because we use expo and needs to include the worker script in the shared library, better inline it in the module.
+export const InlineProcessorScrippt = `
+class RecorderProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.recLength = 0;
+    this.recBuffer = [];
+    this.headerSent = false;
+    this.newRecBuffer = [];
+    this.exportIntervalSamples = 0;
+    this.samplesSinceLastExport = 0;
+    this.recordSampleRate = 44100; // To be overwrited
+    this.exportSampleRate = 44100; // To be overwrited
+    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);
+        break;
+      case 'stop':
+        this.isRecording = false;
+        break;
+      case 'getRecordedData':
+        const recordedData = this.getRecordedData();
+        this.port.postMessage({ command: 'recordedData', recordedData });
+        break;
+    }
+  }
+
+  process(inputs) {
+    if (!this.isRecording) {
+      return true; // Exit early if not recording
+    }
+
+    if (inputs.length === 0 || inputs[0].length === 0) {
+      console.warn('RecorderProcessor -- No input received.');
+      return true; // Exit early if no input
+    }
+
+    const buffer = inputs[0];
+    if (!buffer) {
+      console.error('Input buffer is null.');
+      return true; // Exit early if buffer is null
+    }
+
+    try {
+      this.record(buffer);
+
+      // this.samplesSinceLastExport += buffer.length;
+      // if (this.samplesSinceLastExport >= this.exportIntervalSamples) {
+      //   this.exportBuffer();
+      //   this.samplesSinceLastExport = 0;
+      // }
+    } catch (error) {
+      console.error('Error during processing:', error);
+    }
+    return true;
+  }
+
+  record(inputBuffer) {
+    this.recBuffer.push(inputBuffer);
+    this.newRecBuffer.push(inputBuffer);
+    this.recLength += inputBuffer.length;
+  }
+
+  exportBuffer() {
+    const mergedBuffers = this.mergeBuffers(this.newRecBuffer, this.newRecBuffer.reduce((len, buf) => len + buf.length, 0));
+    console.log('Merged buffer length:', mergedBuffers.length); // Debug log
+
+    const downsampledBuffer = this.downsampleBuffer(mergedBuffers, this.exportSampleRate);
+    console.log('Downsampled buffer length:', downsampledBuffer.length); // Debug log
+
+    const encodedWav = downsampledBuffer;
+    // const encodedWav = this.encodeWAV(downsampledBuffer);
+    // console.log('Encoded WAV length:', encodedWav.byteLength); // Debug log
+
+    this.port.postMessage({ encodedWav, sampleRate: this.exportSampleRate });
+    this.newRecBuffer = []; // Clear the new data buffer after export
+    this.headerSent = true; // Indicate that the header has been sent
+  }
+
+  downsampleBuffer(buffer, exportSampleRate) {
+    console.log('Original buffer length:', buffer.length); // Debug log
+    console.log('Record sample rate:', this.recordSampleRate); // Debug log
+    console.log('Export sample rate:', exportSampleRate); // Debug log
+    if (exportSampleRate === this.recordSampleRate) {
+      return buffer;
+    }
+
+    const sampleRateRatio = this.recordSampleRate / exportSampleRate;
+    const newLength = Math.round(buffer.length / sampleRateRatio);
+    console.log('Sample rate ratio:', sampleRateRatio); // Debug log
+    console.log('New length after downsampling:', newLength); // Debug log
+    
+    if (newLength <= 0) {
+      console.error('New length is zero or negative, returning empty buffer.'); // Debug log
+      return new Float32Array(0);
+    }
+    const result = new Float32Array(newLength);
+    let offsetResult = 0;
+    let offsetBuffer = 0;
+    while (offsetResult < result.length) {
+      const nextOffsetBuffer = Math.round((offsetResult + 1) * sampleRateRatio);
+      let accum = 0, count = 0;
+      for (let i = offsetBuffer; i < nextOffsetBuffer && i < buffer.length; i++) {
+        accum += buffer[i];
+        count++;
+      }
+      result[offsetResult] = accum / count;
+      offsetResult++;
+      offsetBuffer = nextOffsetBuffer;
+    }
+    return result;
+  }
+
+  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(output, offset, input) {
+    for (let i = 0; i < input.length; i++, offset += 2) {
+      const s = Math.max(-1, Math.min(1, input[i]));
+      output.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7fff, true);
+    }
+  }
+
+  writeString(view, offset, string) {
+    for (let i = 0; i < string.length; i++) {
+      view.setUint8(offset + i, string.charCodeAt(i));
+    }
+  }
+
+  getRecordedData() {
+    const length = this.recBuffer.reduce((acc, buffer) => acc + buffer.length, 0);
+    const result = new Float32Array(length);
+    let offset = 0;
+    for (const buffer of this.recBuffer) {
+      result.set(buffer, offset);
+      offset += buffer.length;
+    }
+    this.recBuffer.length = 0; // Clear the buffers after extraction
+
+    return result;
+  }
+
+  encodeWAV(samples) {
+    const buffer = new ArrayBuffer(44 + samples.length * 2);
+    const view = new DataView(buffer);
+    this.writeString(view, 0, 'RIFF');
+    view.setUint32(4, 32 + samples.length * 2, true);
+    this.writeString(view, 8, 'WAVE');
+    this.writeString(view, 12, 'fmt ');
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true);
+    view.setUint16(22, 1, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, sampleRate * 2, true);
+    view.setUint16(32, 2, true);
+    view.setUint16(34, 16, true);
+    this.writeString(view, 36, 'data');
+    view.setUint32(40, samples.length * 2, true);
+    this.floatTo16BitPCM(view, 44, samples);
+    return view;
+  }
+}
+
+registerProcessor('recorder-processor', RecorderProcessor);
+`;
+//# sourceMappingURL=inlineAudioWebWorker.js.map

package/build/inlineAudioWebWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineAudioWebWorker.js","sourceRoot":"","sources":["../src/inlineAudioWebWorker.tsx"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,2BAA2B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8J1C,CAAC;AAEF,oHAAoH;AACpH,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkLrC,CAAC","sourcesContent":["export const SimpleInlineProcessorScript = `\nclass RecorderProcessor extends AudioWorkletProcessor {\n  constructor() {\n      super();\n      this.recordedBuffers = []; // Float32Array\n      this.newRecBuffer = []; // Float32Array\n      this.exportIntervalSamples = 0;\n      this.samplesSinceLastExport = 0;\n      this.recordSampleRate = 44100; // To be overwritten\n      this.exportSampleRate = 44100; // To be overwritten\n      this.channels = 1; // Default to 1 channel (mono)\n      this.bitDepth = 32; // Default to 32-bit depth\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 = event.data.exportSampleRate || event.data.recordSampleRate;\n              this.exportIntervalSamples = this.recordSampleRate * (event.data.interval / 1000);\n              break;\n          case 'stop':\n              this.isRecording = false;\n              const fullRecordedData = this.getAllRecordedData();\n              this.port.postMessage({ command: 'recordedData', recordedData: fullRecordedData });\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(output, offset, input) {\n      for (let i = 0; i < input.length; i++, offset += 2) {\n          const s = Math.max(-1, Math.min(1, input[i]));\n          output.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7FFF, true);\n      }\n      console.debug('Float to 16-bit PCM conversion complete. Output byte length:', offset);\n  }\n\n  floatTo32BitPCM(output, offset, input) {\n      for (let i = 0; i < input.length; i++, offset += 4) {\n          output.setFloat32(offset, input[i], true);\n      }\n      console.debug('Float to 32-bit PCM (no conversion) complete. Output byte length:', offset);\n  }\n\n  writeString(view, offset, string) {\n      for (let i = 0; i < string.length; i++) {\n          view.setUint8(offset + i, string.charCodeAt(i));\n      }\n  }\n\n  encodeWAV(samples, includeHeader = true) {\n      const sampleCount = samples.length;\n      const buffer = new ArrayBuffer((includeHeader ? 44 : 0) + sampleCount * 4);\n      const view = new DataView(buffer);\n\n      if (includeHeader) {\n          this.writeString(view, 0, 'RIFF');\n          view.setUint32(4, 36 + sampleCount * 4, true); // File size - 8 bytes\n          this.writeString(view, 8, 'WAVE');\n          this.writeString(view, 12, 'fmt ');\n          view.setUint32(16, 16, true); // PCM format\n          view.setUint16(20, 3, true); // Format code 3 for float\n          view.setUint16(22, 1, true); // Mono channel\n          view.setUint32(24, this.recordSampleRate, true); // Sample rate\n          view.setUint32(28, this.recordSampleRate * 4, true); // Byte rate\n          view.setUint16(32, 4, true); // Block align (4 bytes for 32-bit float)\n          view.setUint16(34, 32, true); // Bits per sample (32-bit float)\n          this.writeString(view, 36, 'data');\n          view.setUint32(40, sampleCount * 4, true); // Data chunk size\n      }\n\n      console.debug('Writing PCM samples to DataView. Offset:', includeHeader ? 44 : 0, 'Samples length:', sampleCount);\n      this.floatTo32BitPCM(view, includeHeader ? 44 : 0, samples);\n      // this.floatTo16BitPCM(view, includeHeader ? 44 : 0, samples);\n\n      console.debug('Encoded WAV DataView:', view);\n      console.debug('Encoded WAV length:', view.byteLength);\n\n      return view;\n  }\n\n\n  exportNewData() {\n      // Calculate the total length of the new recorded buffers\n      const length = this.newRecBuffer.reduce((acc, buffer) => acc + buffer.length, 0);\n\n      // Merge all new recorded buffers into a single buffer\n      const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length);\n\n      // Encode the merged buffer into a WAV format\n      const encodedWav = this.encodeWAV(mergedBuffer, false);\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 }, [encodedWav.buffer]);\n  }\n\n  getAllRecordedData() {\n      const length = this.recordedBuffers.reduce((acc, buffer) => acc + buffer.length, 0);\n      const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length);\n\n\n      // Calculate the duration based on the sample count and sample rate\n      const sampleCount = mergedBuffer.length;\n      const mergedBufferDuration = sampleCount / this.recordSampleRate;\n\n      const encodedWav = this.encodeWAV(mergedBuffer, true);\n\n      // Calculate and log the duration for encodedWav.buffer based on sample count\n      const encodedWavBufferDuration = sampleCount / this.recordSampleRate;\n\n      this.recordedBuffers.length = 0; // Clear the buffers after extraction\n\n      // Returning both for testing, comment one of the returns based on your test\n      console.debug('mergedBuffer:', mergedBuffer);\n      console.debug('encodedWav.buffer:', encodedWav.buffer);\n\n      // Uncomment the appropriate return for testing\n      // return mergedBuffer; // This works when played\n      return encodedWav.buffer; // This doesn't work when played\n  }\n}\n\nregisterProcessor('recorder-processor', RecorderProcessor);\n`;\n\n// Because we use expo and needs to include the worker script in the shared library, better inline it in the module.\nexport const InlineProcessorScrippt = `\nclass RecorderProcessor extends AudioWorkletProcessor {\n  constructor() {\n    super();\n    this.recLength = 0;\n    this.recBuffer = [];\n    this.headerSent = false;\n    this.newRecBuffer = [];\n    this.exportIntervalSamples = 0;\n    this.samplesSinceLastExport = 0;\n    this.recordSampleRate = 44100; // To be overwrited\n    this.exportSampleRate = 44100; // To be overwrited\n    this.isRecording = true;\n\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 = event.data.exportSampleRate || event.data.recordSampleRate;\n        this.exportIntervalSamples = this.recordSampleRate * (event.data.interval / 1000);\n        break;\n      case 'stop':\n        this.isRecording = false;\n        break;\n      case 'getRecordedData':\n        const recordedData = this.getRecordedData();\n        this.port.postMessage({ command: 'recordedData', recordedData });\n        break;\n    }\n  }\n\n  process(inputs) {\n    if (!this.isRecording) {\n      return true; // Exit early if not recording\n    }\n\n    if (inputs.length === 0 || inputs[0].length === 0) {\n      console.warn('RecorderProcessor -- No input received.');\n      return true; // Exit early if no input\n    }\n\n    const buffer = inputs[0];\n    if (!buffer) {\n      console.error('Input buffer is null.');\n      return true; // Exit early if buffer is null\n    }\n\n    try {\n      this.record(buffer);\n\n      // this.samplesSinceLastExport += buffer.length;\n      // if (this.samplesSinceLastExport >= this.exportIntervalSamples) {\n      //   this.exportBuffer();\n      //   this.samplesSinceLastExport = 0;\n      // }\n    } catch (error) {\n      console.error('Error during processing:', error);\n    }\n    return true;\n  }\n\n  record(inputBuffer) {\n    this.recBuffer.push(inputBuffer);\n    this.newRecBuffer.push(inputBuffer);\n    this.recLength += inputBuffer.length;\n  }\n\n  exportBuffer() {\n    const mergedBuffers = this.mergeBuffers(this.newRecBuffer, this.newRecBuffer.reduce((len, buf) => len + buf.length, 0));\n    console.log('Merged buffer length:', mergedBuffers.length); // Debug log\n\n    const downsampledBuffer = this.downsampleBuffer(mergedBuffers, this.exportSampleRate);\n    console.log('Downsampled buffer length:', downsampledBuffer.length); // Debug log\n\n    const encodedWav = downsampledBuffer;\n    // const encodedWav = this.encodeWAV(downsampledBuffer);\n    // console.log('Encoded WAV length:', encodedWav.byteLength); // Debug log\n\n    this.port.postMessage({ encodedWav, sampleRate: this.exportSampleRate });\n    this.newRecBuffer = []; // Clear the new data buffer after export\n    this.headerSent = true; // Indicate that the header has been sent\n  }\n\n  downsampleBuffer(buffer, exportSampleRate) {\n    console.log('Original buffer length:', buffer.length); // Debug log\n    console.log('Record sample rate:', this.recordSampleRate); // Debug log\n    console.log('Export sample rate:', exportSampleRate); // Debug log\n    if (exportSampleRate === this.recordSampleRate) {\n      return buffer;\n    }\n\n    const sampleRateRatio = this.recordSampleRate / exportSampleRate;\n    const newLength = Math.round(buffer.length / sampleRateRatio);\n    console.log('Sample rate ratio:', sampleRateRatio); // Debug log\n    console.log('New length after downsampling:', newLength); // Debug log\n    \n    if (newLength <= 0) {\n      console.error('New length is zero or negative, returning empty buffer.'); // Debug log\n      return new Float32Array(0);\n    }\n    const result = new Float32Array(newLength);\n    let offsetResult = 0;\n    let offsetBuffer = 0;\n    while (offsetResult < result.length) {\n      const nextOffsetBuffer = Math.round((offsetResult + 1) * sampleRateRatio);\n      let accum = 0, count = 0;\n      for (let i = offsetBuffer; i < nextOffsetBuffer && i < buffer.length; i++) {\n        accum += buffer[i];\n        count++;\n      }\n      result[offsetResult] = accum / count;\n      offsetResult++;\n      offsetBuffer = nextOffsetBuffer;\n    }\n    return result;\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(output, offset, input) {\n    for (let i = 0; i < input.length; i++, offset += 2) {\n      const s = Math.max(-1, Math.min(1, input[i]));\n      output.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7fff, true);\n    }\n  }\n\n  writeString(view, offset, string) {\n    for (let i = 0; i < string.length; i++) {\n      view.setUint8(offset + i, string.charCodeAt(i));\n    }\n  }\n\n  getRecordedData() {\n    const length = this.recBuffer.reduce((acc, buffer) => acc + buffer.length, 0);\n    const result = new Float32Array(length);\n    let offset = 0;\n    for (const buffer of this.recBuffer) {\n      result.set(buffer, offset);\n      offset += buffer.length;\n    }\n    this.recBuffer.length = 0; // Clear the buffers after extraction\n\n    return result;\n  }\n\n  encodeWAV(samples) {\n    const buffer = new ArrayBuffer(44 + samples.length * 2);\n    const view = new DataView(buffer);\n    this.writeString(view, 0, 'RIFF');\n    view.setUint32(4, 32 + samples.length * 2, true);\n    this.writeString(view, 8, 'WAVE');\n    this.writeString(view, 12, 'fmt ');\n    view.setUint32(16, 16, true);\n    view.setUint16(20, 1, true);\n    view.setUint16(22, 1, true);\n    view.setUint32(24, sampleRate, true);\n    view.setUint32(28, sampleRate * 2, true);\n    view.setUint16(32, 2, true);\n    view.setUint16(34, 16, true);\n    this.writeString(view, 36, 'data');\n    view.setUint32(40, samples.length * 2, true);\n    this.floatTo16BitPCM(view, 44, samples);\n    return view;\n  }\n}\n\nregisterProcessor('recorder-processor', RecorderProcessor);\n`;\n"]}

package/build/useAudioRecording.d.ts

@@ -1,13 +1,25 @@
-import { AudioStreamResult, RecordingConfig, StartAudioStreamResult } from "./ExpoAudioStream.types";
-export interface AudioDataEvent {
-    data: string | Blob;
-    position: number;
-    fileUri: string;
-    eventDataSize: number;
-    totalSize: number;
+import { AudioAnalysisData, AudioFeaturesOptions, AudioStreamResult, RecordingConfig, StartAudioStreamResult } from "./ExpoAudioStream.types";
+import { WavFileInfo } from "./utils";
+export interface ExtractMetadataProps {
+    fileUri?: string;
+    wavMetadata?: WavFileInfo;
+    arrayBuffer?: ArrayBuffer;
+    bitDepth?: number;
+    skipWavHeader?: boolean;
+    durationMs?: number;
+    sampleRate?: number;
+    numberOfChannels?: number;
+    algorithm?: "peak" | "rms";
+    position?: number;
+    length?: number;
+    pointsPerSecond?: number;
+    features?: AudioFeaturesOptions;
+    featuresExtratorUrl?: string;
 }
 export interface UseAudioRecorderProps {
     debug?: boolean;
+    audioWorkletUrl?: string;
+    featuresExtratorUrl?: string;
 }
 export interface UseAudioRecorderState {
     startRecording: (_: RecordingConfig) => Promise<StartAudioStreamResult>;
@@ -16,8 +28,11 @@ export interface UseAudioRecorderState {
     resumeRecording: () => void;
     isRecording: boolean;
     isPaused: boolean;
-    duration: number;
+    durationMs: number;
     size: number;
+    analysisData?: AudioAnalysisData;
+    audioWorkletUrl?: string;
+    featuresExtratorUrl?: string;
 }
-export declare function useAudioRecorder({ debug, }?: UseAudioRecorderProps): UseAudioRecorderState;
+export declare function useAudioRecorder({ debug, audioWorkletUrl, featuresExtratorUrl, }?: UseAudioRecorderProps): UseAudioRecorderState;
 //# sourceMappingURL=useAudioRecording.d.ts.map

package/build/useAudioRecording.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAudioRecording.d.ts","sourceRoot":"","sources":["../src/useAudioRecording.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,iBAAiB,EAEjB,eAAe,EACf,sBAAsB,EACvB,MAAM,yBAAyB,CAAC;AAGjC,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AACD,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,CAAC,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACxE,aAAa,EAAE,MAAM,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IACvD,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AA4CD,wBAAgB,gBAAgB,CAAC,EAC/B,KAAa,GACd,GAAE,qBAA0B,GAAG,qBAAqB,CA4LpD"}
+{"version":3,"file":"useAudioRecording.d.ts","sourceRoot":"","sources":["../src/useAudioRecording.tsx"],"names":[],"mappings":"AAKA,OAAO,EACL,iBAAiB,EAGjB,oBAAoB,EACpB,iBAAiB,EAEjB,eAAe,EACf,sBAAsB,EACvB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,CAAC,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACxE,aAAa,EAAE,MAAM,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IACvD,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAkED,wBAAgB,gBAAgB,CAAC,EAC/B,KAAa,EACb,eAAe,EACf,mBAAmB,GACpB,GAAE,qBAA0B,GAAG,qBAAqB,CA8RpD"}

package/build/useAudioRecording.js

@@ -1,7 +1,21 @@
+// src/useAudioRecording.ts
 import { Platform } from "expo-modules-core";
 import { useCallback, useEffect, useReducer, useRef } from "react";
-import { addAudioEventListener } from ".";
+import { addAudioAnalysisListener, addAudioEventListener } from ".";
 import ExpoAudioStreamModule from "./ExpoAudioStreamModule";
+const defaultAnalysis = {
+    pointsPerSecond: 20,
+    bitDepth: 32,
+    numberOfChannels: 1,
+    durationMs: 0,
+    sampleRate: 44100,
+    samples: 0,
+    dataPoints: [],
+    amplitudeRange: {
+        min: Number.POSITIVE_INFINITY,
+        max: Number.NEGATIVE_INFINITY,
+    },
+};
 function recorderReducer(state, action) {
     switch (action.type) {
         case "START":
@@ -9,8 +23,9 @@ function recorderReducer(state, action) {
                 ...state,
                 isRecording: true,
                 isPaused: false,
-                duration: 0,
+                durationMs: 0,
                 size: 0,
+                analysisData: defaultAnalysis, // Reset analysis data
             };
         case "STOP":
             return { ...state, isRecording: false, isPaused: false };
@@ -21,21 +36,33 @@ function recorderReducer(state, action) {
         case "UPDATE_STATUS":
             return {
                 ...state,
-                duration: action.payload.duration,
+                durationMs: action.payload.durationMs,
                 size: action.payload.size,
             };
+        case "UPDATE_ANALYSIS":
+            return {
+                ...state,
+                analysisData: action.payload,
+            };
         default:
             return state;
     }
 }
 const TAG = "[ useAudioRecorder ] ";
-export function useAudioRecorder({ debug = false, } = {}) {
+export function useAudioRecorder({ debug = false, audioWorkletUrl, featuresExtratorUrl, } = {}) {
     const [state, dispatch] = useReducer(recorderReducer, {
         isRecording: false,
         isPaused: false,
-        duration: 0,
+        durationMs: 0,
         size: 0,
+        analysisData: undefined,
     });
+    const analysisListenerRef = useRef(null);
+    const analysisRef = useRef({ ...defaultAnalysis });
+    // Instantiate the module for web with URLs
+    const ExpoAudioStream = Platform.OS === "web"
+        ? ExpoAudioStreamModule({ audioWorkletUrl, featuresExtratorUrl })
+        : ExpoAudioStreamModule;
     const onAudioStreamRef = useRef(null);
     const logDebug = useCallback((message, data) => {
         if (debug) {
@@ -47,9 +74,45 @@ export function useAudioRecorder({ debug = false, } = {}) {
             }
         }
     }, [debug]);
+    const handleAudioAnalysis = useCallback(async (analysis, visualizationDuration) => {
+        const savedAnalysisData = analysisRef.current || { ...defaultAnalysis };
+        const maxDuration = visualizationDuration;
+        logDebug(`[handleAudioAnalysis] Received audio analysis: maxDuration=${maxDuration} analysis.dataPoints=${analysis.dataPoints.length} analysisData.dataPoints=${savedAnalysisData.dataPoints.length}`, analysis);
+        // Combine data points
+        const combinedDataPoints = [
+            ...savedAnalysisData.dataPoints,
+            ...analysis.dataPoints,
+        ];
+        // Calculate the new duration
+        const pointsPerSecond = analysis.pointsPerSecond || savedAnalysisData.pointsPerSecond;
+        const maxDataPoints = (pointsPerSecond * visualizationDuration) / 1000;
+        logDebug(`[handleAudioAnalysis] Combined data points before trimming: pointsPerSecond=${pointsPerSecond} visualizationDuration=${visualizationDuration} combinedDataPointsLength=${combinedDataPoints.length} vs maxDataPoints=${maxDataPoints}`);
+        // Trim data points to keep within the maximum number of data points
+        if (combinedDataPoints.length > maxDataPoints) {
+            combinedDataPoints.splice(0, combinedDataPoints.length - maxDataPoints);
+        }
+        savedAnalysisData.dataPoints = combinedDataPoints;
+        savedAnalysisData.bitDepth =
+            analysis.bitDepth || savedAnalysisData.bitDepth;
+        savedAnalysisData.durationMs =
+            combinedDataPoints.length * (1000 / pointsPerSecond);
+        // Update amplitude range
+        const newMin = Math.min(savedAnalysisData.amplitudeRange.min, analysis.amplitudeRange.min);
+        const newMax = Math.max(savedAnalysisData.amplitudeRange.max, analysis.amplitudeRange.max);
+        savedAnalysisData.amplitudeRange = {
+            min: newMin,
+            max: newMax,
+        };
+        logDebug(`[handleAudioAnalysis] Updated analysis data: durationMs=${savedAnalysisData.durationMs}`, savedAnalysisData);
+        // Update the ref
+        analysisRef.current = savedAnalysisData;
+        // Dispatch the updated analysis data to state to trigger re-render
+        // need to use spread operator otherwise it doesnt trigger update.
+        dispatch({ type: "UPDATE_ANALYSIS", payload: { ...savedAnalysisData } });
+    }, [logDebug]);
     const handleAudioEvent = useCallback(async (eventData) => {
         const { fileUri, deltaSize, totalSize, lastEmittedSize, position, streamUuid, encoded, mimeType, buffer, } = eventData;
-        logDebug(`useAudioRecorder] Received audio event:`, {
+        logDebug(`[handleAudioEvent] Received audio event:`, {
             fileUri,
             deltaSize,
             totalSize,
@@ -100,19 +163,14 @@ export function useAudioRecorder({ debug = false, } = {}) {
                 logDebug(`${TAG} Not recording, exiting status check.`);
                 return;
             }
-            const status = ExpoAudioStreamModule.status();
+            const status = ExpoAudioStream.status();
             if (debug) {
                 logDebug(`${TAG} Status:`, status);
             }
-            if (!status.isRecording) {
-                dispatch({ type: "STOP" });
-            }
-            else {
-                dispatch({
-                    type: "UPDATE_STATUS",
-                    payload: { duration: status.duration, size: status.size },
-                });
-            }
+            dispatch({
+                type: "UPDATE_STATUS",
+                payload: { durationMs: status.durationMs, size: status.size },
+            });
         }
         catch (error) {
             console.error(`${TAG} Error getting status:`, error);
@@ -130,20 +188,23 @@ export function useAudioRecorder({ debug = false, } = {}) {
         };
     }, [checkStatus, state.isRecording]);
     useEffect(() => {
-        logDebug(`${TAG} Registering audio event listener`);
-        const subscribe = addAudioEventListener(handleAudioEvent);
-        logDebug(`${TAG} Subscribed to audio event listener`, subscribe);
+        logDebug(`Registering audio event listener`);
+        const subscribeAudio = addAudioEventListener(handleAudioEvent);
+        logDebug(`Subscribed to audio event listener and analysis listener`, {
+            subscribeAudio,
+        });
         return () => {
-            logDebug(`${TAG} Removing audio event listener`);
-            subscribe.remove();
+            logDebug(`Removing audio event listener`);
+            subscribeAudio.remove();
         };
-    }, [handleAudioEvent, logDebug]);
+    }, [handleAudioEvent, handleAudioAnalysis, logDebug]);
     const startRecording = useCallback(async (recordingOptions) => {
         if (debug) {
-            logDebug(`${TAG} start recoding`, recordingOptions);
+            logDebug(`start recoding`, recordingOptions);
         }
-        // remove onAudioStream from recordingOptions
+        analysisRef.current = { ...defaultAnalysis }; // Reset analysis data
         const { onAudioStream, ...options } = recordingOptions;
+        const { maxRecentDataDuration = 10000, enableProcessing } = options;
         if (typeof onAudioStream === "function") {
             onAudioStreamRef.current = onAudioStream;
         }
@@ -151,13 +212,29 @@ export function useAudioRecorder({ debug = false, } = {}) {
             console.warn(`${TAG} onAudioStream is not a function`, onAudioStream);
             onAudioStreamRef.current = null;
         }
-        const startResult = await ExpoAudioStreamModule.startRecording(options);
+        const startResult = await ExpoAudioStream.startRecording(options);
         dispatch({ type: "START" });
+        if (enableProcessing) {
+            logDebug(`Enabling audio analysis listener`);
+            const listener = addAudioAnalysisListener(async (analysisData) => {
+                try {
+                    await handleAudioAnalysis(analysisData, maxRecentDataDuration);
+                }
+                catch (error) {
+                    console.warn(`${TAG} Error processing audio analysis:`, error);
+                }
+            });
+            analysisListenerRef.current = listener;
+        }
         return startResult;
     }, [logDebug]);
     const stopRecording = useCallback(async () => {
         logDebug(`${TAG} stoping recording`);
-        const stopResult = await ExpoAudioStreamModule.stopRecording();
+        if (analysisListenerRef.current) {
+            analysisListenerRef.current.remove();
+            analysisListenerRef.current = null;
+        }
+        const stopResult = await ExpoAudioStream.stopRecording();
         onAudioStreamRef.current = null;
         logDebug(`${TAG} recording stopped`, stopResult);
         dispatch({ type: "STOP" });
@@ -165,13 +242,13 @@ export function useAudioRecorder({ debug = false, } = {}) {
     }, [logDebug]);
     const pauseRecording = useCallback(async () => {
         logDebug(`${TAG} pause recording`);
-        const pauseResult = await ExpoAudioStreamModule.pauseRecording();
+        const pauseResult = await ExpoAudioStream.pauseRecording();
         dispatch({ type: "PAUSE" });
         return pauseResult;
     }, [logDebug]);
     const resumeRecording = useCallback(async () => {
         logDebug(`${TAG} resume recording`);
-        const resumeResult = await ExpoAudioStreamModule.resumeRecording();
+        const resumeResult = await ExpoAudioStream.resumeRecording();
         dispatch({ type: "RESUME" });
         return resumeResult;
     }, [logDebug]);
@@ -182,8 +259,9 @@ export function useAudioRecorder({ debug = false, } = {}) {
         resumeRecording,
         isPaused: state.isPaused,
         isRecording: state.isRecording,
-        duration: state.duration,
+        durationMs: state.durationMs,
         size: state.size,
+        analysisData: state.analysisData,
     };
 }
 //# sourceMappingURL=useAudioRecording.js.map