@qvac/decoder-audio 0.3.0 → 0.3.2

package/index.d.ts

@@ -33,6 +33,17 @@ interface DecoderStatus {
   paused: boolean
 }
 
+interface RuntimeStats {
+  decodeTimeMs: number
+  inputBytes: number
+  outputBytes: number
+  samplesDecoded: number
+  codecName: string | null
+  inputSampleRate: number
+  outputSampleRate: number
+  audioFormat: 's16le' | 'f32le'
+}
+
 declare class FFmpegDecoder extends BaseInference {
   SUPPORTED_AUDIO_FORMATS: SupportedAudioFormats
   OUTPUT_CHANNEL_LAYOUT: number | null
@@ -46,6 +57,8 @@ declare class FFmpegDecoder extends BaseInference {
   unpause(): Promise<void>
   stop(): Promise<void>
   status(): DecoderStatus
+  
+  runtimeStats(): RuntimeStats
 }
 
-export { FFmpegDecoder }
+export { FFmpegDecoder, RuntimeStats }

package/index.js

@@ -1,4 +1,474 @@
 'use strict'
 
-const FFmpegDecoder = require('./lib/ffmpeg/ffmpeg-decoder')
-module.exports.FFmpegDecoder = FFmpegDecoder
+const QvacResponse = require('@qvac/response')
+const QvacLogger = require('@qvac/logging')
+const ffmpeg = require('bare-ffmpeg')
+const BaseInference = require('@qvac/infer-base/WeightsProvider/BaseInference')
+
+/**
+ * FFmpeg-based audio decoder (single-threaded)
+ */
+class FFmpegDecoder extends BaseInference {
+  SUPPORTED_AUDIO_FORMATS = {
+    s16le: {
+      format: null, // Will be set to ffmpeg.constants.sampleFormats.S16
+      byteLength: 2
+    },
+    f32le: {
+      format: null, // Will be set to ffmpeg.constants.sampleFormats.FLT
+      byteLength: 4
+    }
+  }
+
+  OUTPUT_CHANNEL_LAYOUT = null // Will be set to ffmpeg.constants.channelLayouts.MONO
+  /**
+   * Creates an instance of FFmpegDecoder.
+   * @param {Object} config - Configuration options
+   * @param logger - Logger instance
+   * @param streamIndex - Index of the stream to decode. Default: 0
+   * @param inputBitrate - Input audio bitrate. Default: 192000
+   * @param audioFormat - Output audio format. Default: 's16le'
+   * @param args - Additional arguments passed to BaseInference
+   * @param {Object} [config.streamIndex] - Index of the stream to decode (default: 0)
+   * @param {number} [config.inputBitrate] - Input audio bitrate (default: 192000)
+   * @param {string} [config.audioFormat] - Output audio format (default: 'f32le')
+   * @param {number} [config.sampleRate] - Output sample rate (default: 16000)
+   * @param {Object} [config.logger] - Logger instance
+   */
+  constructor ({
+    config = {},
+    logger = null,
+    streamIndex = 0,
+    inputBitrate = 192000,
+    audioFormat = 's16le',
+    ...args
+  }) {
+    super({ ...args, logger })
+
+    this.config = {
+      streamIndex: config.streamIndex || streamIndex,
+      inputBitrate: config.inputBitrate || inputBitrate,
+      audioFormat: config.audioFormat || audioFormat,
+      sampleRate: config.sampleRate || 16000
+    }
+
+    this.logger = new QvacLogger(logger)
+    this.isLoaded = false
+    this.currentJob = null
+
+    // Encoder delay handling
+    this.samplesSkipped = 0
+    this.totalSkipSamples = 0
+
+    // Runtime stats
+    this._resetStats()
+  }
+
+  /**
+   * Resets the runtime stats
+   */
+  _resetStats () {
+    this._runtimeStats = {
+      decodeTimeMs: 0,
+      inputBytes: 0,
+      outputBytes: 0,
+      samplesDecoded: 0,
+      codecName: null,
+      inputSampleRate: 0,
+      outputSampleRate: this.config.sampleRate,
+      audioFormat: this.config.audioFormat
+    }
+  }
+
+  /**
+   * Get the current runtime stats
+   * @returns {Object} Current runtime stats
+   */
+  runtimeStats () {
+    return { ...this._runtimeStats }
+  }
+
+  /**
+   * Load and initialize the decoder
+   */
+  async load () {
+    if (this.isLoaded) {
+      this.logger.info('FFmpegDecoder already loaded')
+      return
+    }
+
+    this.logger.info('Loading FFmpegDecoder with config:', this.config)
+
+    // Initialize format constants
+    this.SUPPORTED_AUDIO_FORMATS.s16le.format = ffmpeg.constants.sampleFormats.S16
+    this.SUPPORTED_AUDIO_FORMATS.f32le.format = ffmpeg.constants.sampleFormats.FLT
+    this.OUTPUT_CHANNEL_LAYOUT = ffmpeg.constants.channelLayouts.MONO
+
+    // Validate audio format
+    if (!this.SUPPORTED_AUDIO_FORMATS[this.config.audioFormat]) {
+      throw new Error(`Unsupported audio format: ${this.config.audioFormat}`)
+    }
+
+    this.isLoaded = true
+    this.logger.info('FFmpegDecoder loaded successfully')
+  }
+
+  /**
+   * Unload the decoder and clean up resources
+   */
+  async unload () {
+    if (!this.isLoaded) {
+      return
+    }
+
+    this.logger.info('Unloading FFmpegDecoder')
+
+    this.isLoaded = false
+    this.currentJob = null
+    this.logger.info('FFmpegDecoder unloaded')
+  }
+
+  /**
+   * Run the decoder on an audio stream
+   * @param {Readable} audioStream - Input audio stream
+   * @returns {QvacResponse} Response with decoded audio
+   */
+  async run (audioStream) {
+    if (!this.isLoaded) {
+      throw new Error('Decoder not loaded. Call load() first.')
+    }
+
+    this.logger.info('Starting new audio stream processing')
+
+    const response = new QvacResponse({
+      cancelHandler: () => this.stop(),
+      pauseHandler: () => this.pause(),
+      continueHandler: () => this.unpause()
+    })
+
+    this.currentJob = {
+      response,
+      audioChunks: [],
+      isActive: true,
+      isPaused: false
+    }
+
+    // Process the audio stream
+    this._processStream(audioStream).catch(err => {
+      this.logger.error('Error processing audio stream:', err)
+      response.failed(err)
+    })
+
+    return response
+  }
+
+  _getBufferSize (inputBitrate) {
+    const maxBufferSize = 1024 * 1024 // 1MB max
+    return Math.min((inputBitrate / 8) * 4, maxBufferSize)
+  }
+
+  _processFrame (decoder, raw, resampler, job) {
+    const OUTPUT_FORMAT = this.SUPPORTED_AUDIO_FORMATS[this.config.audioFormat].format
+    const OUTPUT_FORMAT_BYTE_LENGTH = this.SUPPORTED_AUDIO_FORMATS[this.config.audioFormat].byteLength
+    const OUTPUT_SAMPLE_RATE = this.config.sampleRate
+
+    while (decoder.receiveFrame(raw)) {
+      const output = new ffmpeg.Frame()
+      output.channelLayout = this.OUTPUT_CHANNEL_LAYOUT
+      output.format = OUTPUT_FORMAT
+      output.sampleRate = OUTPUT_SAMPLE_RATE
+      output.nbSamples = raw.nbSamples
+
+      const samples = new ffmpeg.Samples(
+        output.format,
+        output.channelLayout.nbChannels,
+        output.nbSamples
+      )
+      samples.fill(output)
+
+      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 = OUTPUT_FORMAT_BYTE_LENGTH * samplesToSkip * output.channelLayout.nbChannels
+        const length = OUTPUT_FORMAT_BYTE_LENGTH * (count - samplesToSkip) * output.channelLayout.nbChannels
+        const chunk = Buffer.from(samples.data.subarray(skipBytes, skipBytes + length))
+        job.response.updateOutput({ outputArray: chunk })
+
+        // Track stats for partial frame
+        this._runtimeStats.samplesDecoded += (count - samplesToSkip)
+        this._runtimeStats.outputBytes += length
+      } else {
+        const length = OUTPUT_FORMAT_BYTE_LENGTH * count * output.channelLayout.nbChannels
+        const chunk = Buffer.from(samples.data.subarray(0, length))
+        job.response.updateOutput({ outputArray: chunk })
+
+        // Track stats
+        this._runtimeStats.samplesDecoded += count
+        this._runtimeStats.outputBytes += length
+      }
+    }
+  }
+
+  _processPacket (format, packet, raw, decoder, resampler, job) {
+    while (format.readFrame(packet)) {
+      decoder.sendPacket(packet)
+      this._processFrame(decoder, raw, resampler, job)
+      packet.unref()
+    }
+  }
+
+  _processFFmpegStream (format, stream, job) {
+    const OUTPUT_FORMAT = this.SUPPORTED_AUDIO_FORMATS[this.config.audioFormat].format
+    const OUTPUT_FORMAT_BYTE_LENGTH = this.SUPPORTED_AUDIO_FORMATS[this.config.audioFormat].byteLength
+    const OUTPUT_SAMPLE_RATE = this.config.sampleRate
+
+    this.logger.debug('[FFmpegDecoder] Stream codec:', stream.codec, stream.codecParameters)
+
+    // Track codec info in stats
+    this._runtimeStats.codecName = stream.codec.name
+    this._runtimeStats.inputSampleRate = stream.codecParameters.sampleRate
+
+    const packet = new ffmpeg.Packet()
+    const raw = new ffmpeg.Frame()
+
+    const resampler = new ffmpeg.Resampler(
+      stream.codecParameters.sampleRate,
+      stream.codecParameters.channelLayout,
+      stream.codecParameters.format,
+      OUTPUT_SAMPLE_RATE,
+      this.OUTPUT_CHANNEL_LAYOUT,
+      OUTPUT_FORMAT
+    )
+
+    const decoder = stream.decoder()
+    decoder.open()
+
+    // Auto-detect encoder delay: lossy codecs need ~400ms skipped to remove artifacts
+    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((OUTPUT_SAMPLE_RATE * skipMs) / 1000)
+
+    if (this.totalSkipSamples > 0) {
+      this.logger.info(`[FFmpegDecoder] Skipping ${skipMs}ms (${this.totalSkipSamples} samples) for ${codecName} to remove encoder artifacts`)
+    }
+
+    this._processPacket(format, packet, raw, decoder, resampler, job)
+
+    // Flush resampler
+    const output = new ffmpeg.Frame()
+    output.channelLayout = this.OUTPUT_CHANNEL_LAYOUT
+    output.format = OUTPUT_FORMAT
+    output.sampleRate = OUTPUT_SAMPLE_RATE
+    output.nbSamples = 1024
+
+    const samples = new ffmpeg.Samples(
+      output.format,
+      output.channelLayout.nbChannels,
+      output.nbSamples
+    )
+    samples.fill(output)
+
+    let flushCount
+    while ((flushCount = resampler.flush(output)) > 0) {
+      const actualLength = OUTPUT_FORMAT_BYTE_LENGTH * flushCount * output.channelLayout.nbChannels
+      const chunk = Buffer.from(samples.data.subarray(0, actualLength))
+      job.response.updateOutput({ outputArray: chunk })
+
+      // Track stats for flushed samples
+      this._runtimeStats.samplesDecoded += flushCount
+      this._runtimeStats.outputBytes += actualLength
+    }
+
+    decoder.destroy()
+  }
+
+  async _collectStreamData (audioStream, job) {
+    const chunks = []
+    let totalBytes = 0
+
+    for await (const chunk of audioStream) {
+      if (!job.isActive) {
+        this.logger.info('[FFmpegDecoder] Job cancelled, stopping stream collection')
+        break
+      }
+
+      while (job.isPaused) {
+        this.logger.debug('[FFmpegDecoder] Job is paused, waiting to resume...')
+        await new Promise(resolve => setTimeout(resolve, 100))
+      }
+
+      chunks.push(chunk)
+      totalBytes += chunk.length
+      this.logger.debug(`[FFmpegDecoder] Collected chunk, total bytes: ${totalBytes}`)
+    }
+
+    return Buffer.concat(chunks)
+  }
+
+  async _processStream (audioStream) {
+    const job = this.currentJob
+    if (!job.isActive) {
+      return
+    }
+
+    // Reset and start tracking stats
+    this._resetStats()
+    const startTime = Date.now()
+
+    try {
+      this.logger.info('[FFmpegDecoder] Starting stream processing')
+
+      // Collect all audio data from stream
+      const audioBuffer = await this._collectStreamData(audioStream, job)
+      this.logger.info(`[FFmpegDecoder] Collected ${audioBuffer.length} bytes of audio data`)
+
+      // Track input bytes
+      this._runtimeStats.inputBytes = audioBuffer.length
+
+      if (!job.isActive) {
+        this.logger.info('[FFmpegDecoder] Job cancelled after data collection')
+        return
+      }
+
+      // Create FFmpeg IO context with the buffer
+      const bufferSize = this._getBufferSize(this.config.inputBitrate)
+      let bufferOffset = 0
+
+      const io = new ffmpeg.IOContext(bufferSize, {
+        onread: (buffer, requestedLen) => {
+          const remainingBytes = audioBuffer.length - bufferOffset
+          const bytesToRead = Math.min(requestedLen, remainingBytes)
+
+          if (bytesToRead <= 0) {
+            return 0 // EOF
+          }
+
+          audioBuffer.copy(buffer, 0, bufferOffset, bufferOffset + bytesToRead)
+          bufferOffset += bytesToRead
+
+          this.logger.debug(`[FFmpegDecoder] Read ${bytesToRead} bytes from buffer, offset now: ${bufferOffset}`)
+          return bytesToRead
+        },
+        onseek: (offset, whence) => {
+          const AVSEEK_SIZE = 0x10000
+
+          if (whence === AVSEEK_SIZE) {
+            return audioBuffer.length
+          }
+
+          let newOffset
+          if (whence === 0) {
+            newOffset = offset
+          } else if (whence === 1) {
+            newOffset = bufferOffset + offset
+          } else if (whence === 2) {
+            newOffset = audioBuffer.length + offset
+          } else {
+            return -1
+          }
+
+          if (newOffset < 0 || newOffset > audioBuffer.length) {
+            return -1
+          }
+
+          bufferOffset = newOffset
+          this.logger.debug(`[FFmpegDecoder] Seek to offset: ${bufferOffset}`)
+          return bufferOffset
+        }
+      })
+
+      this.logger.debug('[FFmpegDecoder] IOContext created')
+      const format = new ffmpeg.InputFormatContext(io)
+      this.logger.debug('[FFmpegDecoder] InputFormatContext created')
+
+      const streamIndex = this.config.streamIndex || 0
+      if (format.streams[streamIndex] === undefined) {
+        throw new Error('Stream index out of bounds')
+      }
+
+      // Process the stream and generate decoded output
+      this._processFFmpegStream(format, format.streams[streamIndex], job)
+
+      // Calculate final decode time
+      this._runtimeStats.decodeTimeMs = Date.now() - startTime
+
+      // Update stats on response before ending
+      job.response.updateStats(this.runtimeStats())
+
+      // Mark as complete
+      job.response.ended()
+      this.logger.info('[FFmpegDecoder] Stream processing completed successfully')
+      this.logger.info(`[FFmpegDecoder] Runtime stats: ${JSON.stringify(this._runtimeStats)}`)
+    } catch (err) {
+      // Still capture stats even on error
+      this._runtimeStats.decodeTimeMs = Date.now() - startTime
+      job.response.updateStats(this.runtimeStats())
+
+      this.logger.error('Error processing audio stream:', err)
+      job.response.failed(err)
+    }
+
+    this.logger.info('Audio _processStream completed')
+  }
+
+  /**
+   * Pause the current job
+   */
+  pause () {
+    if (this.currentJob) {
+      this.currentJob.isPaused = true
+      this.logger.debug('Decoder paused')
+    }
+    return Promise.resolve()
+  }
+
+  /**
+   * Unpause the current job
+   */
+  unpause () {
+    if (this.currentJob) {
+      this.currentJob.isPaused = false
+      this.logger.debug('Decoder unpaused')
+    }
+    return Promise.resolve()
+  }
+
+  /**
+   * Stop the current job
+   */
+  stop () {
+    if (this.currentJob) {
+      this.currentJob.isActive = false
+      this.currentJob.response.finish()
+      this.logger.debug('Decoder stopped')
+    }
+    return Promise.resolve()
+  }
+
+  /**
+   * Get the current status
+   */
+  status () {
+    return {
+      loaded: this.isLoaded,
+      active: this.currentJob?.isActive || false,
+      paused: this.currentJob?.isPaused || false
+    }
+  }
+}
+
+module.exports = { FFmpegDecoder }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/decoder-audio",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "",
   "license": "Apache-2.0",
   "author": "Tether",
@@ -12,16 +12,18 @@
     "test": "npm run test:unit && npm run test:integration",
     "coverage:unit": "brittle-bare --coverage --cov-dir=coverage/unit test/unit/*.test.js && npx istanbul report html --include=coverage/unit/coverage-final.json",
     "coverage": "brittle-bare --coverage --cov-dir=coverage/unit test/unit/*.test.js && npx istanbul report html --include=coverage/unit/coverage-final.json",
-    "lint": "standard \"test/**/*.js\" \"*.js\"",
-    "lint:fix": "standard --fix \"test/**/*.js\" \"*.js\"",
-    "test:integration": "brittle-bare test/integration/*.test.js"
+    "lint": "standard \"test/**/*.js\" \"*.js\" \"scripts/**/*.js\"",
+    "lint:fix": "standard --fix \"test/**/*.js\" \"*.js\" \"scripts/**/*.js\"",
+    "test:integration": "npm run test:integration:generate && brittle-bare test/integration/*.test.js",
+    "test:integration:generate": "brittle -r test/integration/all.js test/integration/*.test.js && npm run test:mobile:generate",
+    "test:mobile:generate": "bare ./scripts/generate-mobile-integration-tests.js",
+    "test:mobile:validate": "node scripts/validate-mobile-tests.js"
   },
   "files": [
     "index.js",
     "constants.js",
     "constants.d.ts",
     "utils",
-    "lib",
     "index.d.ts",
     "test/mobile"
   ],
@@ -33,6 +35,8 @@
   },
   "devDependencies": {
     "@types/node": "^22.14.1",
+    "bare-os": "^3.6.2",
+    "bare-url": "^2.1.6",
     "brittle": "^3.13.1",
     "istanbul": "^0.4.5",
     "standard": "^17.1.2",

package/test/mobile/integration-runtime.cjs

@@ -0,0 +1,21 @@
+'use strict'
+
+const path = require('bare-path')
+const fs = require('bare-fs')
+const { pathToFileURL } = require('bare-url')
+
+async function runIntegrationModule (relativeModulePath, options = {}) {
+  const modulePath = path.join(__dirname, relativeModulePath)
+
+  if (!fs.existsSync(modulePath)) {
+    console.warn(`[integration-runner] Missing module: ${relativeModulePath}`)
+    return 'missing'
+  }
+
+  const moduleUrl = pathToFileURL(modulePath).href
+  await import(moduleUrl)
+  return modulePath
+}
+
+global.runIntegrationModule = runIntegrationModule
+

package/test/mobile/integration.auto.cjs

@@ -0,0 +1,11 @@
+'use strict'
+require('./integration-runtime.cjs')
+
+// AUTO-GENERATED FILE. Run `npm run test:mobile:generate` to update.
+// Each function mirrors a single file under test/integration/.
+
+/* global runIntegrationModule */
+
+async function runFfmpegDecoderTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/ffmpeg-decoder.test.js', options)
+}

package/utils/error.js

@@ -40,7 +40,7 @@ addCodes({
   },
   [ERR_CODES.FAILED_TO_GET_STATUS]: {
     name: 'FAILED_TO_GET_STATUS',
-    message: (message) => `Failed to get addon status, error: ${message}`
+    message: (message) => `Failed to get decoder status, error: ${message}`
   },
   [ERR_CODES.FAILED_TO_DESTROY]: {
     name: 'FAILED_TO_DESTROY',

package/lib/ffmpeg/ffmpeg-decoder.js

@@ -1,413 +0,0 @@
-'use strict'
-
-const QvacResponse = require('@qvac/response')
-const QvacLogger = require('@qvac/logging')
-const ffmpeg = require('bare-ffmpeg')
-const BaseInference = require('@qvac/infer-base/WeightsProvider/BaseInference')
-
-/**
- * FFmpeg-based audio decoder (single-threaded)
- */
-class FFmpegDecoder extends BaseInference {
-  SUPPORTED_AUDIO_FORMATS = {
-    s16le: {
-      format: null, // Will be set to ffmpeg.constants.sampleFormats.S16
-      byteLength: 2
-    },
-    f32le: {
-      format: null, // Will be set to ffmpeg.constants.sampleFormats.FLT
-      byteLength: 4
-    }
-  }
-
-  OUTPUT_CHANNEL_LAYOUT = null // Will be set to ffmpeg.constants.channelLayouts.MONO
-  /**
-   * Creates an instance of FFmpegDecoder.
-   * @param {Object} config - Configuration options
-   * @param logger - Logger instance
-   * @param streamIndex - Index of the stream to decode. Default: 0
-   * @param inputBitrate - Input audio bitrate. Default: 192000
-   * @param audioFormat - Output audio format. Default: 's16le'
-   * @param args - Additional arguments passed to BaseInference
-   * @param {Object} [config.streamIndex] - Index of the stream to decode (default: 0)
-   * @param {number} [config.inputBitrate] - Input audio bitrate (default: 192000)
-   * @param {string} [config.audioFormat] - Output audio format (default: 'f32le')
-   * @param {number} [config.sampleRate] - Output sample rate (default: 16000)
-   * @param {Object} [config.logger] - Logger instance
-   */
-  constructor ({
-    config = {},
-    logger = null,
-    streamIndex = 0,
-    inputBitrate = 192000,
-    audioFormat = 's16le',
-    ...args
-  }) {
-    super({ ...args, logger })
-
-    this.config = {
-      streamIndex: config.streamIndex || streamIndex,
-      inputBitrate: config.inputBitrate || inputBitrate,
-      audioFormat: config.audioFormat || audioFormat,
-      sampleRate: config.sampleRate || 16000
-    }
-
-    this.logger = new QvacLogger(logger)
-    this.isLoaded = false
-    this.currentJob = null
-    
-    // Encoder delay handling
-    this.samplesSkipped = 0
-    this.totalSkipSamples = 0
-  }
-
-  /**
-   * Load and initialize the decoder
-   */
-  async load () {
-    if (this.isLoaded) {
-      this.logger.info('FFmpegDecoder already loaded')
-      return
-    }
-
-    this.logger.info('Loading FFmpegDecoder with config:', this.config)
-
-    // Initialize format constants
-    this.SUPPORTED_AUDIO_FORMATS.s16le.format = ffmpeg.constants.sampleFormats.S16
-    this.SUPPORTED_AUDIO_FORMATS.f32le.format = ffmpeg.constants.sampleFormats.FLT
-    this.OUTPUT_CHANNEL_LAYOUT = ffmpeg.constants.channelLayouts.MONO
-
-    // Validate audio format
-    if (!this.SUPPORTED_AUDIO_FORMATS[this.config.audioFormat]) {
-      throw new Error(`Unsupported audio format: ${this.config.audioFormat}`)
-    }
-
-    this.isLoaded = true
-    this.logger.info('FFmpegDecoder loaded successfully')
-  }
-
-  /**
-   * Unload the decoder and clean up resources
-   */
-  async unload () {
-    if (!this.isLoaded) {
-      return
-    }
-
-    this.logger.info('Unloading FFmpegDecoder')
-    
-    this.isLoaded = false
-    this.currentJob = null
-    this.logger.info('FFmpegDecoder unloaded')
-  }
-
-  /**
-   * Run the decoder on an audio stream
-   * @param {Readable} audioStream - Input audio stream
-   * @returns {QvacResponse} Response with decoded audio
-   */
-  async run (audioStream) {
-    if (!this.isLoaded) {
-      throw new Error('Decoder not loaded. Call load() first.')
-    }
-
-    this.logger.info('Starting new audio stream processing')
-
-    const response = new QvacResponse({
-      cancelHandler: () => this.stop(),
-      pauseHandler: () => this.pause(),
-      continueHandler: () => this.unpause()
-    })
-
-    this.currentJob = {
-      response,
-      audioChunks: [],
-      isActive: true,
-      isPaused: false
-    }
-
-    // Process the audio stream
-    this._processStream(audioStream).catch(err => {
-      this.logger.error('Error processing audio stream:', err)
-      response.failed(err)
-    })
-
-    return response
-  }
-
-  _getBufferSize (inputBitrate) {
-    const maxBufferSize = 1024 * 1024 // 1MB max
-    return Math.min((inputBitrate / 8) * 4, maxBufferSize)
-  }
-
-  _processFrame (decoder, raw, resampler, job) {
-    const OUTPUT_FORMAT = this.SUPPORTED_AUDIO_FORMATS[this.config.audioFormat].format
-    const OUTPUT_FORMAT_BYTE_LENGTH = this.SUPPORTED_AUDIO_FORMATS[this.config.audioFormat].byteLength
-    const OUTPUT_SAMPLE_RATE = this.config.sampleRate
-
-    while (decoder.receiveFrame(raw)) {
-      const output = new ffmpeg.Frame()
-      output.channelLayout = this.OUTPUT_CHANNEL_LAYOUT
-      output.format = OUTPUT_FORMAT
-      output.sampleRate = OUTPUT_SAMPLE_RATE
-      output.nbSamples = raw.nbSamples
-
-      const samples = new ffmpeg.Samples(
-        output.format,
-        output.channelLayout.nbChannels,
-        output.nbSamples
-      )
-      samples.fill(output)
-
-      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 = OUTPUT_FORMAT_BYTE_LENGTH * samplesToSkip * output.channelLayout.nbChannels
-        const length = OUTPUT_FORMAT_BYTE_LENGTH * (count - samplesToSkip) * output.channelLayout.nbChannels
-        const chunk = Buffer.from(samples.data.subarray(skipBytes, skipBytes + length))
-        job.response.updateOutput({ outputArray: chunk })
-      } else {
-        const length = OUTPUT_FORMAT_BYTE_LENGTH * count * output.channelLayout.nbChannels
-        const chunk = Buffer.from(samples.data.subarray(0, length))
-        job.response.updateOutput({ outputArray: chunk })
-      }
-    }
-  }
-
-  _processPacket (format, packet, raw, decoder, resampler, job) {
-    while (format.readFrame(packet)) {
-      decoder.sendPacket(packet)
-      this._processFrame(decoder, raw, resampler, job)
-      packet.unref()
-    }
-  }
-
-  _processFFmpegStream (format, stream, job) {
-    const OUTPUT_FORMAT = this.SUPPORTED_AUDIO_FORMATS[this.config.audioFormat].format
-    const OUTPUT_FORMAT_BYTE_LENGTH = this.SUPPORTED_AUDIO_FORMATS[this.config.audioFormat].byteLength
-    const OUTPUT_SAMPLE_RATE = this.config.sampleRate
-
-    this.logger.debug('[FFmpegDecoder] Stream codec:', 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,
-      OUTPUT_SAMPLE_RATE,
-      this.OUTPUT_CHANNEL_LAYOUT,
-      OUTPUT_FORMAT
-    )
-
-    const decoder = stream.decoder()
-    decoder.open()
-
-    // Auto-detect encoder delay: lossy codecs need ~400ms skipped to remove artifacts
-    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((OUTPUT_SAMPLE_RATE * skipMs) / 1000)
-
-    if (this.totalSkipSamples > 0) {
-      this.logger.info(`[FFmpegDecoder] Skipping ${skipMs}ms (${this.totalSkipSamples} samples) for ${codecName} to remove encoder artifacts`)
-    }
-
-    this._processPacket(format, packet, raw, decoder, resampler, job)
-
-    // Flush resampler
-    const output = new ffmpeg.Frame()
-    output.channelLayout = this.OUTPUT_CHANNEL_LAYOUT
-    output.format = OUTPUT_FORMAT
-    output.sampleRate = OUTPUT_SAMPLE_RATE
-    output.nbSamples = 1024
-
-    const samples = new ffmpeg.Samples(
-      output.format,
-      output.channelLayout.nbChannels,
-      output.nbSamples
-    )
-    samples.fill(output)
-
-    let flushCount
-    while ((flushCount = resampler.flush(output)) > 0) {
-      const actualLength = OUTPUT_FORMAT_BYTE_LENGTH * flushCount * output.channelLayout.nbChannels
-      const chunk = Buffer.from(samples.data.subarray(0, actualLength))
-      job.response.updateOutput({ outputArray: chunk })
-    }
-
-    decoder.destroy()
-  }
-
-  async _collectStreamData (audioStream, job) {
-    const chunks = []
-    let totalBytes = 0
-    
-    for await (const chunk of audioStream) {
-      if (!job.isActive) {
-        this.logger.info('[FFmpegDecoder] Job cancelled, stopping stream collection')
-        break
-      }
-
-      while (job.isPaused) {
-        this.logger.debug('[FFmpegDecoder] Job is paused, waiting to resume...')
-        await new Promise(resolve => setTimeout(resolve, 100))
-      }
-
-      chunks.push(chunk)
-      totalBytes += chunk.length
-      this.logger.debug(`[FFmpegDecoder] Collected chunk, total bytes: ${totalBytes}`)
-    }
-
-    return Buffer.concat(chunks)
-  }
-
-  async _processStream (audioStream) {
-    const job = this.currentJob
-    if (!job.isActive) {
-      return
-    }
-
-    try {
-      this.logger.info('[FFmpegDecoder] Starting stream processing')
-
-      // Collect all audio data from stream
-      const audioBuffer = await this._collectStreamData(audioStream, job)
-      this.logger.info(`[FFmpegDecoder] Collected ${audioBuffer.length} bytes of audio data`)
-
-      if (!job.isActive) {
-        this.logger.info('[FFmpegDecoder] Job cancelled after data collection')
-        return
-      }
-
-      // Create FFmpeg IO context with the buffer
-      const bufferSize = this._getBufferSize(this.config.inputBitrate)
-      let bufferOffset = 0
-
-      const io = new ffmpeg.IOContext(bufferSize, {
-        onread: (buffer, requestedLen) => {
-          const remainingBytes = audioBuffer.length - bufferOffset
-          const bytesToRead = Math.min(requestedLen, remainingBytes)
-          
-          if (bytesToRead <= 0) {
-            return 0 // EOF
-          }
-
-          audioBuffer.copy(buffer, 0, bufferOffset, bufferOffset + bytesToRead)
-          bufferOffset += bytesToRead
-          
-          this.logger.debug(`[FFmpegDecoder] Read ${bytesToRead} bytes from buffer, offset now: ${bufferOffset}`)
-          return bytesToRead
-        },
-        onseek: (offset, whence) => {
-          const AVSEEK_SIZE = 0x10000
-          
-          if (whence === AVSEEK_SIZE) {
-            return audioBuffer.length
-          }
-          
-          let newOffset
-          if (whence === 0) {
-            newOffset = offset
-          } else if (whence === 1) {
-            newOffset = bufferOffset + offset
-          } else if (whence === 2) {
-            newOffset = audioBuffer.length + offset
-          } else {
-            return -1
-          }
-          
-          if (newOffset < 0 || newOffset > audioBuffer.length) {
-            return -1
-          }
-          
-          bufferOffset = newOffset
-          this.logger.debug(`[FFmpegDecoder] Seek to offset: ${bufferOffset}`)
-          return bufferOffset
-        }
-      })
-
-      this.logger.debug('[FFmpegDecoder] IOContext created')
-      const format = new ffmpeg.InputFormatContext(io)
-      this.logger.debug('[FFmpegDecoder] InputFormatContext created')
-
-      const streamIndex = this.config.streamIndex || 0
-      if (format.streams[streamIndex] === undefined) {
-        throw new Error('Stream index out of bounds')
-      }
-
-      // Process the stream and generate decoded output
-      this._processFFmpegStream(format, format.streams[streamIndex], job)
-
-      // Mark as complete
-      job.response.ended()
-      this.logger.info('[FFmpegDecoder] Stream processing completed successfully')
-    } catch (err) {
-      this.logger.error('Error processing audio stream:', err)
-      job.response.failed(err)
-    }
-
-    this.logger.info('Audio _processStream completed')
-  }
-
-  /**
-   * Pause the current job
-   */
-  pause () {
-    if (this.currentJob) {
-      this.currentJob.isPaused = true
-      this.logger.debug('Decoder paused')
-    }
-    return Promise.resolve()
-  }
-
-  /**
-   * Unpause the current job
-   */
-  unpause () {
-    if (this.currentJob) {
-      this.currentJob.isPaused = false
-      this.logger.debug('Decoder unpaused')
-    }
-    return Promise.resolve()
-  }
-
-  /**
-   * Stop the current job
-   */
-  stop () {
-    if (this.currentJob) {
-      this.currentJob.isActive = false
-      this.currentJob.response.finish()
-      this.logger.debug('Decoder stopped')
-    }
-    return Promise.resolve()
-  }
-
-  /**
-   * Get the current status
-   */
-  status () {
-    return {
-      loaded: this.isLoaded,
-      active: this.currentJob?.isActive || false,
-      paused: this.currentJob?.isPaused || false
-    }
-  }
-}
-
-module.exports = FFmpegDecoder

package/lib/ffmpeg/index.d.ts

@@ -1,98 +0,0 @@
-import { Readable } from "stream";
-import { QvacResponse } from "@qvac/infer-base";
-import type { Loader, WhisperConfig } from "..";
-
-declare interface FFmpegDecoderConfig {
-  streamIndex?: number;
-  inputBitrate?: number;
-}
-
-declare interface TranscriptionAddonArgs {
-  loader: Loader;
-  params?: {
-    decoder?: FFmpegDecoderConfig;
-    [key: string]: unknown;
-  };
-  logger?: any;
-  modelName?: string;
-  vadModelName?: string;
-  diskPath?: string;
-  [key: string]: unknown;
-}
-
-declare interface TranscriptionAddonConfig {
-  path?: string;
-  opts?: {
-    stats?: boolean;
-    [key: string]: unknown;
-  };
-  whisperConfig?: WhisperConfig;
-  [key: string]: unknown;
-}
-
-/**
- * TranscriptionAddon with FFmpeg decoder support
- *
- * Provides a complete transcription pipeline that:
- * - Decodes various audio formats (WAV, MP3, M4A, OGG, Opus, FLAC, etc.)
- * - Resamples to 16kHz mono
- * - Transcribes using Whisper model
- */
-declare class TranscriptionAddon {
-  /**
-   * Creates an instance of TranscriptionAddon
-   * @param args - Configuration arguments including loader, model paths, and decoder config
-   * @param config - Whisper configuration including VAD settings
-   */
-  constructor(args: TranscriptionAddonArgs, config?: TranscriptionAddonConfig);
-
-  /**
-   * Load model, decoder, and activate addon
-   * @param closeLoader - Whether to close the loader after loading
-   * @param reportProgress - Callback function to report loading progress
-   */
-  load(
-    closeLoader?: boolean,
-    reportProgress?: (data: any) => void
-  ): Promise<void>;
-
-  /**
-   * Unload and clean up resources
-   */
-  unload(): Promise<void>;
-
-  /**
-   * Run transcription on an audio stream
-   * @param audioStream - Audio stream in any format supported by FFmpeg
-   * @returns Promise that resolves to a QvacResponse with transcription results
-   */
-  run(audioStream: Readable): Promise<QvacResponse>;
-
-  /**
-   * Download model files
-   * @param progressReport - Optional progress report instance
-   */
-  download(progressReport?: any): Promise<any>;
-
-  /**
-   * Delete local model files
-   */
-  delete(): Promise<any>;
-
-  /**
-   * Pause inference
-   */
-  pause(): void;
-
-  /**
-   * Resume inference
-   */
-  resume(): void;
-
-  /**
-   * Destroy and clean up all resources
-   */
-  destroy(): Promise<void>;
-}
-
-export = TranscriptionAddon;

package/lib/ffmpeg/index.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const TranscriptionPipeline = require('@qvac/util-transcription')
-const TranscriptionWhispercpp = require('../index')
-const FFmpegDecoder = require('./ffmpeg-decoder')
-
-class TranscriptionAddon extends TranscriptionPipeline {
-  constructor ({ loader, params, logger, ...args }, config = {}) {
-    const whisperAddon = new TranscriptionWhispercpp(
-      {
-        loader,
-        params,
-        logger,
-        ...args
-      },
-      { ...config }
-    )
-
-    // Create FFmpeg decoder instance
-    const decoder = new FFmpegDecoder({
-      config: { ...params.decoder, audio_format: config?.audio_format },
-      logger
-    })
-
-    super({ whisperAddon, decoder }, params.decoder)
-  }
-}
-
-module.exports = TranscriptionAddon

package/test/mobile/ffmpeg-test.cjs

@@ -1,105 +0,0 @@
-const { FFmpegDecoder } = require('@qvac/decoder-audio')
-
-async function testFFmpegDecodeMp3() {
-    try {
-        const decoder = new FFmpegDecoder({
-            config: {
-                audioFormat: 's16le',
-                sampleRate: 16000
-            }
-        })
-    
-        await decoder.load()
-    
-        const audioPath = getAssetPath('sample.mp3')
-        const audioStream = fs.createReadStream(audioPath)
-    
-        const response = await decoder.run(audioStream)
-    
-        let totalBytes = 0
-        let updateCount = 0
-    
-        await response
-          .onUpdate(output => {
-            if (output && output.outputArray) {
-              const bytes = new Uint8Array(output.outputArray)
-              totalBytes += bytes.length
-              updateCount++
-            }
-          })
-          .await()
-    
-        if (totalBytes === 0) {
-          throw new Error('No audio data decoded')
-        }
-    
-        if (updateCount === 0) {
-          throw new Error('No decoder updates received')
-        }
-    
-        console.log(`MP3 decode complete: ${totalBytes} bytes, ${updateCount} updates`)
-    
-        await decoder.unload()
-
-        return { 
-          success: true,
-          totalBytes,
-          updateCount
-        }
-    } catch (error) {
-        console.error('Error during testFFmpegDecodeMp3:', error)
-        throw error
-    }
-}
-
-async function testFFmpegDecodeWav() {
-  try {
-      const decoder = new FFmpegDecoder({
-          config: {
-              audioFormat: 's16le',
-              sampleRate: 16000
-          }
-      })
-  
-      await decoder.load()
-  
-      const audioPath = getAssetPath('sample.wav')
-      const audioStream = fs.createReadStream(audioPath)
-  
-      const response = await decoder.run(audioStream)
-  
-      let totalBytes = 0
-      let updateCount = 0
-  
-      await response
-        .onUpdate(output => {
-          if (output && output.outputArray) {
-            const bytes = new Uint8Array(output.outputArray)
-            totalBytes += bytes.length
-            updateCount++
-          }
-        })
-        .await()
-  
-      if (totalBytes === 0) {
-        throw new Error('No audio data decoded')
-      }
-  
-      if (updateCount === 0) {
-        throw new Error('No decoder updates received')
-      }
-  
-      console.log(`MP3 decode complete: ${totalBytes} bytes, ${updateCount} updates`)
-  
-      await decoder.unload()
-
-      return { 
-        success: true,
-        totalBytes,
-        updateCount
-      }
-  } catch (error) {
-      console.error('Error during testFFmpegDecodeMp3:', error)
-      throw error
-  }
-}