npm - @siteed/expo-audio-stream - Versions diffs - 1.4.0 → 1.5.0 - Mend

@siteed/expo-audio-stream 1.4.0 → 1.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (792) hide show

package/src/utils/convertPCMToFloat32.ts CHANGED Viewed

@@ -1,3 +1,5 @@
+import { Platform } from 'react-native'
 import { ConsoleLike } from '../ExpoAudioStream.types'
 import { getWavFileInfo, WavFileInfo } from './getWavFileInfo'
@@ -29,6 +31,41 @@ const convertSample = (
     }
 }
+const convertSampleNative = (
+    array: Uint8Array,
+    startIndex: number,
+    bitDepth: number
+): number => {
+    switch (bitDepth) {
+        case 8:
+            return (array[startIndex] - 128) / 128
+        case 16: {
+            // Handle 16-bit PCM using Uint8Array directly
+            const low = array[startIndex]
+            const high = array[startIndex + 1]
+            const value = (high << 8) | low
+            // Convert to signed 16-bit
+            return (value > 32767 ? value - 65536 : value) / 32768
+        }
+        case 24: {
+            const byte1 = array[startIndex]
+            const byte2 = array[startIndex + 1]
+            const byte3 = array[startIndex + 2]
+            const value = (byte3 << 16) | (byte2 << 8) | byte1
+            return (
+                ((value > 8388607 ? value - 16777216 : value) / 8388608) * 2 - 1
+            )
+        }
+        case 32: {
+            // Assuming 32-bit float
+            const view = new DataView(array.buffer, startIndex, 4)
+            return view.getFloat32(0, true)
+        }
+        default:
+            throw new Error(`Unsupported bit depth: ${bitDepth}`)
+    }
+}
 export const convertPCMToFloat32 = async ({
     bitDepth,
     buffer,
@@ -44,32 +81,90 @@ export const convertPCMToFloat32 = async ({
         logger?.debug(
             `Converting PCM to Float32: bitDepth: ${bitDepth}, buffer.byteLength: ${buffer.byteLength}`
         )
-        const dataView = new DataView(buffer)
         let headerOffset = 0
-        if (skipWavHeader) {
+        if (!skipWavHeader) {
             const wavFileInfo: WavFileInfo = await getWavFileInfo(buffer)
             headerOffset = wavFileInfo.dataChunkOffset
+            logger?.debug(`Using WAV header offset: ${headerOffset}`)
         }
+        // Convert ArrayBuffer to Uint8Array for more efficient native handling
+        const uint8Array = new Uint8Array(buffer)
         const dataLength = buffer.byteLength - headerOffset
-        const sampleLength = Math.floor(dataLength / (bitDepth / 8))
-        const float32Array = new Float32Array(sampleLength)
+        const bytesPerSample = bitDepth / 8
+        const sampleLength = Math.floor(dataLength / bytesPerSample)
+        // Create result array using SharedArrayBuffer for better memory handling
+        let float32Array: Float32Array
+        try {
+            // Try using SharedArrayBuffer first
+            const sharedBuffer = new SharedArrayBuffer(sampleLength * 4)
+            float32Array = new Float32Array(sharedBuffer)
+        } catch (e) {
+            // Fallback to regular ArrayBuffer if SharedArrayBuffer is not available
+            float32Array = new Float32Array(sampleLength)
+        }
         let min = Infinity
         let max = -Infinity
-        for (let i = 0; i < sampleLength; i++) {
-            const offset = headerOffset + i * (bitDepth / 8)
-            const value = convertSample(dataView, offset, bitDepth)
+        // Process in smaller chunks
+        const CHUNK_SIZE = Platform.OS === 'web' ? sampleLength : 4000 // Smaller chunks for native
+        const numChunks = Math.ceil(sampleLength / CHUNK_SIZE)
+        for (let chunk = 0; chunk < numChunks; chunk++) {
+            const startSample = chunk * CHUNK_SIZE
+            const endSample = Math.min((chunk + 1) * CHUNK_SIZE, sampleLength)
+            // Process chunk
+            for (let i = startSample; i < endSample; i++) {
+                const startIndex = headerOffset + i * bytesPerSample
+                if (startIndex + bytesPerSample <= uint8Array.length) {
+                    const value =
+                        Platform.OS === 'web'
+                            ? convertSample(
+                                  new DataView(buffer),
+                                  startIndex,
+                                  bitDepth
+                              )
+                            : convertSampleNative(
+                                  uint8Array,
+                                  startIndex,
+                                  bitDepth
+                              )
-            if (value < min) min = value
-            if (value > max) max = value
+                    if (isFinite(value)) {
+                        float32Array[i] = value
+                        min = Math.min(min, value)
+                        max = Math.max(max, value)
+                    }
+                }
+            }
-            float32Array[i] = value
+            // Allow garbage collection between chunks on native
+            if (Platform.OS !== 'web' && chunk < numChunks - 1) {
+                await new Promise((resolve) => setTimeout(resolve, 0))
+            }
         }
-        return { pcmValues: float32Array, min, max }
+        logger?.debug(
+            `Conversion complete. Length: ${float32Array.length}, Range: [${min}, ${max}]`
+        )
+        // Only log a small sample of values to avoid memory issues
+        if (logger?.debug) {
+            const sampleValues = Array.from(float32Array.slice(0, 5))
+            logger.debug('Sample values:', sampleValues)
+        }
+        return {
+            pcmValues: float32Array,
+            min,
+            max,
+        }
     } catch (error: unknown) {
         logger?.error(`Error converting PCM to Float32`, error)
-        return { pcmValues: new Float32Array(), min: 0, max: 0 }
+        throw error
     }
 }

package/.eslintrc.js DELETED Viewed

	@@ -1,2 +0,0 @@
1	- // @generated by expo-module-scripts
2	- module.exports = require('expo-module-scripts/eslintrc.base.js');

package/.publisher/hooks/index.ts DELETED Viewed

@@ -1,21 +0,0 @@
-import type { PackageContext } from '@siteed/publisher';
-import { exec } from '@siteed/publisher';
-export async function preRelease(context: PackageContext): Promise<void> {
-  // Run tests
-  await exec('{{packageManager}} test', { cwd: context.path });
-  // Run type checking
-  await exec('{{packageManager}} typecheck', { cwd: context.path });
-  // Build the package
-  await exec('{{packageManager}} build', { cwd: context.path });
-}
-export async function postRelease(context: PackageContext): Promise<void> {
-  // Clean up build artifacts
-  await exec('{{packageManager}} clean', { cwd: context.path });
-  // Run any post-release notifications or integrations
-  console.log(`Successfully released ${context.name}@${context.newVersion}`);
-}