@qvac/decoder-audio 0.2.4 → 0.2.6

package/lib/ffmpeg/channel-port-stream.js

@@ -1,98 +0,0 @@
-'use strict'
-
-const QvacLogger = require('@qvac/logging')
-
-class ChannelPortStream {
-  constructor (channelPort, logger) {
-    this.channelPort = channelPort
-    this.logger = new QvacLogger(logger)
-
-    this.channelEnd = false
-    this.channelClose = false
-
-    this.channelPort.on('end', () => {
-      this.logger.debug('ChannelPortStream Channel port ended')
-      this.channelEnd = true
-    })
-    this.channelPort.on('close', () => {
-      this.logger.debug('ChannelPortStream Channel port closed')
-      this.channelClose = true
-    })
-
-    this.bufferArray = []
-    this.bufferOneOffset = 0
-  }
-
-  portHasData () {
-    const hasData = (this.channelEnd || this.channelClose) && this.channelPort._queue.length
-    return hasData !== 0
-  }
-
-  _readFromChannelPort () {
-    let portHasDataCount = 0
-    while (this.portHasData()) {
-      portHasDataCount++
-      const chunk = this.channelPort.readSync()
-      if (!chunk || chunk.length === 0) {
-        this.logger.debug('Read chunk of length 0 from channelPort')
-        break
-      }
-      this.logger.debug(`Read chunk of length ${chunk.length} from channelPort`)
-      this.bufferArray.push(chunk)
-    }
-    this.logger.debug(`portHasData() loop ran ${portHasDataCount} times, bufferArray.length=${this.bufferArray.length}`)
-  }
-
-  _readFromBufferArray (buffer, len) {
-    let finalLen = 0
-    let bytesCopied = 0
-    if (this.bufferArray.length > 0) {
-      while (finalLen < len) {
-        // Get pending bytes in first buffer
-        const firstBufferPending = this.bufferArray[0].length - this.bufferOneOffset
-
-        // Get bytes to copy in case pending len is less than firstBufferPending
-        const toCopy = Math.min(len - finalLen, firstBufferPending)
-        this.logger.debug(`Copying ${toCopy} bytes from bufferArray[0] (pending: ${firstBufferPending}), bufferOneOffset=${this.bufferOneOffset}, finalLen=${finalLen}`)
-
-        // Copy bytes to buffer
-        bytesCopied += this.bufferArray[0].copy(buffer, finalLen, this.bufferOneOffset, this.bufferOneOffset + toCopy)
-        this.bufferOneOffset += toCopy
-
-        // Shift out buffer if it's empty
-        if (this.bufferOneOffset >= this.bufferArray[0].length) {
-          this.logger.debug('Finished bufferArray[0], shifting it out')
-          this.bufferArray.shift()
-          this.bufferOneOffset = 0
-        }
-
-        // Update finalLen
-        finalLen += toCopy
-
-        // Break inner loop if bufferArray has no more buffers
-        if (this.bufferArray.length === 0) {
-          this.logger.debug('bufferArray is empty, breaking inner loop')
-          break
-        }
-      }
-    } else {
-      this.logger.debug('bufferArray is empty, nothing to copy')
-    }
-
-    this.logger.debug(`_readFromBufferArray bytesCopied=${bytesCopied}`)
-    return finalLen
-  }
-
-  read (buffer, len) {
-    this.logger.debug(`Called with len=${len}`)
-
-    this._readFromChannelPort()
-
-    const finalLen = this._readFromBufferArray(buffer, len)
-
-    this.logger.debug(`Returning finalLen=${finalLen}`)
-    return finalLen
-  }
-}
-
-module.exports = ChannelPortStream

package/lib/ffmpeg/constants.js

@@ -1,23 +0,0 @@
-'use strict'
-
-const FFmpegDecoderMessages = {
-  // Decoder messages
-  INIT: 'init', // Initialization message
-  STREAM_START: 'stream-start', // Start streaming message
-  CLEANUP: 'cleanup' // Cleanup message
-}
-
-const FFmpegWorkerMessages = {
-  // Worker messages
-  READY: 'ready', // Ready message
-  INIT_RESULT: 'init-result', // Initialization result message
-  RESULT_CHUNK: 'result-chunk', // Result chunk message
-  RESULT_END: 'result-end', // End streaming message
-  CLEANUP_DONE: 'cleanup-done', // Cleanup done message
-  ERROR: 'error' // Error message
-}
-
-module.exports = {
-  FFmpegDecoderMessages,
-  FFmpegWorkerMessages
-}

package/lib/ffmpeg/ffmpeg-worker.js

@@ -1,293 +0,0 @@
-'use strict'
-
-const { parentPort } = require('bare-worker')
-const ffmpeg = require('bare-ffmpeg')
-const QvacLogger = require('@qvac/logging')
-const Channel = require('bare-channel')
-const ChannelPortStream = require('./channel-port-stream')
-const { FFmpegDecoderMessages, FFmpegWorkerMessages } = require('./constants')
-
-class FFmpegWorker {
-  SUPPORTED_AUDIO_FORMATS = {
-    s16le: {
-      format: ffmpeg.constants.sampleFormats.S16,
-      byteLength: 2
-    },
-    f32le: {
-      format: ffmpeg.constants.sampleFormats.FLT,
-      byteLength: 4
-    }
-  }
-
-  // Whisper addon expectations
-  OUTPUT_FORMAT_BYTE_LENGTH = 2 // S16LE uses 16 bits = 2 bytes
-  OUTPUT_FORMAT = ffmpeg.constants.sampleFormats.S16
-  OUTPUT_SAMPLE_RATE = 16000
-  OUTPUT_CHANNEL_LAYOUT = ffmpeg.constants.channelLayouts.MONO
-
-  constructor (parentPort, logger = new QvacLogger(console)) {
-    this.parentPort = parentPort
-    this.logger = logger
-
-    this.channel = null
-    this.channelPort = null
-    this.channelPortStream = null
-
-    this.config = null
-    this.totalReadLen = 0
-
-    // Encoder delay handling
-    this.samplesSkipped = 0
-    this.totalSkipSamples = 0
-  }
-
-  sendMessage (type, data) {
-    this.parentPort.postMessage({ type, data })
-  }
-
-  sendResultChunk (data) {
-    this.sendMessage(FFmpegWorkerMessages.RESULT_CHUNK, data)
-  }
-
-  sendEndMessage () {
-    this.logger.debug('[ffmpeg-worker] Sending end message')
-    this.sendMessage(FFmpegWorkerMessages.RESULT_END)
-  }
-
-  initializeDecoder (data) {
-    const { channelHandle, config } = data
-    this.config = config
-
-    if (!this.SUPPORTED_AUDIO_FORMATS[config.audioFormat]) {
-      this.logger.error('[ffmpeg-worker] Unsupported audio format:', config.audioFormat)
-      return { success: false, error: 'Unsupported audio format' }
-    }
-
-    this.OUTPUT_FORMAT = this.SUPPORTED_AUDIO_FORMATS[config.audioFormat].format
-    this.OUTPUT_FORMAT_BYTE_LENGTH = this.SUPPORTED_AUDIO_FORMATS[config.audioFormat].byteLength
-
-    this.logger.info('[ffmpeg-worker] Initializing decoder...')
-    try {
-      this.channel = Channel.from(channelHandle)
-      this.channelPort = this.channel.connect()
-      this.channelPortStream = new ChannelPortStream(this.channelPort, this.logger)
-      return { success: true }
-    } catch (err) {
-      this.logger.error('[ffmpeg-worker] Failed to initialize decoder:', err)
-      return { success: false, error: err.message }
-    }
-  }
-
-  startStream () {
-    this.decodeStream()
-  }
-
-  _processFrame (decoder, raw, resampler) {
-    while (decoder.receiveFrame(raw)) {
-      const output = new ffmpeg.Frame()
-      output.channelLayout = this.OUTPUT_CHANNEL_LAYOUT
-      output.format = this.OUTPUT_FORMAT
-      output.sampleRate = this.OUTPUT_SAMPLE_RATE
-      output.nbSamples = raw.nbSamples
-
-      const samples = new ffmpeg.Samples(
-        output.format,
-        output.channelLayout.nbChannels,
-        output.nbSamples
-      )
-      samples.fill(output)
-
-      // samples.data.length is always fixed, like 8192 bytes. So we need to
-      // extract only the data we need through `subarray`. `resampler.convert`
-      // gives the number of samples converted per channel. So
-      // `bytesPerSample` * `samplesPerChannel` * `channelsPerSample` gives
-      // total amount of bytes.
-      const count = resampler.convert(raw, output)
-
-      // Handle encoder delay by skipping initial samples
-      if (this.samplesSkipped < this.totalSkipSamples) {
-        const samplesToSkip = Math.min(count, this.totalSkipSamples - this.samplesSkipped)
-        this.samplesSkipped += samplesToSkip
-        if (samplesToSkip >= count) continue // Skip entire frame
-
-        // Skip partial frame
-        const skipBytes = this.OUTPUT_FORMAT_BYTE_LENGTH * samplesToSkip * output.channelLayout.nbChannels
-        const length = this.OUTPUT_FORMAT_BYTE_LENGTH * (count - samplesToSkip) * output.channelLayout.nbChannels
-        this.sendResultChunk(Buffer.from(samples.data.subarray(skipBytes, skipBytes + length)))
-      } else {
-        const length = this.OUTPUT_FORMAT_BYTE_LENGTH * count * output.channelLayout.nbChannels
-        this.sendResultChunk(Buffer.from(samples.data.subarray(0, length)))
-      }
-    }
-  }
-
-  _processPacket (format, packet, raw, decoder, resampler) {
-    while (format.readFrame(packet)) {
-      decoder.sendPacket(packet)
-      this._processFrame(decoder, raw, resampler)
-      packet.unref()
-    }
-  }
-
-  _processStream (format, stream) {
-    console.log(stream.codec, stream.codecParameters)
-    const packet = new ffmpeg.Packet()
-    const raw = new ffmpeg.Frame()
-
-    const resampler = new ffmpeg.Resampler(
-      stream.codecParameters.sampleRate,
-      stream.codecParameters.channelLayout,
-      stream.codecParameters.format,
-      this.OUTPUT_SAMPLE_RATE,
-      this.OUTPUT_CHANNEL_LAYOUT,
-      this.OUTPUT_FORMAT
-    )
-
-    const decoder = stream.decoder()
-    decoder.open()
-
-    // Auto-detect encoder delay: lossy codecs need ~400ms skipped to remove artifacts
-    // Lossless codecs (WAV, FLAC) need no skipping
-    const codecName = stream.codec.name.toLowerCase()
-    const SKIP_MS = {
-      mp3: 400,
-      vorbis: 400,
-      opus: 150,
-      aac: 300
-    }
-
-    const skipMs = SKIP_MS[codecName] || 0
-    this.samplesSkipped = 0
-    this.totalSkipSamples = Math.floor((this.OUTPUT_SAMPLE_RATE * skipMs) / 1000)
-
-    if (this.totalSkipSamples > 0) {
-      console.log(`[ffmpeg-worker] Skipping ${skipMs}ms (${this.totalSkipSamples} samples) for ${codecName} to remove encoder artifacts`)
-      this.logger.info(`[ffmpeg-worker] Skipping ${skipMs}ms for ${codecName} to remove encoder artifacts`)
-    }
-
-    this._processPacket(format, packet, raw, decoder, resampler)
-
-    const output = new ffmpeg.Frame()
-    output.channelLayout = this.OUTPUT_CHANNEL_LAYOUT
-    output.format = this.OUTPUT_FORMAT
-    output.sampleRate = this.OUTPUT_SAMPLE_RATE
-    output.nbSamples = 1024
-
-    const samples = new ffmpeg.Samples(
-      output.format,
-      output.channelLayout.nbChannels,
-      output.nbSamples
-    )
-    samples.fill(output)
-
-    while (resampler.flush(output) > 0) {
-      this.sendResultChunk(Buffer.from(samples.data))
-    }
-
-    decoder.destroy()
-    this.sendEndMessage()
-  }
-
-  _getBufferSize (inputBitrate) {
-    const maxBufferSize = 1024 * 1024 // 1MB max
-    return Math.min((inputBitrate / 8) * 4, maxBufferSize)
-  }
-
-  decodeStream () {
-    const {
-      streamIndex = 0,
-      inputBitrate
-    } = this.config
-
-    this.logger.debug('[ffmpeg-worker] Starting deocde with config', this.config)
-
-    if (!this.channelPortStream) {
-      this.logger.error('[ffmpeg-worker] Channel port stream not initialized')
-      return this.sendMessage(FFmpegWorkerMessages.ERROR, { error: 'Channel port stream not initialized' })
-    }
-
-    try {
-      const bufferSize = this._getBufferSize(inputBitrate)
-
-      const io = new ffmpeg.IOContext(bufferSize, {
-        onread: (buffer, requestedLen) => {
-          return this.channelPortStream.read(buffer, requestedLen)
-        }
-      })
-
-      this.logger.debug('[ffmpeg-worker] IOContext created')
-      const format = new ffmpeg.InputFormatContext(io)
-      this.logger.debug('[ffmpeg-worker] InputFormatContext created')
-
-      if (format.streams[streamIndex] === undefined) {
-        this.logger.error('[ffmpeg-worker] Stream index out of bounds')
-        return this.sendMessage(FFmpegWorkerMessages.ERROR, { error: 'Stream index out of bounds' })
-      }
-
-      this._processStream(format, format.streams[streamIndex])
-    } catch (err) {
-      this.logger.error('[ffmpeg-worker] Error during decodeChunk:', err)
-      return this.sendMessage(FFmpegWorkerMessages.ERROR, { error: err.message })
-    }
-  }
-
-  cleanup () {
-    this.logger.info('[ffmpeg-worker] Cleaning up decoder resources...')
-    this.logger.info('[ffmpeg-worker] Cleanup complete')
-    if (this.channelPort) {
-      this.channelPort.close()
-      this.logger.debug('[ffmpeg-worker] Channel port disposed')
-    }
-    if (this.channel) {
-      this.channel = null
-      this.logger.debug('[ffmpeg-worker] Channel disposed')
-    }
-  }
-}
-
-const logger = new QvacLogger()
-const ffmpegWorkerInstance = new FFmpegWorker(parentPort, logger)
-
-// Handle messages from main thread
-parentPort.on('message', ({ type, data }) => {
-  logger.debug(`[ffmpeg-worker] Received message: ${type}`)
-  switch (type) {
-    case FFmpegDecoderMessages.INIT: {
-      logger.info('[ffmpeg-worker] Handling init message with channel handle:', data)
-      const initResult = ffmpegWorkerInstance.initializeDecoder(data)
-      parentPort.postMessage({ type: FFmpegWorkerMessages.INIT_RESULT, ...initResult })
-      break
-    }
-
-    case FFmpegDecoderMessages.STREAM_START: {
-      logger.info('[ffmpeg-worker] Handling decode message')
-      ffmpegWorkerInstance.startStream()
-      break
-    }
-
-    case FFmpegDecoderMessages.CLEANUP: {
-      logger.info('[ffmpeg-worker] Handling cleanup message')
-      ffmpegWorkerInstance.cleanup()
-      parentPort.postMessage({ type: FFmpegWorkerMessages.CLEANUP_DONE, success: true })
-      break
-    }
-
-    default: {
-      logger.warn(`[ffmpeg-worker] Unknown message type: ${type}`)
-      parentPort.postMessage({ type: FFmpegWorkerMessages.ERROR, error: 'Unknown message type' })
-    }
-  }
-})
-
-parentPort.on('close', () => {
-  logger.info('[ffmpeg-worker] Worker exiting')
-})
-
-parentPort.on('error', (err) => {
-  logger.error('[ffmpeg-worker] Worker error:', err)
-  parentPort.postMessage({ type: FFmpegWorkerMessages.ERROR, error: err })
-})
-
-// Notify main thread that worker is ready
-logger.info('[ffmpeg-worker] Worker ready')
-parentPort.postMessage({ type: 'ready' })