whisper.rn 0.5.0-rc.1 → 0.5.0-rc.2

package/src/utils/WavFileReader.ts

@@ -0,0 +1,202 @@
+import { base64ToUint8Array } from './common'
+
+export interface WavFileReaderFs {
+  readFile: (filePath: string, encoding: string) => Promise<string>
+  exists: (filePath: string) => Promise<boolean>
+  unlink: (filePath: string) => Promise<void>
+}
+
+export interface WavFileHeader {
+  sampleRate: number
+  channels: number
+  bitsPerSample: number
+  dataSize: number
+  duration: number
+}
+
+export class WavFileReader {
+  private filePath: string
+
+  private header: WavFileHeader | null = null
+
+  private audioData: Uint8Array | null = null
+
+  private fs: {
+    exists: (filePath: string) => Promise<boolean>
+    readFile: (filePath: string, encoding: string) => Promise<string>
+  }
+
+  constructor(fs: {
+    exists: (filePath: string) => Promise<boolean>
+    readFile: (filePath: string, encoding: string) => Promise<string>
+  }, filePath: string) {
+    this.fs = fs
+    this.filePath = filePath
+  }
+
+  /**
+   * Read and parse the WAV file
+   */
+  async initialize(): Promise<void> {
+    try {
+      // Check if file exists
+      const exists = await this.fs.exists(this.filePath)
+      if (!exists) {
+        throw new Error(`WAV file not found: ${this.filePath}`)
+      }
+
+      // Read the entire file
+      const fileContent = await this.fs.readFile(this.filePath, 'base64')
+      const fileData = base64ToUint8Array(fileContent)
+
+      // Parse WAV header
+      this.header = WavFileReader.parseWavHeader(fileData)
+
+      // Extract audio data (skip the 44-byte header)
+      this.audioData = fileData.slice(44, 44 + this.header.dataSize)
+
+      console.log(
+        `WAV file loaded: ${this.header.duration.toFixed(2)}s, ${
+          this.header.sampleRate
+        }Hz, ${this.header.channels}ch`,
+      )
+    } catch (error) {
+      throw new Error(`Failed to initialize WAV file reader: ${error}`)
+    }
+  }
+
+  /**
+   * Parse WAV file header
+   */
+  private static parseWavHeader(data: Uint8Array): WavFileHeader {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength)
+
+    // Verify RIFF header
+    const riffHeader = String.fromCharCode(...data.slice(0, 4))
+    if (riffHeader !== 'RIFF') {
+      throw new Error('Invalid WAV file: Missing RIFF header')
+    }
+
+    // Verify WAVE format
+    const waveHeader = String.fromCharCode(...data.slice(8, 12))
+    if (waveHeader !== 'WAVE') {
+      throw new Error('Invalid WAV file: Missing WAVE header')
+    }
+
+    // Read format chunk
+    const fmtHeader = String.fromCharCode(...data.slice(12, 16))
+    if (fmtHeader !== 'fmt ') {
+      throw new Error('Invalid WAV file: Missing fmt chunk')
+    }
+
+    const audioFormat = view.getUint16(20, true)
+    if (audioFormat !== 1) {
+      throw new Error('Unsupported WAV format: Only PCM is supported')
+    }
+
+    const channels = view.getUint16(22, true)
+    const sampleRate = view.getUint32(24, true)
+    const bitsPerSample = view.getUint16(34, true)
+
+    // Find data chunk
+    let dataOffset = 36
+    while (dataOffset < data.length - 8) {
+      const chunkId = String.fromCharCode(
+        ...data.slice(dataOffset, dataOffset + 4),
+      )
+      const chunkSize = view.getUint32(dataOffset + 4, true)
+
+      if (chunkId === 'data') {
+        const dataSize = chunkSize
+        const duration =
+          dataSize / (sampleRate * channels * (bitsPerSample / 8))
+
+        return {
+          sampleRate,
+          channels,
+          bitsPerSample,
+          dataSize,
+          duration,
+        }
+      }
+
+      dataOffset += 8 + chunkSize
+    }
+
+    throw new Error('Invalid WAV file: Missing data chunk')
+  }
+
+  /**
+   * Get audio data slice
+   */
+  getAudioSlice(startByte: number, lengthBytes: number): Uint8Array | null {
+    if (!this.audioData) {
+      return null
+    }
+
+    const start = Math.max(0, startByte)
+    const end = Math.min(this.audioData.length, startByte + lengthBytes)
+
+    if (start >= end) {
+      return null
+    }
+
+    return this.audioData.slice(start, end)
+  }
+
+  getAudioData(): Uint8Array | null {
+    return this.audioData
+  }
+
+  /**
+   * Get WAV file header information
+   */
+  getHeader(): WavFileHeader | null {
+    return this.header
+  }
+
+  /**
+   * Get total audio data size
+   */
+  getTotalDataSize(): number {
+    return this.header?.dataSize || 0
+  }
+
+  /**
+   * Convert byte position to time in seconds
+   */
+  byteToTime(bytePosition: number): number {
+    if (!this.header) return 0
+
+    const bytesPerSecond =
+      this.header.sampleRate *
+      this.header.channels *
+      (this.header.bitsPerSample / 8)
+    return bytePosition / bytesPerSecond
+  }
+
+  /**
+   * Convert time in seconds to byte position
+   */
+  timeToByte(timeSeconds: number): number {
+    if (!this.header) return 0
+
+    const bytesPerSecond =
+      this.header.sampleRate *
+      this.header.channels *
+      (this.header.bitsPerSample / 8)
+    return Math.floor(timeSeconds * bytesPerSecond)
+  }
+
+  /**
+   * Get file statistics
+   */
+  getStatistics() {
+    return {
+      filePath: this.filePath,
+      header: this.header,
+      totalDataSize: this.getTotalDataSize(),
+      isInitialized: !!this.header,
+    }
+  }
+}

package/src/utils/WavFileWriter.ts

@@ -0,0 +1,206 @@
+import { base64ToUint8Array, uint8ArrayToBase64 } from './common'
+
+export interface WavFileConfig {
+  sampleRate: number
+  channels: number
+  bitsPerSample: number
+}
+
+export interface WavFileWriterFs {
+  writeFile: (filePath: string, data: string, encoding: string) => Promise<void>
+  appendFile: (filePath: string, data: string, encoding: string) => Promise<void>
+  readFile: (filePath: string, encoding: string) => Promise<string>
+  exists: (filePath: string) => Promise<boolean>
+  unlink: (filePath: string) => Promise<void>
+}
+
+export class WavFileWriter {
+  private fs: WavFileWriterFs
+
+  private filePath: string
+
+  private config: WavFileConfig
+
+  private dataSize = 0
+
+  private isWriting = false
+
+  private writeQueue: Uint8Array[] = []
+
+  constructor(fs: WavFileWriterFs, filePath: string, config: WavFileConfig) {
+    this.fs = fs
+    this.filePath = filePath
+    this.config = config
+  }
+
+  /**
+   * Initialize the WAV file with headers
+   */
+  async initialize(): Promise<void> {
+    if (this.isWriting) {
+      return
+    }
+
+    try {
+      // Create the initial WAV header (we'll update the size later)
+      const header = this.createWavHeader(0)
+      await this.fs.writeFile(this.filePath, uint8ArrayToBase64(header), 'base64')
+
+      this.dataSize = 0
+      this.isWriting = true
+      this.writeQueue = []
+    } catch (error) {
+      throw new Error(`Failed to initialize WAV file: ${error}`)
+    }
+  }
+
+  /**
+   * Append PCM audio data to the WAV file
+   */
+  async appendAudioData(audioData: Uint8Array): Promise<void> {
+    if (!this.isWriting) {
+      throw new Error('WAV file not initialized')
+    }
+
+    try {
+      // Queue the data for writing
+      this.writeQueue.push(audioData)
+
+      // Process the write queue
+      await this.processWriteQueue()
+    } catch (error) {
+      console.warn(`Failed to append audio data to WAV file: ${error}`)
+    }
+  }
+
+  /**
+   * Process the write queue to avoid blocking
+   */
+  private async processWriteQueue(): Promise<void> {
+    if (this.writeQueue.length === 0) {
+      return
+    }
+
+    try {
+      // Combine all queued data
+      const totalLength = this.writeQueue.reduce((sum, data) => sum + data.length, 0)
+      const combinedData = new Uint8Array(totalLength)
+
+      let offset = 0
+      this.writeQueue.forEach(data => {
+        combinedData.set(new Uint8Array(data), offset)
+        offset += data.length
+      })
+
+      // Append to file
+      const base64Data = uint8ArrayToBase64(combinedData)
+      await this.fs.appendFile(this.filePath, base64Data, 'base64')
+
+      // Update data size
+      this.dataSize += combinedData.length
+
+      // Clear the queue
+      this.writeQueue = []
+    } catch (error) {
+      console.warn(`Failed to process WAV write queue: ${error}`)
+      // Don't throw here to avoid breaking the recording
+    }
+  }
+
+  /**
+   * Finalize the WAV file by updating the header with correct sizes
+   */
+  async finalize(): Promise<void> {
+    if (!this.isWriting) {
+      return
+    }
+
+    try {
+      // Process any remaining queued data
+      await this.processWriteQueue()
+
+      // Read the current file
+      const currentData = await this.fs.readFile(this.filePath, 'base64')
+      const currentBytes = base64ToUint8Array(currentData)
+
+      // Create the correct header with final data size
+      const correctHeader = this.createWavHeader(this.dataSize)
+
+      // Replace the header (first 44 bytes)
+      const finalData = new Uint8Array(correctHeader.length + this.dataSize)
+      finalData.set(correctHeader, 0)
+      finalData.set(currentBytes.slice(44), 44) // Skip old header
+
+      // Write the final file
+      const finalBase64 = uint8ArrayToBase64(finalData)
+      await this.fs.writeFile(this.filePath, finalBase64, 'base64')
+
+      this.isWriting = false
+    } catch (error) {
+      console.warn(`Failed to finalize WAV file: ${error}`)
+    }
+  }
+
+  /**
+   * Create WAV file header
+   */
+  private createWavHeader(dataSize: number): Uint8Array {
+    const header = new ArrayBuffer(44)
+    const view = new DataView(header)
+
+    // RIFF header
+    view.setUint32(0, 0x52494646, false) // "RIFF"
+    view.setUint32(4, 36 + dataSize, true) // File size - 8
+    view.setUint32(8, 0x57415645, false) // "WAVE"
+
+    // Format chunk
+    view.setUint32(12, 0x666d7420, false) // "fmt "
+    view.setUint32(16, 16, true) // Chunk size
+    view.setUint16(20, 1, true) // Audio format (PCM)
+    view.setUint16(22, this.config.channels, true) // Number of channels
+    view.setUint32(24, this.config.sampleRate, true) // Sample rate
+    view.setUint32(28, this.config.sampleRate * this.config.channels * (this.config.bitsPerSample / 8), true) // Byte rate
+    view.setUint16(32, this.config.channels * (this.config.bitsPerSample / 8), true) // Block align
+    view.setUint16(34, this.config.bitsPerSample, true) // Bits per sample
+
+    // Data chunk
+    view.setUint32(36, 0x64617461, false) // "data"
+    view.setUint32(40, dataSize, true) // Data size
+
+    return new Uint8Array(header)
+  }
+
+  /**
+   * Cancel writing and cleanup
+   */
+  async cancel(): Promise<void> {
+    this.isWriting = false
+    this.writeQueue = []
+
+    try {
+      // Delete the incomplete file
+      const exists = await this.fs.exists(this.filePath)
+      if (exists) {
+        await this.fs.unlink(this.filePath)
+      }
+    } catch (error) {
+      console.warn(`Failed to cleanup WAV file: ${error}`)
+    }
+  }
+
+  /**
+   * Get current file statistics
+   */
+  getStatistics() {
+    const durationSec = this.dataSize / (this.config.sampleRate * this.config.channels * (this.config.bitsPerSample / 8))
+
+    return {
+      filePath: this.filePath,
+      dataSize: this.dataSize,
+      durationSec,
+      isWriting: this.isWriting,
+      queuedChunks: this.writeQueue.length,
+      estimatedFileSizeMB: (44 + this.dataSize) / (1024 * 1024),
+    }
+  }
+}

package/src/utils/common.ts

@@ -0,0 +1,17 @@
+const Buffer: any = global.Buffer || require('safe-buffer').Buffer
+
+/**
+ * Convert base64 string to Uint8Array
+ */
+export function base64ToUint8Array(base64: string): Uint8Array {
+  const buffer = Buffer.from(base64, 'base64')
+  return new Uint8Array(buffer)
+}
+
+/**
+ * Convert Uint8Array to base64 string
+ */
+export function uint8ArrayToBase64(buffer: Uint8Array): string {
+  const buf = Buffer.from(buffer)
+  return buf.toString('base64')
+}