@siteed/expo-audio-studio 2.8.6 → 2.10.0

package/build/cjs/WebRecorder.web.js

@@ -97,7 +97,7 @@ class WebRecorder {
             this.initFeatureExtractorWorker();
         }
         // Initialize compressed recording if enabled
-        if (recordingConfig.compression?.enabled) {
+        if (recordingConfig.output?.compressed?.enabled) {
             this.initializeCompressedRecorder();
         }
         this.mediaStream = source.mediaStream;
@@ -141,6 +141,8 @@ class WebRecorder {
                 const incomingPosition = typeof event.data.position === 'number'
                     ? event.data.position
                     : this.position;
+                // Simple position tracking for logging (no duplicate filtering)
+                this.logger?.debug(`Audio chunk: position=${incomingPosition.toFixed(3)}s, size=${pcmBufferFloat.length}`);
                 // Calculate bytes per sample based on bit depth
                 const bytesPerSample = this.bitDepth / 8;
                 // Emit chunks without storing them
@@ -151,6 +153,14 @@ class WebRecorder {
                     const startPosition = Math.floor(i * bytesPerSample);
                     const endPosition = Math.floor((i + chunk.length) * bytesPerSample);
                     const samples = chunk.length; // Number of samples in this chunk
+                    // Only store PCM data if primary output is enabled
+                    const shouldStoreUncompressed = this.config.output?.primary?.enabled ?? true;
+                    // Store PCM chunks when needed - this is for the final WAV file
+                    if (shouldStoreUncompressed) {
+                        // Store the original Float32Array data for later WAV creation
+                        this.appendPcmData(chunk);
+                        this.totalSampleCount += chunk.length;
+                    }
                     // Process features if enabled
                     if (this.config.enableProcessing &&
                         this.featureExtractorWorker) {
@@ -170,34 +180,30 @@ class WebRecorder {
                             samples,
                         });
                     }
-                    // Only store PCM data if web.storeUncompressedAudio is not explicitly false
-                    const shouldStoreUncompressed = this.config.web?.storeUncompressedAudio !== false;
-                    // Store PCM chunks when needed
-                    if (shouldStoreUncompressed) {
-                        // Store the original Float32Array data for later WAV creation
-                        this.appendPcmData(chunk);
-                        this.totalSampleCount += chunk.length;
-                    }
-                    // Emit chunk immediately
+                    // Prepare compression data if available
+                    const compression = this.pendingCompressedChunk
+                        ? {
+                            data: this.pendingCompressedChunk,
+                            size: this.pendingCompressedChunk.size,
+                            totalSize: this.compressedSize,
+                            mimeType: 'audio/webm',
+                            format: this.config.output?.compressed?.format ??
+                                'opus',
+                            bitrate: this.config.output?.compressed?.bitrate ??
+                                128000,
+                        }
+                        : undefined;
+                    // Emit chunk immediately - whether compressed or not
                     this.emitAudioEventCallback({
                         data: chunk,
                         position: chunkPosition,
-                        compression: this.pendingCompressedChunk
-                            ? {
-                                data: this.pendingCompressedChunk,
-                                size: this.pendingCompressedChunk.size,
-                                totalSize: this.compressedSize,
-                                mimeType: 'audio/webm',
-                                format: 'opus',
-                                bitrate: this.config.compression?.bitrate ??
-                                    128000,
-                            }
-                            : undefined,
+                        compression,
                     });
+                    // Reset pending compressed chunk after we've used it
+                    this.pendingCompressedChunk = null;
                 }
                 // Update our position based on the worklet's position if provided
                 this.position = incomingPosition + duration;
-                this.pendingCompressedChunk = null;
             };
             // Ensure we use all relevant settings from config
             const recordSampleRate = this.audioContext.sampleRate;
@@ -212,12 +218,12 @@ class WebRecorder {
                 channels,
                 interval,
                 position: this.position,
-                deviceId: this.config.deviceId || 'default',
-                compression: this.config.compression
+                deviceId: this.config.deviceId ?? 'default',
+                compression: this.config.output?.compressed
                     ? {
-                        enabled: this.config.compression.enabled,
-                        format: this.config.compression.format,
-                        bitrate: this.config.compression.bitrate,
+                        enabled: this.config.output.compressed.enabled,
+                        format: this.config.output.compressed.format,
+                        bitrate: this.config.output.compressed.bitrate,
                     }
                     : 'disabled',
             });
@@ -298,78 +304,85 @@ class WebRecorder {
      * @param event - The event containing audio analysis results
      */
     handleFeatureExtractorMessage(event) {
-        if (event.data.command === 'features') {
-            const segmentResult = event.data.result;
-            // Track existing IDs to prevent duplicates
-            const existingIds = new Set(this.audioAnalysisData.dataPoints.map((dp) => dp.id));
-            // Filter out datapoints with duplicate IDs
-            const uniqueNewDataPoints = segmentResult.dataPoints.filter((dp) => {
-                return !existingIds.has(dp.id);
-            });
-            // Log filtered duplicates if any
-            if (uniqueNewDataPoints.length < segmentResult.dataPoints.length &&
-                this.logger?.warn) {
-                this.logger.warn(`Filtered ${segmentResult.dataPoints.length - uniqueNewDataPoints.length} duplicate datapoints`);
-            }
-            // Update counter based on the highest ID seen
-            if (uniqueNewDataPoints.length > 0) {
-                const lastDataPoint = uniqueNewDataPoints[uniqueNewDataPoints.length - 1];
-                if (lastDataPoint && typeof lastDataPoint.id === 'number') {
-                    const nextIdValue = lastDataPoint.id + 1;
-                    if (nextIdValue > this.dataPointIdCounter) {
-                        this.dataPointIdCounter = nextIdValue;
-                        this.logger?.debug(`Counter updated to ${this.dataPointIdCounter}`);
-                    }
-                }
-            }
-            // Add unique data points to our analysis data
-            this.audioAnalysisData.dataPoints.push(...uniqueNewDataPoints);
-            this.audioAnalysisData.durationMs += segmentResult.durationMs;
-            this.audioAnalysisData.sampleRate = segmentResult.sampleRate;
-            // Merge amplitude ranges
-            if (segmentResult.amplitudeRange) {
-                if (!this.audioAnalysisData.amplitudeRange) {
-                    this.audioAnalysisData.amplitudeRange = {
-                        ...segmentResult.amplitudeRange,
-                    };
-                }
-                else {
-                    this.audioAnalysisData.amplitudeRange = {
-                        min: Math.min(this.audioAnalysisData.amplitudeRange.min, segmentResult.amplitudeRange.min),
-                        max: Math.max(this.audioAnalysisData.amplitudeRange.max, segmentResult.amplitudeRange.max),
-                    };
-                }
-            }
-            // Merge RMS ranges
-            if (segmentResult.rmsRange) {
-                if (!this.audioAnalysisData.rmsRange) {
-                    this.audioAnalysisData.rmsRange = {
-                        ...segmentResult.rmsRange,
-                    };
-                }
-                else {
-                    this.audioAnalysisData.rmsRange = {
-                        min: Math.min(this.audioAnalysisData.rmsRange.min, segmentResult.rmsRange.min),
-                        max: Math.max(this.audioAnalysisData.rmsRange.max, segmentResult.rmsRange.max),
-                    };
-                }
+        if (event.data.command !== 'features')
+            return;
+        const segmentResult = event.data.result;
+        const uniqueNewDataPoints = this.filterUniqueDataPoints(segmentResult.dataPoints);
+        // Update counter based on the highest ID seen
+        this.updateDataPointCounter(uniqueNewDataPoints);
+        // Update analysis data with the new results
+        this.updateAudioAnalysisData(segmentResult, uniqueNewDataPoints);
+        // Send filtered result to avoid duplicate IDs
+        const filteredSegmentResult = {
+            ...segmentResult,
+            dataPoints: uniqueNewDataPoints,
+        };
+        this.emitAudioAnalysisCallback(filteredSegmentResult);
+    }
+    /**
+     * Filters out data points with duplicate IDs
+     */
+    filterUniqueDataPoints(dataPoints) {
+        // Track existing IDs to prevent duplicates
+        const existingIds = new Set(this.audioAnalysisData.dataPoints.map((dp) => dp.id));
+        // Filter out datapoints with duplicate IDs
+        const uniquePoints = dataPoints.filter((dp) => !existingIds.has(dp.id));
+        // Log filtered duplicates if any
+        if (uniquePoints.length < dataPoints.length && this.logger?.warn) {
+            this.logger.warn(`Filtered ${dataPoints.length - uniquePoints.length} duplicate datapoints`);
+        }
+        return uniquePoints;
+    }
+    /**
+     * Updates the counter based on the highest ID in datapoints
+     */
+    updateDataPointCounter(dataPoints) {
+        if (dataPoints.length === 0)
+            return;
+        const lastDataPoint = dataPoints[dataPoints.length - 1];
+        if (lastDataPoint && typeof lastDataPoint.id === 'number') {
+            const nextIdValue = lastDataPoint.id + 1;
+            if (nextIdValue > this.dataPointIdCounter) {
+                this.dataPointIdCounter = nextIdValue;
+                this.logger?.debug(`Counter updated to ${this.dataPointIdCounter}`);
             }
-            // Send filtered result to avoid duplicate IDs
-            const filteredSegmentResult = {
-                ...segmentResult,
-                dataPoints: uniqueNewDataPoints,
-            };
-            this.emitAudioAnalysisCallback(filteredSegmentResult);
         }
     }
+    /**
+     * Updates audio analysis data with segment results
+     */
+    updateAudioAnalysisData(segmentResult, uniqueDataPoints) {
+        // Add unique data points to our analysis data
+        this.audioAnalysisData.dataPoints.push(...uniqueDataPoints);
+        this.audioAnalysisData.durationMs += segmentResult.durationMs;
+        this.audioAnalysisData.sampleRate = segmentResult.sampleRate;
+        // Update amplitude range if present
+        if (segmentResult.amplitudeRange) {
+            this.audioAnalysisData.amplitudeRange = this.mergeRange(this.audioAnalysisData.amplitudeRange, segmentResult.amplitudeRange);
+        }
+        // Update RMS range if present
+        if (segmentResult.rmsRange) {
+            this.audioAnalysisData.rmsRange = this.mergeRange(this.audioAnalysisData.rmsRange, segmentResult.rmsRange);
+        }
+    }
+    /**
+     * Merges value ranges
+     */
+    mergeRange(existing, newRange) {
+        if (!existing)
+            return { ...newRange };
+        return {
+            min: Math.min(existing.min, newRange.min),
+            max: Math.max(existing.max, newRange.max),
+        };
+    }
     /**
      * Reset the data point counter to a specific value or zero
      * @param startCounterFrom Optional value to start the counter from (for continuing from previous recordings)
      */
     resetDataPointCounter(startCounterFrom) {
         // Set the counter with the passed value or 0
-        this.dataPointIdCounter =
-            startCounterFrom !== undefined ? startCounterFrom : 0;
+        this.dataPointIdCounter = startCounterFrom ?? 0;
         this.logger?.debug(`Reset data point counter to ${this.dataPointIdCounter}`);
         // Update worker counter if available
         if (this.featureExtractorWorker) {
@@ -431,7 +444,7 @@ class WebRecorder {
                 this.logger?.warn('No PCM data available to create WAV file');
                 return null;
             }
-            const sampleRate = this.config.sampleRate || this.audioContext.sampleRate;
+            const sampleRate = this.config.sampleRate ?? this.audioContext.sampleRate;
             const channels = this.numberOfChannels || 1;
             // Convert float32 PCM data to 16-bit PCM for WAV
             const bytesPerSample = 2; // 16-bit = 2 bytes
@@ -479,8 +492,7 @@ class WebRecorder {
             let uncompressedBlob;
             // Only create WAV if we have PCM data
             if (this.pcmData && this.pcmData.length > 0) {
-                uncompressedBlob =
-                    (await this.createWavFromPcmData()) || undefined;
+                uncompressedBlob = this.createWavFromPcmData() || undefined;
             }
             // Return the compressed and/or uncompressed blobs if available
             return {
@@ -500,6 +512,7 @@ class WebRecorder {
             this.pendingCompressedChunk = null;
             this.pcmData = null;
             this.totalSampleCount = 0;
+            this.dataPointIdCounter = 0; // Reset counter
         }
     }
     /**
@@ -514,12 +527,10 @@ class WebRecorder {
         }
         // Check if AudioContext is already closed before attempting to close it
         if (this.audioContext && this.audioContext.state !== 'closed') {
-            try {
-                this.audioContext.close();
-            }
-            catch (e) {
-                // Ignore closure errors - this happens if already closed
-            }
+            this.audioContext.close().catch((e) => {
+                // Log closure errors but continue cleanup
+                this.logger?.warn('Error closing AudioContext:', e);
+            });
         }
         // Safely disconnect audioWorkletNode if it exists
         if (this.audioWorkletNode) {
@@ -527,7 +538,8 @@ class WebRecorder {
                 this.audioWorkletNode.disconnect();
             }
             catch (e) {
-                // Ignore disconnection errors - node might be already disconnected
+                // Log disconnection errors but continue cleanup
+                this.logger?.warn('Error disconnecting audioWorkletNode:', e);
             }
         }
         // Safely disconnect source if it exists
@@ -536,7 +548,8 @@ class WebRecorder {
                 this.source.disconnect();
             }
             catch (e) {
-                // Ignore disconnection errors - source might be already disconnected
+                // Log disconnection errors but continue cleanup
+                this.logger?.warn('Error disconnecting source:', e);
             }
         }
         // Always stop media stream tracks to release hardware resources
@@ -616,6 +629,8 @@ class WebRecorder {
         }
         catch (error) {
             this.logger?.error('Error in resume(): ', error);
+            // Rethrow the error to inform callers
+            throw new Error(`Failed to resume recording: ${error instanceof Error ? error.message : 'unknown error'}`);
         }
     }
     /**
@@ -631,18 +646,22 @@ class WebRecorder {
             }
             this.compressedMediaRecorder = new MediaRecorder(this.source.mediaStream, {
                 mimeType,
-                audioBitsPerSecond: this.config.compression?.bitrate ?? 128000,
+                audioBitsPerSecond: this.config.output?.compressed?.bitrate ?? 128000,
             });
             this.compressedMediaRecorder.ondataavailable = (event) => {
                 if (event.data.size > 0) {
+                    // Store the compressed chunk for final blob creation
                     this.compressedChunks.push(event.data);
                     this.compressedSize += event.data.size;
+                    // Store the pending compressed chunk for the next PCM chunk to use
                     this.pendingCompressedChunk = event.data;
                 }
             };
         }
         catch (error) {
             this.logger?.error('Failed to initialize compressed recorder:', error);
+            // Setting to null to indicate initialization failed
+            this.compressedMediaRecorder = null;
         }
     }
     /**
@@ -697,6 +716,7 @@ class WebRecorder {
                 }
                 catch (e) {
                     // Ignore disconnection errors as the track might already be gone
+                    this.logger?.warn('Error disconnecting audioWorkletNode:', e);
                 }
             }
         };