@siteed/expo-audio-stream 1.16.0 → 2.0.0

package/src/ExpoAudioStream.web.ts

@@ -46,9 +46,11 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
     currentDurationMs: number
     currentSize: number
     currentInterval: number
+    currentIntervalAnalysis: number
     lastEmittedSize: number
     lastEmittedTime: number
     lastEmittedCompressionSize: number
+    lastEmittedAnalysisTime: number
     streamUuid: string | null
     extension: 'webm' | 'wav' = 'wav' // Default extension is 'wav'
     recordingConfig?: RecordingConfig
@@ -87,10 +89,12 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         this.currentSize = 0
         this.bitDepth = 32 // Default
         this.currentInterval = 1000 // Default interval in ms
+        this.currentIntervalAnalysis = 500 // Default analysis interval in ms
         this.lastEmittedSize = 0
         this.lastEmittedTime = 0
         this.latestPosition = 0
         this.lastEmittedCompressionSize = 0
+        this.lastEmittedAnalysisTime = 0
         this.streamUuid = null // Initialize UUID on first recording start
         this.audioWorkletUrl = audioWorkletUrl
         this.featuresExtratorUrl = featuresExtratorUrl
@@ -132,7 +136,6 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
             audioContext,
             source,
             recordingConfig,
-            audioWorkletUrl: this.audioWorkletUrl,
             emitAudioEventCallback: ({
                 data,
                 position,
@@ -172,6 +175,9 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         this.lastEmittedSize = 0
         this.lastEmittedTime = 0
         this.lastEmittedCompressionSize = 0
+        this.currentInterval = recordingConfig.interval ?? 1000
+        this.currentIntervalAnalysis = recordingConfig.intervalAnalysis ?? 500
+        this.lastEmittedAnalysisTime = Date.now()
 
         // Use custom filename if provided, otherwise fallback to timestamp
         if (recordingConfig.filename) {
@@ -335,6 +341,7 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
             durationMs: this.currentDurationMs,
             size: this.currentSize,
             interval: this.currentInterval,
+            intervalAnalysis: this.currentIntervalAnalysis,
             mimeType: `audio/${this.extension}`,
             compression: this.recordingConfig?.compression?.enabled
                 ? {

package/src/ExpoAudioStreamModule.ts

@@ -1,10 +1,18 @@
+import crc32 from 'crc-32'
 import { requireNativeModule } from 'expo-modules-core'
 import { Platform } from 'react-native'
 
+import {
+    ExtractAudioDataOptions,
+    ExtractedAudioData,
+    BitDepth,
+} from './ExpoAudioStream.types'
 import {
     ExpoAudioStreamWeb,
     ExpoAudioStreamWebProps,
 } from './ExpoAudioStream.web'
+import { processAudioBuffer } from './utils/audioProcessing'
+import { writeWavHeader } from './utils/writeWavHeader'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let ExpoAudioStreamModule: any
@@ -19,19 +27,256 @@ if (Platform.OS === 'web') {
         return instance
     }
     ExpoAudioStreamModule.requestPermissionsAsync = async () => {
-        return {
-            status: 'granted',
-            granted: true,
-            expires: 'never',
-            canAskAgain: true,
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({
+                audio: true,
+            })
+            stream.getTracks().forEach((track) => track.stop())
+            return {
+                status: 'granted',
+                expires: 'never',
+                canAskAgain: true,
+                granted: true,
+            }
+        } catch {
+            return {
+                status: 'denied',
+                expires: 'never',
+                canAskAgain: true,
+                granted: false,
+            }
         }
     }
     ExpoAudioStreamModule.getPermissionsAsync = async () => {
-        return {
-            status: 'granted',
-            granted: true,
-            expires: 'never',
-            canAskAgain: true,
+        let maybeStatus: string | null = null
+
+        if (navigator?.permissions?.query) {
+            try {
+                const { state } = await navigator.permissions.query({
+                    name: 'microphone' as PermissionName,
+                })
+                maybeStatus = state
+            } catch {
+                maybeStatus = null
+            }
+        }
+
+        switch (maybeStatus) {
+            case 'granted':
+                return {
+                    status: 'granted',
+                    expires: 'never',
+                    canAskAgain: true,
+                    granted: true,
+                }
+            case 'denied':
+                return {
+                    status: 'denied',
+                    expires: 'never',
+                    canAskAgain: true,
+                    granted: false,
+                }
+            default:
+                return await ExpoAudioStreamModule.requestPermissionsAsync()
+        }
+    }
+    ExpoAudioStreamModule.extractAudioData = async (
+        options: ExtractAudioDataOptions
+    ): Promise<ExtractedAudioData> => {
+        try {
+            const {
+                fileUri,
+                position,
+                length,
+                startTimeMs,
+                endTimeMs,
+                decodingOptions,
+                includeNormalizedData,
+                includeBase64Data,
+                includeWavHeader = false,
+                logger,
+            } = options
+
+            logger?.debug('EXTRACT AUDIO - Step 1: Initial request', {
+                fileUri,
+                extractionParams: {
+                    position,
+                    length,
+                    startTimeMs,
+                    endTimeMs,
+                },
+                decodingOptions: {
+                    targetSampleRate:
+                        decodingOptions?.targetSampleRate ?? 16000,
+                    targetChannels: decodingOptions?.targetChannels ?? 1,
+                    targetBitDepth: decodingOptions?.targetBitDepth ?? 16,
+                    normalizeAudio: decodingOptions?.normalizeAudio ?? false,
+                },
+                outputOptions: {
+                    includeNormalizedData,
+                    includeBase64Data,
+                    includeWavHeader,
+                },
+            })
+
+            // Process the audio using shared helper function
+            const processedBuffer = await processAudioBuffer({
+                fileUri,
+                targetSampleRate: decodingOptions?.targetSampleRate ?? 16000,
+                targetChannels: decodingOptions?.targetChannels ?? 1,
+                normalizeAudio: decodingOptions?.normalizeAudio ?? false,
+                position,
+                length,
+                startTimeMs,
+                endTimeMs,
+                logger,
+            })
+
+            logger?.debug('EXTRACT AUDIO - Step 2: Audio processing complete', {
+                processedData: {
+                    samples: processedBuffer.samples,
+                    sampleRate: processedBuffer.sampleRate,
+                    channels: processedBuffer.channels,
+                    durationMs: processedBuffer.durationMs,
+                },
+            })
+
+            const channelData = processedBuffer.channelData
+            const bitDepth = (decodingOptions?.targetBitDepth ?? 16) as BitDepth
+            const bytesPerSample = bitDepth / 8
+            const numSamples = processedBuffer.samples
+
+            logger?.debug('EXTRACT AUDIO - Step 3: PCM conversion setup', {
+                channelData: {
+                    length: channelData.length,
+                    first: channelData[0],
+                    last: channelData[channelData.length - 1],
+                },
+                calculation: {
+                    bitDepth,
+                    bytesPerSample,
+                    numSamples,
+                    expectedBytes: numSamples * bytesPerSample,
+                },
+            })
+
+            // Create PCM data with correct length based on original byte length
+            const pcmData = new Uint8Array(numSamples * bytesPerSample)
+            let offset = 0
+
+            // Convert Float32 samples to PCM format
+            for (let i = 0; i < numSamples; i++) {
+                const sample = channelData[i]
+                const value = Math.max(-1, Math.min(1, sample))
+                // Convert to 16-bit signed integer
+                let intValue = Math.round(value * 32767)
+
+                // Handle negative values correctly
+                if (intValue < 0) {
+                    intValue = 65536 + intValue
+                }
+
+                // Write as little-endian
+                pcmData[offset++] = intValue & 255 // Low byte
+                pcmData[offset++] = (intValue >> 8) & 255 // High byte
+            }
+
+            const durationMs = Math.round(
+                (numSamples / processedBuffer.sampleRate) * 1000
+            )
+
+            logger?.debug('EXTRACT AUDIO - Step 4: Final output', {
+                pcmData: {
+                    length: pcmData.length,
+                    first: pcmData[0],
+                    last: pcmData[pcmData.length - 1],
+                },
+                timing: {
+                    numSamples,
+                    sampleRate: processedBuffer.sampleRate,
+                    durationMs,
+                    shouldBe3000ms: endTimeMs
+                        ? endTimeMs - (startTimeMs ?? 0) === 3000
+                        : undefined,
+                },
+            })
+
+            const result: ExtractedAudioData = {
+                pcmData: new Uint8Array(pcmData.buffer),
+                sampleRate: processedBuffer.sampleRate,
+                channels: processedBuffer.channels,
+                bitDepth,
+                durationMs,
+                format: `pcm_${bitDepth}bit` as const,
+                samples: numSamples,
+            }
+
+            // Add WAV header if requested
+            if (includeWavHeader) {
+                logger?.debug('EXTRACT AUDIO - Step 4: Adding WAV header', {
+                    originalLength: pcmData.length,
+                    newLength: result.pcmData.length,
+                    firstBytes: Array.from(result.pcmData.slice(0, 44)), // WAV header is 44 bytes
+                })
+                const wavBuffer = writeWavHeader({
+                    buffer: pcmData.buffer.slice(0, pcmData.length),
+                    sampleRate: processedBuffer.sampleRate,
+                    numChannels: processedBuffer.channels,
+                    bitDepth,
+                })
+                result.pcmData = new Uint8Array(wavBuffer)
+                result.hasWavHeader = true
+            }
+
+            if (includeNormalizedData) {
+                // // Simple approach: Create normalized data directly from the PCM data
+                // // Just convert to -1 to 1 range without any amplification
+                // const normalizedData = new Float32Array(numSamples)
+
+                // // Convert the PCM data to float values
+                // for (let i = 0; i < numSamples; i++) {
+                //     // Get the 16-bit PCM value (little endian)
+                //     const lowByte = pcmData[i * 2]
+                //     const highByte = pcmData[i * 2 + 1]
+                //     const pcmValue = (highByte << 8) | lowByte
+
+                //     // Convert to signed 16-bit value
+                //     const signedValue =
+                //         pcmValue > 32767 ? pcmValue - 65536 : pcmValue
+
+                //     // Normalize to float between -1 and 1
+                //     normalizedData[i] = signedValue / 32768.0
+                // }
+                // Store the normalized data in the result
+                result.normalizedData = channelData
+            }
+
+            if (includeBase64Data) {
+                // Convert the PCM data to a base64 string
+                const binary = Array.from(new Uint8Array(pcmData.buffer))
+                    .map((b) => String.fromCharCode(b))
+                    .join('')
+                result.base64Data = btoa(binary)
+            }
+
+            if (options.computeChecksum) {
+                result.checksum = crc32.buf(pcmData)
+            }
+
+            logger?.debug('EXTRACT AUDIO - Step 3: PCM conversion complete', {
+                pcmStats: {
+                    length: pcmData.length,
+                    bytesPerSample,
+                    totalSamples: numSamples,
+                    firstBytes: Array.from(pcmData.slice(0, 16)),
+                    lastBytes: Array.from(pcmData.slice(-16)),
+                },
+            })
+
+            return result
+        } catch (error) {
+            options.logger?.error('EXTRACT AUDIO - Error:', error)
+            throw error
         }
     }
 } else {