@siteed/expo-audio-stream 1.0.0 → 1.0.2

package/src/useAudioRecording.tsx

@@ -0,0 +1,410 @@
+// src/useAudioRecording.ts
+import { Platform, Subscription } from "expo-modules-core";
+import { useCallback, useEffect, useReducer, useRef } from "react";
+
+import { addAudioAnalysisListener, addAudioEventListener } from ".";
+import {
+  AudioAnalysisData,
+  AudioDataEvent,
+  AudioEventPayload,
+  AudioFeaturesOptions,
+  AudioStreamResult,
+  AudioStreamStatus,
+  RecordingConfig,
+  StartAudioStreamResult,
+} from "./ExpoAudioStream.types";
+import ExpoAudioStreamModule from "./ExpoAudioStreamModule";
+import { WavFileInfo } from "./utils";
+
+export interface ExtractMetadataProps {
+  fileUri?: string; // should provide either fileUri or arrayBuffer
+  wavMetadata?: WavFileInfo;
+  arrayBuffer?: ArrayBuffer;
+  bitDepth?: number;
+  skipWavHeader?: boolean;
+  durationMs?: number;
+  sampleRate?: number;
+  numberOfChannels?: number;
+  algorithm?: "peak" | "rms";
+  position?: number; // Optional number of bytes to skip. Default is 0
+  length?: number; // Optional number of bytes to read.
+  pointsPerSecond?: number; // Optional number of points per second. Use to reduce the number of points and compute the number of datapoints to return.
+  features?: AudioFeaturesOptions;
+  featuresExtratorUrl?: string;
+}
+
+export interface UseAudioRecorderProps {
+  debug?: boolean;
+  audioWorkletUrl?: string;
+  featuresExtratorUrl?: string;
+}
+
+export interface UseAudioRecorderState {
+  startRecording: (_: RecordingConfig) => Promise<StartAudioStreamResult>;
+  stopRecording: () => Promise<AudioStreamResult | null>;
+  pauseRecording: () => void;
+  resumeRecording: () => void;
+  isRecording: boolean;
+  isPaused: boolean;
+  durationMs: number; // Duration of the recording
+  size: number; // Size in bytes of the recorded audio
+  analysisData?: AudioAnalysisData;
+  audioWorkletUrl?: string;
+  featuresExtratorUrl?: string;
+}
+
+interface RecorderState {
+  isRecording: boolean;
+  isPaused: boolean;
+  durationMs: number;
+  size: number;
+  analysisData?: AudioAnalysisData;
+}
+
+type RecorderAction =
+  | { type: "START" | "STOP" | "PAUSE" | "RESUME" }
+  | { type: "UPDATE_STATUS"; payload: { durationMs: number; size: number } }
+  | { type: "UPDATE_ANALYSIS"; payload: AudioAnalysisData };
+
+const defaultAnalysis: AudioAnalysisData = {
+  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: RecorderState,
+  action: RecorderAction,
+): RecorderState {
+  switch (action.type) {
+    case "START":
+      return {
+        ...state,
+        isRecording: true,
+        isPaused: false,
+        durationMs: 0,
+        size: 0,
+        analysisData: defaultAnalysis, // Reset analysis data
+      };
+    case "STOP":
+      return { ...state, isRecording: false, isPaused: false };
+    case "PAUSE":
+      return { ...state, isPaused: true, isRecording: false };
+    case "RESUME":
+      return { ...state, isPaused: false, isRecording: true };
+    case "UPDATE_STATUS":
+      return {
+        ...state,
+        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,
+  audioWorkletUrl,
+  featuresExtratorUrl,
+}: UseAudioRecorderProps = {}): UseAudioRecorderState {
+  const [state, dispatch] = useReducer(recorderReducer, {
+    isRecording: false,
+    isPaused: false,
+    durationMs: 0,
+    size: 0,
+    analysisData: undefined,
+  });
+
+  const analysisListenerRef = useRef<Subscription | null>(null);
+  const analysisRef = useRef<AudioAnalysisData>({ ...defaultAnalysis });
+
+  // Instantiate the module for web with URLs
+  const ExpoAudioStream =
+    Platform.OS === "web"
+      ? ExpoAudioStreamModule({ audioWorkletUrl, featuresExtratorUrl })
+      : ExpoAudioStreamModule;
+
+  const onAudioStreamRef = useRef<
+    ((_: AudioDataEvent) => Promise<void>) | null
+  >(null);
+
+  const logDebug = useCallback(
+    (message: string, data?: any) => {
+      if (debug) {
+        if (data) {
+          console.log(`${TAG} ${message}`, data);
+        } else {
+          console.log(`${TAG} ${message}`);
+        }
+      }
+    },
+    [debug],
+  );
+
+  const handleAudioAnalysis = useCallback(
+    async (analysis: AudioAnalysisData, visualizationDuration: number) => {
+      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: AudioEventPayload) => {
+      const {
+        fileUri,
+        deltaSize,
+        totalSize,
+        lastEmittedSize,
+        position,
+        streamUuid,
+        encoded,
+        mimeType,
+        buffer,
+      } = eventData;
+      logDebug(`[handleAudioEvent] Received audio event:`, {
+        fileUri,
+        deltaSize,
+        totalSize,
+        position,
+        mimeType,
+        lastEmittedSize,
+        streamUuid,
+        encodedLength: encoded?.length,
+      });
+      if (deltaSize === 0) {
+        // Ignore packet with no data
+        return;
+      }
+      try {
+        // Coming from native ( ios / android ) otherwise buffer is set
+        if (Platform.OS !== "web") {
+          // Read the audio file as a base64 string for comparison
+          if (!encoded) {
+            console.error(`${TAG} Encoded audio data is missing`);
+            throw new Error("Encoded audio data is missing");
+          }
+          onAudioStreamRef.current?.({
+            data: encoded,
+            position,
+            fileUri,
+            eventDataSize: deltaSize,
+            totalSize,
+          });
+        } else if (buffer) {
+          // Coming from web
+          onAudioStreamRef.current?.({
+            data: buffer,
+            position,
+            fileUri,
+            eventDataSize: deltaSize,
+            totalSize,
+          });
+        }
+      } catch (error) {
+        console.error(`${TAG} Error processing audio event:`, error);
+      }
+    },
+    [logDebug],
+  );
+
+  const checkStatus = useCallback(async () => {
+    try {
+      if (!state.isRecording) {
+        logDebug(`${TAG} Not recording, exiting status check.`);
+        return;
+      }
+
+      const status: AudioStreamStatus = ExpoAudioStream.status();
+      if (debug) {
+        logDebug(`${TAG} Status:`, status);
+      }
+
+      dispatch({
+        type: "UPDATE_STATUS",
+        payload: { durationMs: status.durationMs, size: status.size },
+      });
+    } catch (error) {
+      console.error(`${TAG} Error getting status:`, error);
+    }
+  }, [state.isRecording, logDebug]);
+
+  useEffect(() => {
+    let interval: ReturnType<typeof setTimeout>;
+    if (state.isRecording) {
+      interval = setInterval(checkStatus, 1000);
+    }
+    return () => {
+      if (interval) {
+        clearInterval(interval);
+      }
+    };
+  }, [checkStatus, state.isRecording]);
+
+  useEffect(() => {
+    logDebug(`Registering audio event listener`);
+    const subscribeAudio = addAudioEventListener(handleAudioEvent);
+
+    logDebug(`Subscribed to audio event listener and analysis listener`, {
+      subscribeAudio,
+    });
+
+    return () => {
+      logDebug(`Removing audio event listener`);
+      subscribeAudio.remove();
+    };
+  }, [handleAudioEvent, handleAudioAnalysis, logDebug]);
+
+  const startRecording = useCallback(
+    async (recordingOptions: RecordingConfig) => {
+      if (debug) {
+        logDebug(`start recoding`, recordingOptions);
+      }
+
+      analysisRef.current = { ...defaultAnalysis }; // Reset analysis data
+
+      const { onAudioStream, ...options } = recordingOptions;
+      const { maxRecentDataDuration = 10000, enableProcessing } = options;
+      if (typeof onAudioStream === "function") {
+        onAudioStreamRef.current = onAudioStream;
+      } else {
+        console.warn(`${TAG} onAudioStream is not a function`, onAudioStream);
+        onAudioStreamRef.current = null;
+      }
+      const startResult: StartAudioStreamResult =
+        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`);
+
+    if (analysisListenerRef.current) {
+      analysisListenerRef.current.remove();
+      analysisListenerRef.current = null;
+    }
+
+    const stopResult: AudioStreamResult = await ExpoAudioStream.stopRecording();
+    onAudioStreamRef.current = null;
+    logDebug(`${TAG} recording stopped`, stopResult);
+    dispatch({ type: "STOP" });
+    return stopResult;
+  }, [logDebug]);
+
+  const pauseRecording = useCallback(async () => {
+    logDebug(`${TAG} pause recording`);
+    const pauseResult = await ExpoAudioStream.pauseRecording();
+    dispatch({ type: "PAUSE" });
+    return pauseResult;
+  }, [logDebug]);
+
+  const resumeRecording = useCallback(async () => {
+    logDebug(`${TAG} resume recording`);
+    const resumeResult = await ExpoAudioStream.resumeRecording();
+    dispatch({ type: "RESUME" });
+    return resumeResult;
+  }, [logDebug]);
+
+  return {
+    startRecording,
+    stopRecording,
+    pauseRecording,
+    resumeRecording,
+    isPaused: state.isPaused,
+    isRecording: state.isRecording,
+    durationMs: state.durationMs,
+    size: state.size,
+    analysisData: state.analysisData,
+  };
+}

package/src/utils.ts

@@ -0,0 +1,189 @@
+import { EncodingType } from "./ExpoAudioStream.types";
+
+export const WAV_HEADER_SIZE = 44;
+export const convertPCMToFloat32 = ({
+  bitDepth,
+  buffer,
+  skipWavHeader = false,
+}: {
+  buffer: ArrayBuffer;
+  bitDepth: number;
+  skipWavHeader?: boolean;
+}): { pcmValues: Float32Array; min: number; max: number } => {
+  const dataView = new DataView(buffer);
+  const headerOffset = skipWavHeader ? WAV_HEADER_SIZE : 0;
+  const dataLength = buffer.byteLength - headerOffset;
+  const sampleLength = dataLength / (bitDepth / 8);
+  const float32Array = new Float32Array(sampleLength);
+  let min = Infinity;
+  let max = -Infinity;
+
+  for (let i = 0; i < sampleLength; i++) {
+    let value = 0;
+    const offset = headerOffset + i * (bitDepth / 8);
+    switch (bitDepth) {
+      case 8:
+        value = dataView.getUint8(offset) / 128;
+        break;
+      case 16:
+        value = dataView.getInt16(offset, true) / 32768;
+        break;
+      case 24:
+        value =
+          (dataView.getUint8(offset) +
+            (dataView.getUint8(offset + 1) << 8) +
+            (dataView.getUint8(offset + 2) << 16)) /
+          8388608;
+        break;
+      case 32:
+        value = dataView.getFloat32(offset, true);
+        break;
+      default:
+        throw new Error(`Unsupported bit depth: ${bitDepth}`);
+    }
+    if (value < min) min = value;
+    if (value > max) max = value;
+    float32Array[i] = value;
+  }
+
+  return { pcmValues: float32Array, min, max };
+};
+
+interface WavHeaderOptions {
+  buffer: ArrayBuffer;
+  sampleRate: number;
+  numChannels: number;
+  bitDepth: number;
+}
+
+export const writeWavHeader = ({
+  buffer,
+  sampleRate,
+  numChannels,
+  bitDepth,
+}: WavHeaderOptions): ArrayBuffer => {
+  const bytesPerSample = bitDepth / 8;
+  const numSamples = buffer.byteLength / (numChannels * bytesPerSample);
+  const view = new DataView(buffer);
+  const blockAlign = numChannels * bytesPerSample;
+  const byteRate = sampleRate * blockAlign;
+
+  // Function to write a string to the DataView
+  const writeString = (view: DataView, offset: number, string: string) => {
+    for (let i = 0; i < string.length; i++) {
+      view.setUint8(offset + i, string.charCodeAt(i));
+    }
+  };
+
+  // Check if the buffer already has a WAV header by looking for "RIFF" at the start
+  const existingHeader = view.getUint32(0, false) === 0x52494646; // "RIFF" in ASCII
+
+  if (!existingHeader) {
+    // Write the WAV header
+    writeString(view, 0, "RIFF"); // ChunkID
+    view.setUint32(4, 36 + numSamples * blockAlign, true); // ChunkSize
+    writeString(view, 8, "WAVE"); // Format
+    writeString(view, 12, "fmt "); // Subchunk1ID
+    view.setUint32(16, 16, true); // Subchunk1Size (16 for PCM)
+    view.setUint16(20, bitDepth === 32 ? 3 : 1, true); // AudioFormat (3 for float, 1 for PCM)
+    view.setUint16(22, numChannels, true); // NumChannels
+    view.setUint32(24, sampleRate, true); // SampleRate
+    view.setUint32(28, byteRate, true); // ByteRate
+    view.setUint16(32, blockAlign, true); // BlockAlign
+    view.setUint16(34, bitDepth, true); // BitsPerSample
+    writeString(view, 36, "data"); // Subchunk2ID
+    view.setUint32(40, numSamples * blockAlign, true); // Subchunk2Size
+  } else {
+    // Update the existing WAV header if necessary
+    view.setUint32(4, 36 + numSamples * blockAlign, true); // Update ChunkSize
+    view.setUint32(24, sampleRate, true); // Update SampleRate
+    view.setUint32(28, byteRate, true); // Update ByteRate
+    view.setUint16(32, blockAlign, true); // Update BlockAlign
+    view.setUint32(40, numSamples * blockAlign, true); // Update Subchunk2Size
+  }
+
+  return buffer;
+};
+
+export interface WavFileInfo {
+  sampleRate: number;
+  numChannels: number;
+  bitDepth: number;
+  size: number; // in bytes
+  durationMs: number; // in seconds
+}
+
+export const getWavFileInfo = async (
+  arrayBuffer: ArrayBuffer,
+): Promise<WavFileInfo> => {
+  const view = new DataView(arrayBuffer);
+
+  // Check if the file is a valid RIFF/WAVE file
+  const riffHeader = view.getUint32(0, false); // "RIFF"
+  const waveHeader = view.getUint32(8, false); // "WAVE"
+  if (riffHeader !== 0x52494646 || waveHeader !== 0x57415645) {
+    throw new Error("Invalid WAV file");
+  }
+
+  // Locate the "fmt " chunk
+  let fmtChunkOffset = 12;
+  let sampleRate = 0;
+  let numChannels = 0;
+  let bitDepth = 0;
+  let dataChunkSize = 0;
+  let audioFormat = 0;
+
+  while (fmtChunkOffset < view.byteLength) {
+    const chunkId = view.getUint32(fmtChunkOffset, false);
+    const chunkSize = view.getUint32(fmtChunkOffset + 4, true);
+    if (chunkId === 0x666d7420) {
+      // "fmt "
+      audioFormat = view.getUint16(fmtChunkOffset + 8, true);
+      if (audioFormat !== 1 && audioFormat !== 3) {
+        throw new Error("Unsupported WAV file format");
+      }
+      numChannels = view.getUint16(fmtChunkOffset + 10, true);
+      sampleRate = view.getUint32(fmtChunkOffset + 12, true);
+      bitDepth = view.getUint16(fmtChunkOffset + 22, true);
+    } else if (chunkId === 0x64617461) {
+      // "data"
+      dataChunkSize = chunkSize;
+      break;
+    }
+    fmtChunkOffset += 8 + chunkSize;
+  }
+
+  if (!sampleRate || !numChannels || !bitDepth || !dataChunkSize) {
+    throw new Error("Incomplete WAV file information");
+  }
+
+  // Calculate duration
+  const bytesPerSample = bitDepth / 8;
+  const numSamples = dataChunkSize / (numChannels * bytesPerSample);
+  const durationMs = (numSamples / sampleRate) * 1000;
+
+  return {
+    sampleRate,
+    numChannels,
+    bitDepth,
+    size: arrayBuffer.byteLength,
+    durationMs,
+  };
+};
+
+export const encodingToBitDepth = ({
+  encoding,
+}: {
+  encoding: EncodingType;
+}): number => {
+  switch (encoding) {
+    case "pcm_32bit":
+      return 32;
+    case "pcm_16bit":
+      return 16;
+    case "pcm_8bit":
+      return 8;
+    default:
+      throw new Error(`Unsupported encoding type: ${encoding}`);
+  }
+};

package/build/ExpoAudioStreamModule.web.d.ts

@@ -1,37 +0,0 @@
-import { EventEmitter } from "expo-modules-core";
-import { AudioStreamResult, RecordingConfig, StartAudioStreamResult } from "./ExpoAudioStream.types";
-declare class ExpoAudioStreamWeb extends EventEmitter {
-    mediaRecorder: MediaRecorder | null;
-    audioChunks: Blob[];
-    isRecording: boolean;
-    isPaused: boolean;
-    recordingStartTime: number;
-    pausedTime: number;
-    currentDurationMs: number;
-    currentSize: number;
-    currentInterval: number;
-    lastEmittedSize: number;
-    lastEmittedTime: number;
-    streamUuid: string | null;
-    constructor();
-    getMediaStream(): Promise<MediaStream>;
-    startRecording(options?: RecordingConfig): Promise<StartAudioStreamResult>;
-    setupRecordingListeners(): void;
-    emitAudioEvent({ data, position }: {
-        data: Blob;
-        position: number;
-    }): void;
-    generateUUID(): string;
-    stopRecording(): Promise<AudioStreamResult | null>;
-    pauseRecording(): Promise<void>;
-    status(): {
-        isRecording: boolean;
-        isPaused: boolean;
-        duration: number;
-        size: number;
-        interval: number;
-    };
-}
-declare const _default: ExpoAudioStreamWeb;
-export default _default;
-//# sourceMappingURL=ExpoAudioStreamModule.web.d.ts.map

package/build/ExpoAudioStreamModule.web.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ExpoAudioStreamModule.web.d.ts","sourceRoot":"","sources":["../src/ExpoAudioStreamModule.web.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,OAAO,EAEL,iBAAiB,EACjB,eAAe,EACf,sBAAsB,EACvB,MAAM,yBAAyB,CAAC;AAGjC,cAAM,kBAAmB,SAAQ,YAAY;IAC3C,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;IACpC,WAAW,EAAE,IAAI,EAAE,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;;IA4BpB,cAAc;IAUd,cAAc,CAAC,OAAO,GAAE,eAAoB;IAwBlD,uBAAuB;IA4BvB,cAAc,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE;IAiBnE,YAAY;IAUN,aAAa,IAAI,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAelD,cAAc;IAcpB,MAAM;;;;;;;CASP;;AAED,wBAAwC"}