@qvac/decoder-audio 0.2.9 → 0.3.0

package/README.md

@@ -1,12 +1,11 @@
 # qvac-lib-decoder-audio
 
-This decoder addon leverages the GStreamer pipeline for efficient, asynchronous audio decoding. It simplifies processing of input audio, particularly as a preprocessing step for other addons.
+This decoder library leverages FFmpeg for efficient audio decoding. It simplifies processing of input audio, particularly as a preprocessing step for other addons.
 
 ## Table of Contents
 
 - [Installation](#installation)  
 - [Usage](#usage)  
-  - [Supported Audio Formats](#supported-audio-formats)  
   - [1. Creating the Decoder Instance](#1-creating-the-decoder-instance)  
   - [2. Loading the Decoder](#2-loading-the-decoder)  
   - [3. Decoding Audio](#3-decoding-audio)  
@@ -57,34 +56,16 @@ npm install @tetherto/qvac-lib-decoder-audio@latest
 
 This library provides a simple workflow for decoding audio streams.
 
-### Supported Audio Formats
-
-The library exports two constants that define the supported audio formats:
-
-```javascript
-const GSTDecoder = require('@tetherto/qvac-lib-decoder-audio')
-
-// Audio formats that require decoding before processing
-console.log(GSTDecoder.FORMATS_NEEDING_DECODE)
-// ['.mp3', '.m4a', '.ogg', '.flac', '.aac', '.wav']
-
-// All supported audio formats (including raw)
-console.log(GSTDecoder.SUPPORTED_AUDIO_FORMATS)
-// ['.mp3', '.m4a', '.ogg', '.wav', '.flac', '.aac', '.raw']
-```
-
-These constants can be used to validate input file formats or to determine if a file needs decoding before processing.
-
 ### 1. Creating the Decoder Instance
 
-To get started, import the decoder addon and create an instance:
+To get started, import the decoder and create an instance:
 
 ```javascript
-const GSTDecoder = require('@tetherto/qvac-lib-decoder-audio')
+const { FFmpegDecoder } = require('@tetherto/qvac-lib-decoder-audio')
 
-const decoder = new GSTDecoder({
+const decoder = new FFmpegDecoder({
   config: {
-    audioFormat: 'encoded', // 'encoded' | 's16le' | 'f32le'; default is 'encoded'
+    audioFormat: 's16le', // 's16le' | 'f32le'; default is 's16le'
     sampleRate: 16000 // in Hz; default is 16000
   }
 })
@@ -92,20 +73,19 @@ const decoder = new GSTDecoder({
 
 The `config` object accepts the following parameters:
 
-* **`audioFormat`**: Specifies the format of the input audio. Supported values:
+* **`audioFormat`**: Specifies the output format of the decoded audio. Supported values:
 
-  * `'encoded'`: For encoded audio input. Currently supported formats are OGG, WAV, MP3 and M4A.
   * `'s16le'`: Signed 16-bit little-endian PCM — a widely used raw format.
   * `'f32le'`: 32-bit floating-point little-endian PCM — ideal for high-precision audio processing.
 
-  Default: `'encoded'`.
+  Default: `'s16le'`.
 
-* **`sampleRate`**: Sample rate of the input audio in Hertz (Hz).
+* **`sampleRate`**: Sample rate of the output audio in Hertz (Hz).
   Default: `16000` (16 kHz), commonly used for speech processing.
 
 ### 2. Loading the Decoder
 
-Initializes and activates the decoder addon with the provided or default configuration. This method must be called before decoding any audio input.
+Initializes and activates the decoder with the provided or default configuration. This method must be called before decoding any audio input.
 
 ```javascript
 try {
@@ -156,7 +136,7 @@ try {
 
 ## Quickstart Example
 
-The following example demonstrates how to use the decoder addon to decode a sample OGG file into a raw audio file. Follow these steps, to run the example:
+The following example demonstrates how to use the decoder to decode a sample OGG file into a raw audio file. Follow these steps, to run the example:
 
 ### 1. Create a new project:
    
@@ -178,45 +158,38 @@ npm install bare-fs @tetherto/qvac-lib-decoder-audio
 'use strict'
 
 const fs = require('bare-fs')
-const GSTDecoder = require('@tetherto/qvac-lib-decoder-audio')
+const { FFmpegDecoder } = require('@tetherto/qvac-lib-decoder-audio')
 
 const audioFilePath = './path/to/audio/file.ogg'
 const outputFilePath = './path/to/output/file.raw'
 
 async function main () {
-  // 1. Create a decoder instance
-  const decoder = new GSTDecoder({
+  const decoder = new FFmpegDecoder({
     config: {
-      audioFormat: 'encoded' // Use 'encoded' for OGG input
+      audioFormat: 's16le',
+      sampleRate: 16000
     }
   })
 
   try {
-    // 2. Load the decoder
     await decoder.load()
 
-    // 3. Create audio stream and pass it to the decoder
     const audioStream = fs.createReadStream(audioFilePath)
     const response = await decoder.run(audioStream)
 
     const decodedFileBuffer = []
 
-    // 4. Handle response updates
     await response
       .onUpdate(output => {
         const bytes = new Uint8Array(output.outputArray)
-
-        // Collect decoded bytes
         decodedFileBuffer.push(bytes)
       })
       .onFinish(() => {
-        // Write the decoded bytes to a file on finish
         fs.writeFileSync(outputFilePath, Buffer.concat(decodedFileBuffer))
         console.log('Decoded file saved to', outputFilePath)
       })
       .await()
   } finally {
-    // 5. Unload the decoder
     await decoder.unload()
   }
 }
@@ -267,10 +240,9 @@ Coverage reports are generated in the 'coverage/unit/' directory. Open the corre
 ## Resources
 
 * GitHub Repo: [tetherto/qvac-lib-decoder-audio](https://github.com/tetherto/qvac-lib-decoder-audio)
-* GStreamer: [gstreamer.freedesktop.org](https://gstreamer.freedesktop.org/)
 
 ## License
 
 This project is licensed under the Apache-2.0 License – see the [LICENSE](LICENSE) file for details.
 
-*For questions or issues, please open an issue on the GitHub repository.*
+*For questions or issues, please open an issue on the GitHub repository.*

package/index.d.ts

@@ -1,69 +1,51 @@
 import BaseInference = require('@qvac/infer-base/WeightsProvider/BaseInference')
 import QvacResponse from '@qvac/response'
 
-type AppendInput = {
-  type: 'audio' | 'end of job'
-  input?: ArrayBuffer
-  priority?: number
+interface AudioFormatConfig {
+  format: number | null
+  byteLength: number
 }
 
-interface DecoderConfig {
-  audioFormat?: string
-  sampleRate?: number
-  [key: string]: any
+interface SupportedAudioFormats {
+  s16le: AudioFormatConfig
+  f32le: AudioFormatConfig
 }
 
-interface AudioStream {
-  [Symbol.asyncIterator](): AsyncIterator<{ buffer: Buffer }>
-}
-
-interface Addon {
-  activate(): Promise<void>
-  append(input: AppendInput): Promise<number>
-  cancel(jobId: number): Promise<void>
-  pause(): Promise<void>
-  continue(): Promise<void>
-  status(): Promise<any>
-  loadWeights?(params: {
-    filename: string
-    contents?: Buffer
-    completed: boolean
-  }): Promise<void>
+interface FFmpegDecoderConfig {
+  streamIndex?: number
+  inputBitrate?: number
+  audioFormat?: 's16le' | 'f32le'
+  sampleRate?: number
 }
 
-interface GSTDecoderConstructorParams {
-  config: DecoderConfig
+interface FFmpegDecoderConstructorParams {
+  config?: FFmpegDecoderConfig
+  logger?: any
+  streamIndex?: number
+  inputBitrate?: number
+  audioFormat?: 's16le' | 'f32le'
   [key: string]: any
 }
 
-/**
- * GSTDecoder client implementation for the Whisper transcription model
- */
-declare class GSTDecoder extends BaseInference {
-  /**
-   * Creates an instance of GSTDecoder.
-   * @constructor
-   * @param {Object} config - environment-specific inference setup configuration
-   */
-  constructor({ config, ...args }: GSTDecoderConstructorParams)
-  private config: DecoderConfig
-  private addon: Addon
-  load(): Promise<void>
-  createAddon(config: DecoderConfig): Addon
-  protected _runInternal(audioStream: AudioStream): Promise<QvacResponse>
-  getStatus(): Promise<any>
+interface DecoderStatus {
+  loaded: boolean
+  active: boolean
+  paused: boolean
 }
 
-declare namespace GSTDecoder {
-  /**
-   * Audio formats that require decoding before processing
-   */
-  export const FORMATS_NEEDING_DECODE: readonly string[]
+declare class FFmpegDecoder extends BaseInference {
+  SUPPORTED_AUDIO_FORMATS: SupportedAudioFormats
+  OUTPUT_CHANNEL_LAYOUT: number | null
+
+  constructor(params: FFmpegDecoderConstructorParams)
 
-  /**
-   * All supported audio formats (including raw)
-   */
-  export const SUPPORTED_AUDIO_FORMATS: readonly string[]
+  load(): Promise<void>
+  unload(): Promise<void>
+  run(audioStream: AsyncIterable<Buffer>): Promise<QvacResponse>
+  pause(): Promise<void>
+  unpause(): Promise<void>
+  stop(): Promise<void>
+  status(): DecoderStatus
 }
 
-export = GSTDecoder
+export { FFmpegDecoder }

package/index.js

@@ -1,119 +1,4 @@
 'use strict'
 
-const QvacResponse = require('@qvac/response')
-const BaseInference = require('@qvac/infer-base/WeightsProvider/BaseInference')
-const { GSTDecoderInterface } = require('./gstreamer')
-const createStreamAccumulator = require('./utils/createStreamAccumulator')
-const { FORMATS_NEEDING_DECODE, SUPPORTED_AUDIO_FORMATS } = require('./constants')
-
-const END_OF_INPUT = 'end of job'
-
-/**
- * GSTDecoder client implementation for the Whisper transcription model
- */
-class GSTDecoder extends BaseInference {
-  /**
-   * Creates an instance of GSTDecoder.
-   * @constructor
-   * @param {Object} options - Constructor options
-   * @param {Object} options.config - environment-specific inference setup configuration
-   * @param {*} [args] - Additional arguments passed to BaseInference
-   */
-
-  constructor ({ config, ...args }) {
-    super(args)
-    this.config = config
-  }
-
-  async load () {
-    const config = {
-      audioFormat: this.config.audioFormat || 'encoded',
-      sampleRate: this.config.sampleRate || 16000
-    }
-
-    this.logger.info('Loading GSTDecoder with config:', config)
-    this.addon = this.createAddon(config)
-
-    await this.addon.activate()
-    this.logger.info('GSTDecoder activated successfully')
-  }
-
-  async _runInternal (audioStream) {
-    this.logger.info('Starting new audio stream processing')
-    const response = new QvacResponse({
-      cancelHandler: () => this.addon.cancel(jobId),
-      pauseHandler: () => this.addon.pause(),
-      continueHandler: () => this.addon.continue()
-    })
-
-    const jobId = await this.addon.append({
-      type: 'audio',
-      input: new Uint8Array().buffer,
-      priority: 1
-    })
-
-    this.logger.info('Created new job with ID:', jobId)
-    this._saveJobToResponseMapping(jobId, response)
-
-    this._handleAudioStream(audioStream).catch(err => {
-      this.logger.error('Error processing audio stream:', err)
-      response.failed(err)
-    })
-    return response
-  }
-
-  async _handleAudioStream (audioStream) {
-    this.logger.info('Starting audio stream handling')
-    const streamAccumulator = createStreamAccumulator({
-      onChunk: async chunk => {
-        this.logger.debug('Processing audio chunk of size:', chunk.byteLength)
-        await this.addon.append({
-          type: 'audio',
-          input: chunk.buffer,
-          priority: 1
-        })
-      },
-      onFinish: async () => {
-        this.logger.info('Audio stream finished, sending end of input')
-        await this.addon.append({ type: END_OF_INPUT })
-      }
-    })
-
-    for await (const chunk of audioStream) {
-      await streamAccumulator.processData(chunk)
-    }
-
-    await streamAccumulator.finish()
-    this.logger.info('Audio stream handling completed')
-  }
-
-  async getStatus () {
-    const status = await this.addon.status()
-    this.logger.debug('Current status:', status)
-    return status
-  }
-
-  async unload () {
-    if (this.addon) {
-      this.logger.info('Destroying GSTDecoder addon')
-      await this.addon.destroy()
-      this.addon = null
-    }
-  }
-
-  createAddon (config) {
-    this.logger.info('Creating new GSTDecoderInterface instance')
-    return new GSTDecoderInterface(
-      config,
-      this._outputCallback.bind(this),
-      this.logger.info.bind(this.logger)
-    )
-  }
-}
-
 const FFmpegDecoder = require('./lib/ffmpeg/ffmpeg-decoder')
-
-module.exports = GSTDecoder
-module.exports.FORMATS_NEEDING_DECODE = FORMATS_NEEDING_DECODE
-module.exports.SUPPORTED_AUDIO_FORMATS = SUPPORTED_AUDIO_FORMATS
 module.exports.FFmpegDecoder = FFmpegDecoder

package/lib/ffmpeg/ffmpeg-decoder.js

@@ -312,6 +312,32 @@ class FFmpegDecoder extends BaseInference {
           
           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
         }
       })
 

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@qvac/decoder-audio",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "description": "",
   "license": "Apache-2.0",
   "author": "Tether",
   "type": "commonjs",
   "main": "index.js",
-  "addon": true,
   "scripts": {
     "test:dts": "tsc index.d.ts --noEmit --esModuleInterop --skipLibCheck",
     "test:unit": "brittle-bare test/unit/*.test.js",
@@ -18,12 +17,9 @@
     "test:integration": "brittle-bare test/integration/*.test.js"
   },
   "files": [
-    "binding.js",
     "index.js",
-    "gstreamer.js",
     "constants.js",
     "constants.d.ts",
-    "prebuilds",
     "utils",
     "lib",
     "index.d.ts",
@@ -38,8 +34,6 @@
   "devDependencies": {
     "@types/node": "^22.14.1",
     "brittle": "^3.13.1",
-    "cmake-bare": "^1.7.5",
-    "cmake-vcpkg": "^1.1.0",
     "istanbul": "^0.4.5",
     "standard": "^17.1.2",
     "typescript": "^5.3.0"

package/binding.js

@@ -1,3 +0,0 @@
-'use strict'
-
-module.exports = require.addon()

package/gstreamer.js

@@ -1,131 +0,0 @@
-'use strict'
-
-const binding = require('./binding')
-const { QvacErrorDecoderAudio, ERR_CODES } = require('./utils/error')
-
-/**
- * An interface between Bare addon in C++ and JS runtime.
- */
-class GSTDecoderInterface {
-  /**
-   *
-   * @param {Object} configurationParams - all the required configuration for inference setup
-   * @param {Function} outputCb - to be called on any inference event ( started, new output, error, etc )
-   * @param {Function} transitionCb - to be called on addon state changes (LISTENING, IDLE, STOPPED, etc )
-   */
-  constructor (configurationParams, outputCb, transitionCb = null) {
-    this._handle = binding.createInstance(this, configurationParams, outputCb, transitionCb)
-  }
-
-  /**
-   *
-   * @param {Object} weightsData
-   * @param {String} weightsData.filename
-   * @param {Uint8Array} weightsData.contents
-   * @param {Boolean} weightsData.completed
-   */
-  async loadWeights (weightsData) {
-    try {
-      binding.loadWeights(this._handle, weightsData)
-    } catch (err) {
-      throw new QvacErrorDecoderAudio(
-        ERR_CODES.FAILED_TO_LOAD_WEIGHTS,
-        err.message
-      )
-    }
-  }
-
-  /**
-   * Moves addon to the LISTENING state after all the initialization is done
-   */
-  async activate () {
-    try {
-      binding.activate(this._handle)
-    } catch (err) {
-      throw new QvacErrorDecoderAudio(
-        ERR_CODES.FAILED_TO_ACTIVATE,
-        err.message
-      )
-    }
-  }
-
-  /**
-   * Pauses current inference process
-   */
-  async pause () {
-    try {
-      binding.pause(this._handle)
-    } catch (err) {
-      throw new QvacErrorDecoderAudio(
-        ERR_CODES.FAILED_TO_PAUSE,
-        err.message
-      )
-    }
-  }
-
-  /**
-   * Cancel a inference process by jobId, if no jobId is provided it cancel the whole queue
-   */
-  async cancel (jobId) {
-    try {
-      binding.cancel(this._handle, jobId)
-    } catch (err) {
-      throw new QvacErrorDecoderAudio(
-        ERR_CODES.FAILED_TO_CANCEL,
-        err.message
-      )
-    }
-  }
-
-  /**
-   * Adds new input to the processing queue
-   * @param {Object} data
-   * @param {String} data.type
-   * @param {String} data.input
-   * @returns {Number} - job ID
-   */
-  async append (data) {
-    try {
-      return binding.append(this._handle, data)
-    } catch (err) {
-      throw new QvacErrorDecoderAudio(
-        ERR_CODES.FAILED_TO_APPEND,
-        err.message
-      )
-    }
-  }
-
-  /**
-   * Addon process status
-   * @returns {String}
-   */
-  async status () {
-    try {
-      return binding.status(this._handle)
-    } catch (err) {
-      throw new QvacErrorDecoderAudio(
-        ERR_CODES.FAILED_TO_GET_STATUS,
-        err.message
-      )
-    }
-  }
-
-  /**
-   * Stops addon process and clears resources (including memory).
-   */
-  async destroy () {
-    try {
-      binding.destroyInstance(this._handle)
-      this._handle = null
-    } catch (err) {
-      throw new QvacErrorDecoderAudio(
-        ERR_CODES.FAILED_TO_DESTROY,
-        err.message
-      )
-    }
-  }
-}
-
-module.exports = {
-  GSTDecoderInterface
-}