@siteed/expo-audio-stream 1.0.2 → 1.0.3

package/src/index.ts

@@ -1,183 +1,22 @@
 // src/index.ts
-import { EventEmitter, type Subscription } from "expo-modules-core";
-import { Platform } from "react-native";
 
-// Import the native module. On web, it will be resolved to ExpoAudioStream.web.ts
-// and on native platforms to ExpoAudioStream.ts
+import { extractAudioAnalysis } from "./AudioAnalysis/extractAudioAnalysis";
 import {
   AudioRecorderProvider,
   useSharedAudioRecorder,
 } from "./AudioRecorder.provider";
-import { AudioAnalysisData, AudioEventPayload } from "./ExpoAudioStream.types";
-import ExpoAudioStreamModule from "./ExpoAudioStreamModule";
-import { ExtractMetadataProps, useAudioRecorder } from "./useAudioRecording";
-import { convertPCMToFloat32, getWavFileInfo, writeWavHeader } from "./utils";
+import { useAudioRecorder } from "./useAudioRecorder";
 
-const emitter = new EventEmitter(ExpoAudioStreamModule);
-
-export function addAudioEventListener(
-  listener: (event: AudioEventPayload) => Promise<void>,
-): Subscription {
-  console.log(`addAudioEventListener`, listener);
-  return emitter.addListener<AudioEventPayload>("AudioData", listener);
-}
-
-export function addAudioAnalysisListener(
-  listener: (event: AudioAnalysisData) => Promise<void>,
-): Subscription {
-  console.log(`addAudioAnalysisListener`, listener);
-  return emitter.addListener<AudioAnalysisData>("AudioAnalysis", listener);
-}
-
-const isWeb = Platform.OS === "web";
-
-export const extractAudioAnalysis = async ({
-  fileUri,
-  pointsPerSecond = 20,
-  arrayBuffer,
-  bitDepth,
-  skipWavHeader,
-  durationMs,
-  sampleRate,
-  numberOfChannels,
-  algorithm = "rms",
-  features,
-  featuresExtratorUrl = "/audio-features-extractor.js",
-}: ExtractMetadataProps): Promise<AudioAnalysisData> => {
-  if (isWeb) {
-    if (!arrayBuffer && !fileUri) {
-      throw new Error("Either arrayBuffer or fileUri must be provided");
-    }
-
-    if (!arrayBuffer) {
-      console.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);
-      console.log(`fetched fileUri`, arrayBuffer.byteLength, arrayBuffer);
-    }
-
-    // Create a new copy of the ArrayBuffer to avoid detachment issues
-    const bufferCopy = arrayBuffer.slice(0);
-    console.log(
-      `extractAudioAnalysis skipWavHeader=${skipWavHeader} bitDepth=${bitDepth} len=${bufferCopy.byteLength}`,
-      bufferCopy.slice(0, 100),
-    );
-
-    let actualBitDepth = bitDepth;
-    if (!actualBitDepth) {
-      console.log(
-        `extractAudioAnalysis bitDepth not provided -- getting wav file info`,
-      );
-      const fileInfo = await getWavFileInfo(bufferCopy);
-      actualBitDepth = fileInfo.bitDepth;
-    }
-    console.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,
-    });
-    console.log(
-      `extractAudioAnalysis skipWaveHeader=${skipWavHeader} convertPCMToFloat32 length=${channelData.length} range: [ ${min} :: ${max} ]`,
-    );
-
-    return new Promise((resolve, reject) => {
-      const worker = new Worker(
-        new URL(featuresExtratorUrl, window.location.href),
-      );
-
-      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");
-    }
-    console.log(`extractAudioAnalysis`, {
-      fileUri,
-      pointsPerSecond,
-      algorithm,
-    });
-    const res = await ExpoAudioStreamModule.extractAudioAnalysis({
-      fileUri,
-      pointsPerSecond,
-      skipWavHeader,
-      algorithm,
-      features,
-    });
-    console.log(`extractAudioAnalysis`, res);
-    return res;
-  }
-};
-
-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,
-  });
-  console.log(`extractWaveform`, res);
-  return res;
-};
+export * from "./utils/getWavFileInfo";
+export * from "./utils/convertPCMToFloat32";
+export * from "./utils/writeWavHeader";
 
 export {
   AudioRecorderProvider,
-  convertPCMToFloat32,
-  getWavFileInfo,
+  extractAudioAnalysis,
   useAudioRecorder,
   useSharedAudioRecorder,
-  writeWavHeader as writeWaveHeader,
 };
 
-export * from "./ExpoAudioStream.types";
+export type * from "./AudioAnalysis/AudioAnalysis.types";
+export type * from "./ExpoAudioStream.types";

package/src/logger.ts

@@ -0,0 +1,26 @@
+// packages/expo-audio-stream/src/logger.ts
+import createDebug from "debug";
+
+import { DEBUG_NAMESPACE } from "./constants";
+
+type ConsoleLike = {
+  log: (message: string, ...args: unknown[]) => void;
+  debug: (message: string, ...args: unknown[]) => void;
+};
+
+export const getLogger = (tag: string): ConsoleLike => {
+  const baseLogger = createDebug(`${DEBUG_NAMESPACE}:${tag}`);
+
+  return {
+    log: (...args: unknown[]) => baseLogger(...(args as [unknown])),
+    debug: (...args: unknown[]) => baseLogger(...(args as [unknown])),
+  };
+};
+
+export const enableAllLoggers = () => {
+  createDebug.enable(`${DEBUG_NAMESPACE}:*`);
+};
+
+export const disableAllLoggers = () => {
+  createDebug.disable();
+};

package/src/{useAudioRecording.tsx → useAudioRecorder.tsx}

@@ -1,20 +1,27 @@
-// src/useAudioRecording.ts
+// src/useAudioRecorder.ts
 import { Platform, Subscription } from "expo-modules-core";
 import { useCallback, useEffect, useReducer, useRef } from "react";
 
-import { addAudioAnalysisListener, addAudioEventListener } from ".";
 import {
   AudioAnalysisData,
+  AudioAnalysisEventPayload,
+  AudioFeaturesOptions,
+} from "./AudioAnalysis/AudioAnalysis.types";
+import {
   AudioDataEvent,
   AudioEventPayload,
-  AudioFeaturesOptions,
-  AudioStreamResult,
+  AudioRecordingResult,
   AudioStreamStatus,
   RecordingConfig,
-  StartAudioStreamResult,
+  StartRecordingResult,
 } from "./ExpoAudioStream.types";
 import ExpoAudioStreamModule from "./ExpoAudioStreamModule";
-import { WavFileInfo } from "./utils";
+import { addAudioAnalysisListener, addAudioEventListener } from "./events";
+import { disableAllLoggers, enableAllLoggers, getLogger } from "./logger";
+import { WavFileInfo } from "./utils/getWavFileInfo";
+
+const TAG = "useAudioRecorder";
+const logger = getLogger(TAG);
 
 export interface ExtractMetadataProps {
   fileUri?: string; // should provide either fileUri or arrayBuffer
@@ -40,8 +47,8 @@ export interface UseAudioRecorderProps {
 }
 
 export interface UseAudioRecorderState {
-  startRecording: (_: RecordingConfig) => Promise<StartAudioStreamResult>;
-  stopRecording: () => Promise<AudioStreamResult | null>;
+  startRecording: (_: RecordingConfig) => Promise<StartRecordingResult>;
+  stopRecording: () => Promise<AudioRecordingResult | null>;
   pauseRecording: () => void;
   resumeRecording: () => void;
   isRecording: boolean;
@@ -49,11 +56,9 @@ export interface UseAudioRecorderState {
   durationMs: number; // Duration of the recording
   size: number; // Size in bytes of the recorded audio
   analysisData?: AudioAnalysisData;
-  audioWorkletUrl?: string;
-  featuresExtratorUrl?: string;
 }
 
-interface RecorderState {
+interface RecorderReducerState {
   isRecording: boolean;
   isPaused: boolean;
   durationMs: number;
@@ -67,7 +72,7 @@ type RecorderAction =
   | { type: "UPDATE_ANALYSIS"; payload: AudioAnalysisData };
 
 const defaultAnalysis: AudioAnalysisData = {
-  pointsPerSecond: 20,
+  pointsPerSecond: 10,
   bitDepth: 32,
   numberOfChannels: 1,
   durationMs: 0,
@@ -80,10 +85,10 @@ const defaultAnalysis: AudioAnalysisData = {
   },
 };
 
-function recorderReducer(
-  state: RecorderState,
+function audioRecorderReducer(
+  state: RecorderReducerState,
   action: RecorderAction,
-): RecorderState {
+): RecorderReducerState {
   switch (action.type) {
     case "START":
       return {
@@ -115,14 +120,13 @@ function recorderReducer(
       return state;
   }
 }
-const TAG = "[ useAudioRecorder ] ";
 
 export function useAudioRecorder({
   debug = false,
   audioWorkletUrl,
   featuresExtratorUrl,
 }: UseAudioRecorderProps = {}): UseAudioRecorderState {
-  const [state, dispatch] = useReducer(recorderReducer, {
+  const [state, dispatch] = useReducer(audioRecorderReducer, {
     isRecording: false,
     isPaused: false,
     durationMs: 0,
@@ -143,26 +147,13 @@ export function useAudioRecorder({
     ((_: 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) => {
+    async ({ analysis, visualizationDuration }: AudioAnalysisEventPayload) => {
       const savedAnalysisData = analysisRef.current || { ...defaultAnalysis };
 
       const maxDuration = visualizationDuration;
 
-      logDebug(
+      logger.debug(
         `[handleAudioAnalysis] Received audio analysis: maxDuration=${maxDuration} analysis.dataPoints=${analysis.dataPoints.length} analysisData.dataPoints=${savedAnalysisData.dataPoints.length}`,
         analysis,
       );
@@ -178,7 +169,7 @@ export function useAudioRecorder({
         analysis.pointsPerSecond || savedAnalysisData.pointsPerSecond;
       const maxDataPoints = (pointsPerSecond * visualizationDuration) / 1000;
 
-      logDebug(
+      logger.debug(
         `[handleAudioAnalysis] Combined data points before trimming: pointsPerSecond=${pointsPerSecond} visualizationDuration=${visualizationDuration} combinedDataPointsLength=${combinedDataPoints.length} vs maxDataPoints=${maxDataPoints}`,
       );
 
@@ -208,7 +199,7 @@ export function useAudioRecorder({
         max: newMax,
       };
 
-      logDebug(
+      logger.debug(
         `[handleAudioAnalysis] Updated analysis data: durationMs=${savedAnalysisData.durationMs}`,
         savedAnalysisData,
       );
@@ -220,78 +211,80 @@ export function useAudioRecorder({
       // need to use spread operator otherwise it doesnt trigger update.
       dispatch({ type: "UPDATE_ANALYSIS", payload: { ...savedAnalysisData } });
     },
-    [logDebug],
+    [dispatch],
   );
 
-  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,
-          });
+  const handleAudioEvent = useCallback(async (eventData: AudioEventPayload) => {
+    const {
+      fileUri,
+      deltaSize,
+      totalSize,
+      lastEmittedSize,
+      position,
+      streamUuid,
+      encoded,
+      mimeType,
+      buffer,
+    } = eventData;
+    logger.debug(`[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");
         }
-      } catch (error) {
-        console.error(`${TAG} Error processing audio event:`, error);
+        onAudioStreamRef.current?.({
+          data: encoded,
+          position,
+          fileUri,
+          eventDataSize: deltaSize,
+          totalSize,
+        });
+      } else if (buffer) {
+        // Coming from web
+        const webEvent: AudioDataEvent = {
+          data: buffer,
+          position,
+          fileUri,
+          eventDataSize: deltaSize,
+          totalSize,
+        };
+        onAudioStreamRef.current?.(webEvent);
+        logger.debug(
+          `[handleAudioEvent] Audio data sent to onAudioStream`,
+          webEvent,
+        );
       }
-    },
-    [logDebug],
-  );
+    } catch (error) {
+      console.error(`${TAG} Error processing audio event:`, error);
+    }
+  }, []);
 
   const checkStatus = useCallback(async () => {
     try {
       if (!state.isRecording) {
-        logDebug(`${TAG} Not recording, exiting status check.`);
+        logger.debug(`Not recording, exiting status check.`);
         return;
       }
 
       const status: AudioStreamStatus = ExpoAudioStream.status();
       if (debug) {
-        logDebug(`${TAG} Status:`, status);
+        logger.debug(`Status:`, status);
       }
 
       dispatch({
@@ -301,59 +294,36 @@ export function useAudioRecorder({
     } 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]);
+  }, [state.isRecording]);
 
   const startRecording = useCallback(
     async (recordingOptions: RecordingConfig) => {
-      if (debug) {
-        logDebug(`start recoding`, recordingOptions);
-      }
+      logger.debug(`start recoding`, recordingOptions);
 
       analysisRef.current = { ...defaultAnalysis }; // Reset analysis data
 
       const { onAudioStream, ...options } = recordingOptions;
-      const { maxRecentDataDuration = 10000, enableProcessing } = options;
+      const { enableProcessing } = options;
+
+      const maxRecentDataDuration = 10000; // TODO compute maxRecentDataDuration based on screen dimensions
       if (typeof onAudioStream === "function") {
         onAudioStreamRef.current = onAudioStream;
       } else {
         console.warn(`${TAG} onAudioStream is not a function`, onAudioStream);
         onAudioStreamRef.current = null;
       }
-      const startResult: StartAudioStreamResult =
+      const startResult: StartRecordingResult =
         await ExpoAudioStream.startRecording(options);
       dispatch({ type: "START" });
 
       if (enableProcessing) {
-        logDebug(`Enabling audio analysis listener`);
+        logger.debug(`Enabling audio analysis listener`);
         const listener = addAudioAnalysisListener(async (analysisData) => {
           try {
-            await handleAudioAnalysis(analysisData, maxRecentDataDuration);
+            await handleAudioAnalysis({
+              analysis: analysisData,
+              visualizationDuration: maxRecentDataDuration,
+            });
           } catch (error) {
             console.warn(`${TAG} Error processing audio analysis:`, error);
           }
@@ -364,37 +334,72 @@ export function useAudioRecorder({
 
       return startResult;
     },
-    [logDebug],
+    [handleAudioAnalysis, dispatch],
   );
 
   const stopRecording = useCallback(async () => {
-    logDebug(`${TAG} stoping recording`);
+    logger.debug(`stoping recording`);
 
     if (analysisListenerRef.current) {
       analysisListenerRef.current.remove();
       analysisListenerRef.current = null;
     }
 
-    const stopResult: AudioStreamResult = await ExpoAudioStream.stopRecording();
+    const stopResult: AudioRecordingResult =
+      await ExpoAudioStream.stopRecording();
     onAudioStreamRef.current = null;
-    logDebug(`${TAG} recording stopped`, stopResult);
+    logger.debug(`recording stopped`, stopResult);
     dispatch({ type: "STOP" });
     return stopResult;
-  }, [logDebug]);
+  }, [dispatch]);
 
   const pauseRecording = useCallback(async () => {
-    logDebug(`${TAG} pause recording`);
+    logger.debug(`pause recording`);
     const pauseResult = await ExpoAudioStream.pauseRecording();
     dispatch({ type: "PAUSE" });
     return pauseResult;
-  }, [logDebug]);
+  }, [dispatch]);
 
   const resumeRecording = useCallback(async () => {
-    logDebug(`${TAG} resume recording`);
+    logger.debug(`resume recording`);
     const resumeResult = await ExpoAudioStream.resumeRecording();
     dispatch({ type: "RESUME" });
     return resumeResult;
-  }, [logDebug]);
+  }, [dispatch]);
+
+  useEffect(() => {
+    let interval: ReturnType<typeof setTimeout>;
+    if (state.isRecording) {
+      interval = setInterval(checkStatus, 1000);
+    }
+    return () => {
+      if (interval) {
+        clearInterval(interval);
+      }
+    };
+  }, [checkStatus, state.isRecording]);
+
+  useEffect(() => {
+    logger.debug(`Registering audio event listener`);
+    const subscribeAudio = addAudioEventListener(handleAudioEvent);
+
+    logger.debug(`Subscribed to audio event listener and analysis listener`, {
+      subscribeAudio,
+    });
+
+    return () => {
+      logger.debug(`Removing audio event listener`);
+      subscribeAudio.remove();
+    };
+  }, [handleAudioEvent, handleAudioAnalysis]);
+
+  useEffect(() => {
+    if (debug) {
+      enableAllLoggers();
+    } else {
+      disableAllLoggers();
+    }
+  }, [debug]);
 
   return {
     startRecording,

package/src/utils/convertPCMToFloat32.ts

@@ -0,0 +1,48 @@
+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 };
+};