@qvac/decoder-audio 0.3.1 → 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

@@ -59,6 +59,33 @@ class FFmpegDecoder extends BaseInference {
     // 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 }
   }
 
   /**
@@ -172,10 +199,18 @@ class FFmpegDecoder extends BaseInference {
         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
       }
     }
   }
@@ -195,6 +230,10 @@ class FFmpegDecoder extends BaseInference {
 
     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()
 
@@ -248,6 +287,10 @@ class FFmpegDecoder extends BaseInference {
       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()
@@ -282,6 +325,10 @@ class FFmpegDecoder extends BaseInference {
       return
     }
 
+    // Reset and start tracking stats
+    this._resetStats()
+    const startTime = Date.now()
+
     try {
       this.logger.info('[FFmpegDecoder] Starting stream processing')
 
@@ -289,6 +336,9 @@ class FFmpegDecoder extends BaseInference {
       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
@@ -353,10 +403,21 @@ class FFmpegDecoder extends BaseInference {
       // 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)
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/decoder-audio",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "",
   "license": "Apache-2.0",
   "author": "Tether",
@@ -12,9 +12,12 @@
     "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",
@@ -32,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/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
-  }
-}