@qvac/decoder-audio 0.2.10 → 0.3.1

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 }