@siteed/expo-audio-stream 1.0.3 → 1.1.1

package/src/utils/convertPCMToFloat32.ts

@@ -1,48 +1,75 @@
-export const WAV_HEADER_SIZE = 44;
-export const convertPCMToFloat32 = ({
-  bitDepth,
-  buffer,
-  skipWavHeader = false,
-}: {
-  buffer: ArrayBuffer;
-  bitDepth: number;
-  skipWavHeader?: boolean;
-}): { pcmValues: Float32Array; min: number; max: number } => {
-  const dataView = new DataView(buffer);
-  const headerOffset = skipWavHeader ? WAV_HEADER_SIZE : 0;
-  const dataLength = buffer.byteLength - headerOffset;
-  const sampleLength = dataLength / (bitDepth / 8);
-  const float32Array = new Float32Array(sampleLength);
-  let min = Infinity;
-  let max = -Infinity;
-
-  for (let i = 0; i < sampleLength; i++) {
-    let value = 0;
-    const offset = headerOffset + i * (bitDepth / 8);
+import { getWavFileInfo, WavFileInfo } from './getWavFileInfo'
+import { getLogger } from '../logger'
+
+export const WAV_HEADER_SIZE = 44
+
+const logger = getLogger('convertPCMToFloat32')
+
+const convertSample = (
+    dataView: DataView,
+    offset: number,
+    bitDepth: number
+): number => {
     switch (bitDepth) {
-      case 8:
-        value = dataView.getUint8(offset) / 128;
-        break;
-      case 16:
-        value = dataView.getInt16(offset, true) / 32768;
-        break;
-      case 24:
-        value =
-          (dataView.getUint8(offset) +
-            (dataView.getUint8(offset + 1) << 8) +
-            (dataView.getUint8(offset + 2) << 16)) /
-          8388608;
-        break;
-      case 32:
-        value = dataView.getFloat32(offset, true);
-        break;
-      default:
-        throw new Error(`Unsupported bit depth: ${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}`)
     }
-    if (value < min) min = value;
-    if (value > max) max = value;
-    float32Array[i] = value;
-  }
+}
+
+export const convertPCMToFloat32 = async ({
+    bitDepth,
+    buffer,
+    skipWavHeader = false,
+}: {
+    buffer: ArrayBuffer
+    bitDepth: number
+    skipWavHeader?: boolean
+}): Promise<{ pcmValues: Float32Array; min: number; max: number }> => {
+    try {
+        logger.debug(
+            `Converting PCM to Float32: bitDepth: ${bitDepth}, buffer.byteLength: ${buffer.byteLength}`
+        )
+        const dataView = new DataView(buffer)
+        let headerOffset = 0
+        if (skipWavHeader) {
+            const wavFileInfo: WavFileInfo = await getWavFileInfo(buffer)
+            headerOffset = wavFileInfo.dataChunkOffset
+        }
 
-  return { pcmValues: float32Array, min, max };
-};
+        const dataLength = buffer.byteLength - headerOffset
+        const sampleLength = Math.floor(dataLength / (bitDepth / 8))
+        const 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)
+
+            if (value < min) min = value
+            if (value > max) max = value
+
+            float32Array[i] = value
+        }
+
+        return { pcmValues: float32Array, min, max }
+    } catch (error: unknown) {
+        logger.error(`Error converting PCM to Float32`, error)
+        return { pcmValues: new Float32Array(), min: 0, max: 0 }
+    }
+}

package/src/utils/encodingToBitDepth.ts

@@ -1,18 +1,18 @@
-import { BitDepth, EncodingType } from "../ExpoAudioStream.types";
+import { BitDepth, EncodingType } from '../ExpoAudioStream.types'
 
 export const encodingToBitDepth = ({
-  encoding,
+    encoding,
 }: {
-  encoding: EncodingType;
+    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}`);
-  }
-};
+    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,125 +1,132 @@
 // packages/expo-audio-stream/src/utils/getWavFileInfo.ts
 
-import { BitDepth, SampleRate } from "../ExpoAudioStream.types";
+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";
+    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",
-};
+    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
+    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 file.
+ * Extracts metadata from a WAV buffer.
  *
- * @param arrayBuffer - The array buffer containing the WAV file data.
+ * @param arrayBuffer - The array buffer containing the WAV data.
  * @returns A promise that resolves to the extracted metadata.
  */
 export const getWavFileInfo = async (
-  arrayBuffer: ArrayBuffer,
+    arrayBuffer: ArrayBuffer
 ): Promise<WavFileInfo> => {
-  const view = new DataView(arrayBuffer);
+    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");
-  }
+    // 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 = "";
+    // 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;
-      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];
+    // 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
     }
-    fmtChunkOffset += 8 + chunkSize;
-  }
 
-  if (!sampleRate || !numChannels || !bitDepth || !dataChunkSize) {
-    throw new Error("Incomplete WAV file information");
-  }
+    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;
+    // 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],
-  };
-};
+    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,56 +1,61 @@
 // packages/expo-audio-stream/src/utils/writeWavHeader.ts
 interface WavHeaderOptions {
-  buffer: ArrayBuffer;
-  sampleRate: number;
-  numChannels: number;
-  bitDepth: number;
+    buffer: ArrayBuffer
+    sampleRate: number
+    numChannels: number
+    bitDepth: number
 }
 
 export const writeWavHeader = ({
-  buffer,
-  sampleRate,
-  numChannels,
-  bitDepth,
+    buffer,
+    sampleRate,
+    numChannels,
+    bitDepth,
 }: WavHeaderOptions): ArrayBuffer => {
-  const bytesPerSample = bitDepth / 8;
-  const numSamples = buffer.byteLength / (numChannels * bytesPerSample);
-  const view = new DataView(buffer);
-  const blockAlign = numChannels * bytesPerSample;
-  const byteRate = sampleRate * blockAlign;
+    const bytesPerSample = bitDepth / 8
+    const numSamples = buffer.byteLength / (numChannels * bytesPerSample)
+    const view = new DataView(buffer)
+    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 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))
+        }
     }
-  };
 
-  // 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
+    // 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) {
-    // Write the WAV header
-    writeString(view, 0, "RIFF"); // ChunkID
-    view.setUint32(4, 36 + numSamples * blockAlign, 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, numSamples * blockAlign, true); // Subchunk2Size
-  } else {
-    // Update the existing WAV header if necessary
-    view.setUint32(4, 36 + numSamples * blockAlign, true); // Update ChunkSize
-    view.setUint32(24, sampleRate, true); // Update SampleRate
-    view.setUint32(28, byteRate, true); // Update ByteRate
-    view.setUint16(32, blockAlign, true); // Update BlockAlign
-    view.setUint32(40, numSamples * blockAlign, true); // Update Subchunk2Size
-  }
+    if (!existingHeader) {
+        // Ensure the buffer is large enough for the WAV header
+        if (buffer.byteLength < 44) {
+            throw new Error('Buffer is too small to contain a valid WAV header')
+        }
 
-  return buffer;
-};
+        // Write the WAV header
+        writeString(view, 0, 'RIFF') // ChunkID
+        view.setUint32(4, 36 + numSamples * blockAlign, 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, numSamples * blockAlign, true) // Subchunk2Size
+    } else {
+        // Update the existing WAV header if necessary
+        view.setUint32(4, 36 + numSamples * blockAlign, true) // Update ChunkSize
+        view.setUint32(24, sampleRate, true) // Update SampleRate
+        view.setUint32(28, byteRate, true) // Update ByteRate
+        view.setUint16(32, blockAlign, true) // Update BlockAlign
+        view.setUint32(40, numSamples * blockAlign, true) // Update Subchunk2Size
+    }
+
+    return buffer
+}