@siteed/expo-audio-stream 2.1.0 → 2.2.0

package/src/utils/audioProcessing.ts

@@ -1,205 +0,0 @@
-// packages/expo-audio-stream/src/utils/audioProcessing.ts
-import { Platform } from 'react-native'
-
-import { ConsoleLike } from '../ExpoAudioStream.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/concatenateBuffers.ts

@@ -1,24 +0,0 @@
-/**
- * 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

@@ -1,170 +0,0 @@
-import { Platform } from 'react-native'
-
-import { ConsoleLike } from '../ExpoAudioStream.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/encodingToBitDepth.ts

@@ -1,18 +0,0 @@
-import { BitDepth, EncodingType } from '../ExpoAudioStream.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

@@ -1,132 +0,0 @@
-// packages/expo-audio-stream/src/utils/getWavFileInfo.ts
-
-import { BitDepth, SampleRate } from '../ExpoAudioStream.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,
-    }
-}

package/src/utils/writeWavHeader.ts

@@ -1,114 +0,0 @@
-// packages/expo-audio-stream/src/utils/writeWavHeader.ts
-
-/**
- * Options for creating a WAV header.
- */
-export interface WavHeaderOptions {
-    /** Optional buffer containing audio data. If provided, it will be combined with the header. */
-    buffer?: ArrayBuffer
-    /** The sample rate of the audio in Hz (e.g., 44100). */
-    sampleRate: number
-    /** The number of audio channels (e.g., 1 for mono, 2 for stereo). */
-    numChannels: number
-    /** The bit depth of the audio (e.g., 16, 24, or 32). */
-    bitDepth: number
-}
-
-/**
- * Writes or updates a WAV (RIFF) header based on the provided options.
- *
- * This function can be used in three ways:
- * 1. To create a standalone WAV header (when no buffer is provided).
- * 2. To create a WAV header and combine it with existing audio data (when a buffer without a header is provided).
- * 3. To update an existing WAV header in the provided buffer.
- *
- * For streaming audio where the final size is unknown, this function sets the size fields
- * to the maximum 32-bit value (0xFFFFFFFF). These can be updated later using the
- * `updateWavHeaderSize` function once the final size is known.
- *
- * @param options - The options for creating or updating the WAV header.
- * @returns An ArrayBuffer containing the WAV header, or the header combined with the provided audio data.
- *
- * @throws {Error} Throws an error if the provided options are invalid or if the buffer is too small.
- *
- * @example
- * // Create a standalone WAV header
- * const header = writeWavHeader({
- *   sampleRate: 44100,
- *   numChannels: 2,
- *   bitDepth: 16
- * });
- *
- * @example
- * // Create a WAV header and combine it with audio data
- * const completeWav = writeWavHeader({
- *   buffer: audioData,
- *   sampleRate: 44100,
- *   numChannels: 2,
- *   bitDepth: 16
- * });
- */
-export const writeWavHeader = ({
-    buffer,
-    sampleRate,
-    numChannels,
-    bitDepth,
-}: WavHeaderOptions): ArrayBuffer => {
-    const bytesPerSample = bitDepth / 8
-    const blockAlign = numChannels * bytesPerSample
-    const byteRate = sampleRate * blockAlign
-
-    // Function to write a string to the DataView
-    const writeString = (view: DataView, offset: number, string: string) => {
-        for (let i = 0; i < string.length; i++) {
-            view.setUint8(offset + i, string.charCodeAt(i))
-        }
-    }
-
-    // Function to write or update the header
-    const writeHeader = (view: DataView, dataSize: number = 0xffffffff) => {
-        writeString(view, 0, 'RIFF') // ChunkID
-        view.setUint32(4, 36 + dataSize, true) // ChunkSize
-        writeString(view, 8, 'WAVE') // Format
-        writeString(view, 12, 'fmt ') // Subchunk1ID
-        view.setUint32(16, 16, true) // Subchunk1Size (16 for PCM)
-        view.setUint16(20, bitDepth === 32 ? 3 : 1, true) // AudioFormat (3 for float, 1 for PCM)
-        view.setUint16(22, numChannels, true) // NumChannels
-        view.setUint32(24, sampleRate, true) // SampleRate
-        view.setUint32(28, byteRate, true) // ByteRate
-        view.setUint16(32, blockAlign, true) // BlockAlign
-        view.setUint16(34, bitDepth, true) // BitsPerSample
-        writeString(view, 36, 'data') // Subchunk2ID
-        view.setUint32(40, dataSize, true) // Subchunk2Size
-    }
-
-    if (buffer) {
-        if (buffer.byteLength < 44) {
-            throw new Error('Buffer is too small to contain a valid WAV header')
-        }
-
-        const view = new DataView(buffer)
-
-        // Check if the buffer already has a WAV header by looking for "RIFF" at the start
-        const existingHeader = view.getUint32(0, false) === 0x52494646 // "RIFF" in ASCII
-
-        if (existingHeader) {
-            // Update the existing header
-            writeHeader(view, buffer.byteLength - 44)
-            return buffer
-        } else {
-            // Combine the new header with the existing buffer
-            const newBuffer = new ArrayBuffer(44 + buffer.byteLength)
-            const newView = new DataView(newBuffer)
-            writeHeader(newView, buffer.byteLength)
-            new Uint8Array(newBuffer).set(new Uint8Array(buffer), 44)
-            return newBuffer
-        }
-    } else {
-        // Create a standalone header
-        const headerBuffer = new ArrayBuffer(44)
-        const view = new DataView(headerBuffer)
-        writeHeader(view)
-        return headerBuffer
-    }
-}