@siteed/audio-studio 3.0.0

package/src/utils/audioProcessing.ts

@@ -0,0 +1,205 @@
+// packages/audio-studio/src/utils/audioProcessing.ts
+import { Platform } from 'react-native'
+
+import { ConsoleLike } from '../AudioStudio.types'
+
+export interface ProcessAudioBufferOptions {
+    arrayBuffer?: ArrayBuffer
+    fileUri?: string
+    targetSampleRate: number
+    targetChannels: number
+    normalizeAudio: boolean
+    startTimeMs?: number
+    endTimeMs?: number
+    position?: number
+    length?: number
+    audioContext?: AudioContext
+    logger?: ConsoleLike
+}
+
+export interface ProcessedAudioData {
+    channelData: Float32Array
+    samples: number
+    durationMs: number
+    sampleRate: number
+    channels: number
+    buffer: AudioBuffer
+}
+
+export async function processAudioBuffer({
+    arrayBuffer,
+    fileUri,
+    targetSampleRate,
+    targetChannels,
+    normalizeAudio,
+    startTimeMs,
+    endTimeMs,
+    position,
+    length,
+    audioContext,
+    logger,
+}: ProcessAudioBufferOptions): Promise<ProcessedAudioData> {
+    if (Platform.OS !== 'web') {
+        throw new Error('processAudioBuffer is only supported on web')
+    }
+
+    let ctx: AudioContext | undefined
+    let buffer: AudioBuffer | undefined
+
+    try {
+        // Log initial parameters
+        logger?.debug('Process audio buffer - Initial params:', {
+            hasArrayBuffer: !!arrayBuffer,
+            fileUri,
+            targetSampleRate,
+            targetChannels,
+            normalizeAudio,
+            startTimeMs,
+            endTimeMs,
+            position,
+            length,
+        })
+
+        // Get the audio data
+        let audioData: ArrayBuffer
+        if (arrayBuffer) {
+            audioData = arrayBuffer
+        } else if (fileUri) {
+            const response = await fetch(fileUri)
+            if (!response.ok) {
+                throw new Error(
+                    `Failed to fetch fileUri: ${response.statusText}`
+                )
+            }
+            audioData = await response.arrayBuffer()
+        } else {
+            throw new Error('Either arrayBuffer or fileUri must be provided')
+        }
+
+        logger?.debug('Audio data loaded:', {
+            byteLength: audioData.byteLength,
+            firstBytes: Array.from(new Uint8Array(audioData.slice(0, 16))),
+        })
+
+        // Create context at original sample rate first
+        ctx =
+            audioContext ||
+            new (window.AudioContext || (window as any).webkitAudioContext)()
+        buffer = await ctx.decodeAudioData(audioData)
+
+        logger?.debug('Decoded audio buffer:', {
+            originalChannels: buffer.numberOfChannels,
+            originalSampleRate: buffer.sampleRate,
+            originalDuration: buffer.duration,
+            originalLength: buffer.length,
+        })
+
+        // Calculate time range
+        const startSample =
+            startTimeMs !== undefined
+                ? Math.floor((startTimeMs / 1000) * buffer.sampleRate)
+                : position !== undefined
+                  ? Math.floor(position / 2)
+                  : 0
+
+        // Fix: Adjust position calculation based on original sample rate
+        // When position is provided in bytes, we need to account for the original sample rate
+        const bytesPerSample = 2 // 16-bit audio = 2 bytes per sample
+        const adjustedStartSample =
+            position !== undefined
+                ? Math.floor(
+                      (position / bytesPerSample) *
+                          (buffer.sampleRate / targetSampleRate)
+                  )
+                : startSample
+
+        const samplesNeeded =
+            length !== undefined
+                ? Math.floor(
+                      (length / bytesPerSample) *
+                          (buffer.sampleRate / targetSampleRate)
+                  )
+                : endTimeMs !== undefined && startTimeMs !== undefined
+                  ? Math.floor(
+                        ((endTimeMs - startTimeMs) / 1000) * buffer.sampleRate
+                    )
+                  : buffer.length - adjustedStartSample
+
+        logger?.debug('Sample calculations (adjusted):', {
+            originalStartSample: startSample,
+            adjustedStartSample,
+            samplesNeeded,
+            originalSampleRate: buffer.sampleRate,
+            targetSampleRate,
+            conversionRatio: buffer.sampleRate / targetSampleRate,
+            expectedDurationMs: (samplesNeeded / buffer.sampleRate) * 1000,
+        })
+
+        // Create temporary buffer for the segment
+        const segmentBuffer = ctx.createBuffer(
+            buffer.numberOfChannels,
+            samplesNeeded,
+            buffer.sampleRate
+        )
+
+        // Copy the segment
+        for (let channel = 0; channel < buffer.numberOfChannels; channel++) {
+            const channelData = buffer.getChannelData(channel)
+            const segmentData = segmentBuffer.getChannelData(channel)
+            for (let i = 0; i < samplesNeeded; i++) {
+                segmentData[i] = channelData[adjustedStartSample + i]
+            }
+        }
+
+        // Create offline context for resampling
+        const offlineCtx = new OfflineAudioContext(
+            targetChannels,
+            Math.ceil((samplesNeeded * targetSampleRate) / buffer.sampleRate),
+            targetSampleRate
+        )
+
+        // Create source and connect
+        const source = offlineCtx.createBufferSource()
+        source.buffer = segmentBuffer
+        source.connect(offlineCtx.destination)
+
+        // Render at new sample rate
+        source.start()
+        const processedBuffer = await offlineCtx.startRendering()
+
+        // Get the final audio data
+        const channelData = processedBuffer.getChannelData(0)
+        const durationMs = Math.round(
+            (samplesNeeded / buffer.sampleRate) * 1000
+        )
+
+        logger?.debug('Final processed audio:', {
+            outputSamples: channelData.length,
+            outputSampleRate: targetSampleRate,
+            durationMs,
+        })
+
+        return {
+            buffer: processedBuffer,
+            channelData,
+            samples: channelData.length,
+            durationMs,
+            sampleRate: targetSampleRate,
+            channels: processedBuffer.numberOfChannels,
+        }
+    } catch (error) {
+        logger?.error('Failed to process audio buffer:', {
+            error,
+            position,
+            length,
+            startTimeMs,
+            endTimeMs,
+            bufferLength: buffer?.length,
+        })
+        throw error
+    } finally {
+        if (!audioContext && ctx) {
+            await ctx.close()
+        }
+    }
+}

package/src/utils/cleanNativeOptions.ts

@@ -0,0 +1,18 @@
+/**
+ * Strips non-serializable values (functions, ArrayBuffer, undefined) from
+ * option objects before passing them to Expo native modules.
+ *
+ * Android's Kotlin bridge crashes with "Cannot convert '[object Object]' to a
+ * Kotlin type" when it receives non-plain values such as `logger`, `ArrayBuffer`,
+ * or `undefined` fields.  The JSON round-trip removes all of these safely.
+ *
+ * Only use this for small config objects (never for large audio buffers).
+ *
+ * NOTE: structuredClone() is intentionally NOT used here — it preserves
+ * undefined values and non-JSON types, which is exactly what we need to strip.
+ */
+export function cleanNativeOptions<T>(options: T): T {
+    // NOSONAR: JSON round-trip is deliberate — it strips undefined, functions,
+    // and non-serializable values that structuredClone would preserve.
+    return JSON.parse(JSON.stringify(options)) // NOSONAR
+}

package/src/utils/concatenateBuffers.ts

@@ -0,0 +1,24 @@
+/**
+ * Concatenates an array of ArrayBuffers into a single ArrayBuffer.
+ *
+ * @param buffers - An array of ArrayBuffers to be concatenated.
+ * @returns A single ArrayBuffer containing the concatenated data.
+ */
+export const concatenateBuffers = (buffers: ArrayBuffer[]): ArrayBuffer => {
+    // Filter out any undefined or null buffers
+    const validBuffers = buffers.filter((buffer) => buffer)
+    const totalLength = validBuffers.reduce(
+        (sum, buffer) => sum + buffer.byteLength,
+        0
+    )
+    // Create a new Uint8Array to hold the concatenated result
+    const result = new Uint8Array(totalLength)
+    // Offset to keep track of the current position in the result array
+    let offset = 0
+
+    for (const buffer of validBuffers) {
+        result.set(new Uint8Array(buffer), offset)
+        offset += buffer.byteLength
+    }
+    return result.buffer
+}

package/src/utils/convertPCMToFloat32.ts

@@ -0,0 +1,170 @@
+import { Platform } from 'react-native'
+
+import { ConsoleLike } from '../AudioStudio.types'
+import { getWavFileInfo, WavFileInfo } from './getWavFileInfo'
+
+export const WAV_HEADER_SIZE = 44
+
+const convertSample = (
+    dataView: DataView,
+    offset: number,
+    bitDepth: number
+): number => {
+    switch (bitDepth) {
+        case 8:
+            return (dataView.getUint8(offset) - 128) / 128
+        case 16:
+            return dataView.getInt16(offset, true) / 32768
+        case 24:
+            return (
+                ((dataView.getUint8(offset) |
+                    (dataView.getUint8(offset + 1) << 8) |
+                    (dataView.getUint8(offset + 2) << 16)) /
+                    8388608) *
+                    2 -
+                1
+            )
+        case 32:
+            return dataView.getFloat32(offset, true)
+        default:
+            throw new Error(`Unsupported bit depth: ${bitDepth}`)
+    }
+}
+
+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,
+    skipWavHeader = false,
+    logger,
+}: {
+    buffer: ArrayBuffer
+    bitDepth: number
+    skipWavHeader?: boolean
+    logger?: ConsoleLike
+}): Promise<{ pcmValues: Float32Array; min: number; max: number }> => {
+    try {
+        logger?.debug(
+            `Converting PCM to Float32: bitDepth: ${bitDepth}, buffer.byteLength: ${buffer.byteLength}`
+        )
+
+        let headerOffset = 0
+        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 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
+
+        // 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 (isFinite(value)) {
+                        float32Array[i] = value
+                        min = Math.min(min, value)
+                        max = Math.max(max, value)
+                    }
+                }
+            }
+
+            // Allow garbage collection between chunks on native
+            if (Platform.OS !== 'web' && chunk < numChunks - 1) {
+                await new Promise((resolve) => setTimeout(resolve, 0))
+            }
+        }
+
+        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)
+        throw error
+    }
+}

package/src/utils/crc32.ts

@@ -0,0 +1,59 @@
+// Bundler (Metro/Webpack) will automatically resolve to crc32.web.ts or crc32.native.ts.
+
+import { Platform } from 'react-native'
+
+// Define the interface first
+export interface CRC32 {
+    (data: string | Uint8Array): number
+    buf(data: Uint8Array): number
+}
+
+// --- Web CRC32 Calculation Logic ---
+let webCrcTable: Uint32Array | undefined
+function computeWebCrc32(data: string | Uint8Array): number {
+    // Lazily compute the table only on web when first needed
+    if (!webCrcTable) {
+        webCrcTable = (() => {
+            const table = new Uint32Array(256)
+            for (let i = 0; i < 256; ++i) {
+                let crc = i
+                for (let j = 0; j < 8; ++j) {
+                    crc = crc & 1 ? (crc >>> 1) ^ 0xedb88320 : crc >>> 1
+                }
+                table[i] = crc
+            }
+            return table
+        })()
+    }
+
+    let crc = -1 // Initialize with 0xFFFFFFFF
+    if (typeof data === 'string') {
+        const strBytes = new TextEncoder().encode(data)
+        for (let i = 0; i < strBytes.length; ++i) {
+            crc = (crc >>> 8) ^ webCrcTable[(crc ^ strBytes[i]) & 0xff]
+        }
+    } else if (data instanceof Uint8Array) {
+        for (let i = 0; i < data.length; ++i) {
+            crc = (crc >>> 8) ^ webCrcTable[(crc ^ data[i]) & 0xff]
+        }
+    } else {
+        throw new Error('Unsupported data type for CRC32 calculation.')
+    }
+
+    return (crc ^ -1) >>> 0 // Final XOR and ensure unsigned 32-bit
+}
+// --- End Web CRC32 Calculation Logic ---
+
+let crc32Implementation: CRC32
+
+if (Platform.OS === 'web') {
+    // Assign the web implementation
+    crc32Implementation = Object.assign(computeWebCrc32, {
+        buf: (data: Uint8Array): number => computeWebCrc32(data),
+    })
+} else {
+    // No-op implementation for native platforms
+    crc32Implementation = Object.assign(() => 0, { buf: () => 0 })
+}
+
+export default crc32Implementation

package/src/utils/encodingToBitDepth.ts

@@ -0,0 +1,18 @@
+import { BitDepth, EncodingType } from '../AudioStudio.types'
+
+export const encodingToBitDepth = ({
+    encoding,
+}: {
+    encoding: EncodingType
+}): BitDepth => {
+    switch (encoding) {
+        case 'pcm_32bit':
+            return 32
+        case 'pcm_16bit':
+            return 16
+        case 'pcm_8bit':
+            return 8
+        default:
+            throw new Error(`Unsupported encoding type: ${encoding}`)
+    }
+}

package/src/utils/getWavFileInfo.ts

@@ -0,0 +1,132 @@
+// packages/audio-studio/src/utils/getWavFileInfo.ts
+
+import { BitDepth, SampleRate } from '../AudioStudio.types'
+import {
+    DATA_CHUNK_ID,
+    DEFAULT_BIT_DEPTH,
+    DEFAULT_SAMPLE_RATE,
+    FMT_CHUNK_ID,
+    INFO_CHUNK_ID,
+    RIFF_HEADER,
+    WAVE_HEADER,
+} from '../constants'
+
+// Audio format descriptions
+const AUDIO_FORMATS: { [key: number]: string } = {
+    1: 'PCM',
+    3: 'IEEE float',
+    6: '8-bit ITU-T G.711 A-law',
+    7: '8-bit ITU-T G.711 µ-law',
+    65534: 'WAVE_FORMAT_EXTENSIBLE',
+}
+
+/**
+ * Interface representing the metadata of a WAV file.
+ */
+export interface WavFileInfo {
+    sampleRate: SampleRate
+    numChannels: number
+    bitDepth: BitDepth
+    size: number // in bytes
+    durationMs: number // in ms
+    audioFormatDescription: string // Description of the audio format
+    byteRate: number // Average bytes per second
+    blockAlign: number // Number of bytes for one sample including all channels
+    creationDateTime?: string // Optional creation date and time
+    comments?: string // Optional comments or tags
+    compressionType?: string // Optional compression type
+    dataChunkOffset: number // Position of the first data chunk
+}
+
+/**
+ * Extracts metadata from a WAV buffer.
+ *
+ * @param arrayBuffer - The array buffer containing the WAV data.
+ * @returns A promise that resolves to the extracted metadata.
+ */
+export const getWavFileInfo = async (
+    arrayBuffer: ArrayBuffer
+): Promise<WavFileInfo> => {
+    const view = new DataView(arrayBuffer)
+
+    // Check if the file is a valid RIFF/WAVE file
+    const riffHeader = view.getUint32(0, false)
+    const waveHeader = view.getUint32(8, false)
+    if (riffHeader !== RIFF_HEADER || waveHeader !== WAVE_HEADER) {
+        throw new Error('Invalid WAV file')
+    }
+
+    // Initialize variables for the metadata
+    let fmtChunkOffset = 12
+    let sampleRate: SampleRate = DEFAULT_SAMPLE_RATE
+    let numChannels = 0
+    let bitDepth: BitDepth = DEFAULT_BIT_DEPTH
+    let dataChunkSize = 0
+    let audioFormat = 0
+    let byteRate = 0
+    let blockAlign = 0
+    let creationDateTime = ''
+    let comments = ''
+    let dataChunkOffset = 0
+
+    // Parse chunks to find the "fmt " and "data" chunks
+    while (fmtChunkOffset < view.byteLength) {
+        const chunkId = view.getUint32(fmtChunkOffset, false)
+        const chunkSize = view.getUint32(fmtChunkOffset + 4, true)
+        if (chunkId === FMT_CHUNK_ID) {
+            // "fmt "
+            audioFormat = view.getUint16(fmtChunkOffset + 8, true)
+            if (!AUDIO_FORMATS[audioFormat]) {
+                throw new Error('Unsupported WAV file format')
+            }
+            numChannels = view.getUint16(fmtChunkOffset + 10, true)
+            sampleRate = view.getUint32(fmtChunkOffset + 12, true) as SampleRate
+            byteRate = view.getUint32(fmtChunkOffset + 16, true)
+            blockAlign = view.getUint16(fmtChunkOffset + 20, true)
+            bitDepth = view.getUint16(fmtChunkOffset + 22, true) as BitDepth
+        } else if (chunkId === DATA_CHUNK_ID) {
+            // "data"
+            dataChunkSize = chunkSize
+            dataChunkOffset = fmtChunkOffset + 8 // Position after chunk header
+            break
+        } else if (chunkId === INFO_CHUNK_ID) {
+            // "INFO"
+            // Read INFO chunk (assuming it contains a text-based creation date/time and comments)
+            const infoStart = fmtChunkOffset + 8
+            const infoText = new TextDecoder().decode(
+                new Uint8Array(
+                    arrayBuffer.slice(infoStart, infoStart + chunkSize)
+                )
+            )
+            const infoParts = infoText.split('\0')
+            creationDateTime = infoParts[0]
+            comments = infoParts[1]
+        }
+        fmtChunkOffset += 8 + chunkSize
+    }
+
+    if (!sampleRate || !numChannels || !bitDepth || !dataChunkSize) {
+        throw new Error('Incomplete WAV file information')
+    }
+
+    // Calculate duration
+    const bytesPerSample = bitDepth / 8
+    const numSamples = dataChunkSize / (numChannels * bytesPerSample)
+    const durationMs = (numSamples / sampleRate) * 1000
+
+    return {
+        sampleRate,
+        numChannels,
+        bitDepth,
+        size: arrayBuffer.byteLength,
+        durationMs,
+        audioFormatDescription: AUDIO_FORMATS[audioFormat],
+        byteRate,
+        blockAlign,
+        creationDateTime: creationDateTime || undefined,
+        comments: comments || undefined,
+        compressionType:
+            audioFormat === 1 ? 'None' : AUDIO_FORMATS[audioFormat],
+        dataChunkOffset,
+    }
+}