@siteed/expo-audio-stream 1.12.2 → 1.13.0

package/src/AudioAnalysis/extractAudioAnalysis.ts

@@ -6,6 +6,9 @@ import {
     AmplitudeAlgorithm,
     AudioAnalysis,
     AudioFeaturesOptions,
+    AudioPreview,
+    DecodingConfig,
+    PreviewOptions,
 } from './AudioAnalysis.types'
 import { convertPCMToFloat32 } from '../utils/convertPCMToFloat32'
 import { getWavFileInfo, WavFileInfo } from '../utils/getWavFileInfo'
@@ -27,6 +30,175 @@ export interface ExtractAudioAnalysisProps {
     features?: AudioFeaturesOptions
     featuresExtratorUrl?: string
     logger?: ConsoleLike
+    decodingOptions?: DecodingConfig
+}
+
+export interface ExtractAudioFromAnyFormatProps
+    extends ExtractAudioAnalysisProps {
+    mimeType?: string
+    decodingOptions?: DecodingConfig
+    startTime?: number // Add start time in milliseconds
+    endTime?: number // Add end time in milliseconds
+}
+
+export async function extractAudioFromAnyFormat({
+    fileUri,
+    arrayBuffer,
+    mimeType,
+    decodingOptions,
+    startTime,
+    endTime,
+    ...restProps
+}: ExtractAudioFromAnyFormatProps): Promise<AudioAnalysis> {
+    if (isWeb) {
+        try {
+            // Get the audio data
+            let audioBuffer: ArrayBuffer
+            if (arrayBuffer) {
+                audioBuffer = arrayBuffer
+            } else if (fileUri) {
+                const response = await fetch(fileUri)
+                if (!response.ok) {
+                    throw new Error(
+                        `Failed to fetch fileUri: ${response.statusText}`
+                    )
+                }
+                audioBuffer = await response.arrayBuffer()
+            } else {
+                throw new Error(
+                    'Either arrayBuffer or fileUri must be provided'
+                )
+            }
+
+            // Create audio context with target sample rate if specified
+            const audioContext = new (window.AudioContext ||
+                (window as any).webkitAudioContext)({
+                sampleRate: decodingOptions?.targetSampleRate,
+            })
+
+            // Decode the audio data
+            const decodedAudioBuffer =
+                await audioContext.decodeAudioData(audioBuffer)
+
+            // Calculate the actual duration in milliseconds
+            const fullDurationMs = decodedAudioBuffer.duration * 1000
+            const effectiveDurationMs = endTime
+                ? endTime - (startTime || 0)
+                : fullDurationMs - (startTime || 0)
+
+            // Create a new buffer for the selected range
+            const rangeLength = decodedAudioBuffer.length
+            const rangeBuffer = new AudioBuffer({
+                length: rangeLength,
+                numberOfChannels: decodedAudioBuffer.numberOfChannels,
+                sampleRate: decodedAudioBuffer.sampleRate,
+            })
+
+            // Copy the selected range
+            for (
+                let channel = 0;
+                channel < decodedAudioBuffer.numberOfChannels;
+                channel++
+            ) {
+                const channelData = decodedAudioBuffer.getChannelData(channel)
+                const rangeData = channelData.slice(0, rangeLength)
+                rangeBuffer.copyToChannel(rangeData, channel)
+            }
+
+            // Use the range buffer instead of the full buffer
+            let processedBuffer = rangeBuffer
+
+            // Get original properties
+            const originalSampleRate = processedBuffer.sampleRate
+            const length = processedBuffer.length
+
+            // Determine target format
+            const targetChannels =
+                decodingOptions?.targetChannels ??
+                processedBuffer.numberOfChannels
+            const targetSampleRate =
+                decodingOptions?.targetSampleRate ?? processedBuffer.sampleRate
+
+            // Create offline context for resampling if needed
+            if (targetSampleRate !== originalSampleRate) {
+                const offlineCtx = new OfflineAudioContext(
+                    targetChannels,
+                    (length * targetSampleRate) / originalSampleRate,
+                    targetSampleRate
+                )
+                const source = offlineCtx.createBufferSource()
+                source.buffer = processedBuffer
+                source.connect(offlineCtx.destination)
+                source.start()
+                processedBuffer = await offlineCtx.startRendering()
+            }
+
+            // Convert to the desired format
+            const newLength = processedBuffer.length
+            let wavBuffer: Float32Array | Int16Array | Int8Array
+
+            // Create appropriate buffer based on target bit depth
+            switch (decodingOptions?.targetBitDepth) {
+                case 16:
+                    wavBuffer = new Int16Array(newLength * targetChannels)
+                    break
+                case 8:
+                    wavBuffer = new Int8Array(newLength * targetChannels)
+                    break
+                case 32:
+                default:
+                    wavBuffer = new Float32Array(newLength * targetChannels)
+                    break
+            }
+
+            // Interleave channels and handle bit depth conversion
+            const numChannels = Math.min(
+                processedBuffer.numberOfChannels,
+                targetChannels
+            )
+            for (let channel = 0; channel < numChannels; channel++) {
+                const channelData = processedBuffer.getChannelData(channel)
+                for (let i = 0; i < newLength; i++) {
+                    let sample = channelData[i]
+
+                    // Normalize if requested
+                    if (decodingOptions?.normalizeAudio) {
+                        sample = Math.max(-1, Math.min(1, sample))
+                    }
+
+                    // Convert sample based on target bit depth
+                    if (decodingOptions?.targetBitDepth === 16) {
+                        sample = sample * 32767 // Convert to 16-bit range
+                    } else if (decodingOptions?.targetBitDepth === 8) {
+                        sample = sample * 127 // Convert to 8-bit range
+                    }
+
+                    wavBuffer[i * targetChannels + channel] = sample
+                }
+            }
+
+            // Pass the duration to extractAudioAnalysis
+            return await extractAudioAnalysis({
+                arrayBuffer: wavBuffer.buffer as ArrayBuffer,
+                bitDepth: decodingOptions?.targetBitDepth ?? 32,
+                skipWavHeader: true,
+                sampleRate: targetSampleRate,
+                numberOfChannels: targetChannels,
+                durationMs: effectiveDurationMs,
+                ...restProps,
+            })
+        } catch (error) {
+            console.error('Failed to process audio:', error)
+            throw error
+        }
+    } else {
+        // For native platforms, pass through all options
+        return await extractAudioAnalysis({
+            fileUri,
+            decodingOptions,
+            ...restProps,
+        })
+    }
 }
 
 export const extractAudioAnalysis = async ({
@@ -145,3 +317,50 @@ export const extractAudioAnalysis = async ({
         return res
     }
 }
+
+export async function extractPreview({
+    fileUri,
+    numberOfPoints,
+    algorithm = 'rms',
+    startTime,
+    endTime,
+    decodingOptions,
+}: PreviewOptions): Promise<AudioPreview> {
+    if (isWeb) {
+        // For web, we can reuse the existing extractAudioFromAnyFormat with modified parameters
+        const analysis = await extractAudioFromAnyFormat({
+            fileUri,
+            algorithm,
+            decodingOptions,
+            startTime, // Pass startTime
+            endTime, // Pass endTime
+            pointsPerSecond:
+                (numberOfPoints ?? 100) /
+                ((endTime ? endTime - (startTime || 0) : 1000) / 1000), // Adjust points per second calculation
+        })
+
+        // Convert AudioAnalysis to AudioPreview format and adjust duration
+        return {
+            pointsPerSecond: analysis.pointsPerSecond,
+            durationMs: endTime
+                ? endTime - (startTime || 0)
+                : analysis.durationMs, // Use range duration if specified
+            amplitudeRange: analysis.amplitudeRange,
+            dataPoints: analysis.dataPoints.map((point) => ({
+                id: point.id,
+                amplitude: point.amplitude,
+                startTime: point.startTime,
+                endTime: point.endTime,
+            })),
+        }
+    }
+
+    return await ExpoAudioStreamModule.extractPreview({
+        fileUri,
+        numberOfPoints,
+        algorithm,
+        startTime,
+        endTime,
+        decodingOptions,
+    })
+}

package/src/index.ts

@@ -1,6 +1,10 @@
 // src/index.ts
 
-import { extractAudioAnalysis } from './AudioAnalysis/extractAudioAnalysis'
+import {
+    extractAudioAnalysis,
+    extractAudioFromAnyFormat,
+    extractPreview,
+} from './AudioAnalysis/extractAudioAnalysis'
 import {
     AudioRecorderProvider,
     useSharedAudioRecorder,
@@ -16,9 +20,16 @@ export {
     AudioRecorderProvider,
     ExpoAudioStreamModule,
     extractAudioAnalysis,
+    extractAudioFromAnyFormat,
+    extractPreview,
     useAudioRecorder,
     useSharedAudioRecorder,
 }
 
 export type * from './AudioAnalysis/AudioAnalysis.types'
+
 export type * from './ExpoAudioStream.types'
+export type {
+    ExtractAudioAnalysisProps,
+    ExtractAudioFromAnyFormatProps,
+} from './AudioAnalysis/extractAudioAnalysis'

package/src/useAudioRecorder.tsx

@@ -178,6 +178,14 @@ export function useAudioRecorder({
         ((_: AudioDataEvent) => Promise<void>) | null
     >(null)
 
+    const stateRef = useRef({
+        isRecording: false,
+        isPaused: false,
+        durationMs: 0,
+        size: 0,
+        compression: undefined as CompressionInfo | undefined,
+    })
+
     const handleAudioAnalysis = useCallback(
         async ({
             analysis,
@@ -373,15 +381,17 @@ export function useAudioRecorder({
         try {
             const status: AudioStreamStatus = ExpoAudioStream.status()
             logger?.debug(
-                `Status: paused: ${status.isPaused} durationMs: ${status.durationMs} size: ${status.size}`,
+                `Status: paused: ${status.isPaused} isRecording: ${status.isRecording} durationMs: ${status.durationMs} size: ${status.size}`,
                 status.compression
             )
 
             // Only dispatch if values actually changed
             if (
-                status.isRecording !== state.isRecording ||
-                status.isPaused !== state.isPaused
+                status.isRecording !== stateRef.current.isRecording ||
+                status.isPaused !== stateRef.current.isPaused
             ) {
+                stateRef.current.isRecording = status.isRecording
+                stateRef.current.isPaused = status.isPaused
                 dispatch({
                     type: 'UPDATE_RECORDING_STATE',
                     payload: {
@@ -391,13 +401,13 @@ export function useAudioRecorder({
                 })
             }
 
-            // Only dispatch if progress values changed
             if (
-                status.durationMs !== state.durationMs ||
-                status.size !== state.size ||
-                JSON.stringify(status.compression) !==
-                    JSON.stringify(state.compression)
+                status.durationMs !== stateRef.current.durationMs ||
+                status.size !== stateRef.current.size
             ) {
+                stateRef.current.durationMs = status.durationMs
+                stateRef.current.size = status.size
+                stateRef.current.compression = status.compression
                 dispatch({
                     type: 'UPDATE_STATUS',
                     payload: {
@@ -410,6 +420,17 @@ export function useAudioRecorder({
         } catch (error) {
             logger?.error(`Error getting status:`, error)
         }
+    }, [ExpoAudioStream, logger]) // Only depend on ExpoAudioStream and logger
+
+    // Update ref when state changes
+    useEffect(() => {
+        stateRef.current = {
+            isRecording: state.isRecording,
+            isPaused: state.isPaused,
+            durationMs: state.durationMs,
+            size: state.size,
+            compression: state.compression,
+        }
     }, [
         state.isRecording,
         state.isPaused,
@@ -499,18 +520,18 @@ export function useAudioRecorder({
     useEffect(() => {
         let intervalId: NodeJS.Timeout | undefined
 
-        const runInterval = () => {
-            if (state.isRecording || state.isPaused) {
-                checkStatus()
-                intervalId = setTimeout(runInterval, 1000)
-            }
-        }
+        if (state.isRecording || state.isPaused) {
+            // Immediately check status when starting
+            checkStatus()
 
-        runInterval()
+            // Start interval
+            intervalId = setInterval(checkStatus, 1000)
+        }
 
         return () => {
             if (intervalId) {
-                clearTimeout(intervalId)
+                clearInterval(intervalId)
+                intervalId = undefined
             }
         }
     }, [checkStatus, state.isRecording, state.isPaused])