@qvac/decoder-audio 0.5.0 → 0.6.0

package/constants.d.ts

@@ -1,9 +1,8 @@
 /**
  * Audio formats that require decoding before processing
  */
-export const FORMATS_NEEDING_DECODE: readonly string[]
-
+export declare const FORMATS_NEEDING_DECODE: readonly string[];
 /**
  * All supported audio formats (including raw)
  */
-export const SUPPORTED_AUDIO_FORMATS: readonly string[]
+export declare const SUPPORTED_AUDIO_FORMATS: readonly string[];

package/constants.js

@@ -1,31 +1,26 @@
-'use strict'
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_AUDIO_FORMATS = exports.FORMATS_NEEDING_DECODE = void 0;
 /**
  * Audio formats that require decoding before processing
  */
-const FORMATS_NEEDING_DECODE = [
-  '.mp3',
-  '.m4a',
-  '.ogg',
-  '.flac',
-  '.aac',
-  '.wav'
-]
-
+exports.FORMATS_NEEDING_DECODE = [
+    ".mp3",
+    ".m4a",
+    ".ogg",
+    ".flac",
+    ".aac",
+    ".wav",
+];
 /**
  * All supported audio formats (including raw)
  */
-const SUPPORTED_AUDIO_FORMATS = [
-  '.mp3',
-  '.m4a',
-  '.ogg',
-  '.wav',
-  '.flac',
-  '.aac',
-  '.raw'
-]
-
-module.exports = {
-  FORMATS_NEEDING_DECODE,
-  SUPPORTED_AUDIO_FORMATS
-}
+exports.SUPPORTED_AUDIO_FORMATS = [
+    ".mp3",
+    ".m4a",
+    ".ogg",
+    ".wav",
+    ".flac",
+    ".aac",
+    ".raw",
+];

package/index.d.ts

@@ -1,56 +1,108 @@
-import { QvacResponse } from '@qvac/infer-base'
-
-interface AudioFormatConfig {
-  format: number | null
-  byteLength: number
-}
-
-interface SupportedAudioFormats {
-  s16le: AudioFormatConfig
-  f32le: AudioFormatConfig
-}
-
-interface FFmpegDecoderConfig {
-  streamIndex?: number
-  inputBitrate?: number
-  audioFormat?: 's16le' | 'f32le'
-  sampleRate?: number
-}
-
-interface FFmpegDecoderConstructorParams {
-  config?: FFmpegDecoderConfig
-  logger?: any
-  streamIndex?: number
-  inputBitrate?: number
-  audioFormat?: 's16le' | 'f32le'
-}
-
+import QvacLogger = require("@qvac/logging");
+import { type QvacResponse } from "@qvac/infer-base";
+/** Output sample formats this decoder can resample to. */
+export type AudioFormatName = "s16le" | "f32le";
+export interface AudioFormatConfig {
+    /** FFmpeg sample format id. Null until `load()` resolves it from `ffmpeg.constants`. */
+    format: number | null;
+    byteLength: number;
+}
+export interface SupportedAudioFormats {
+    s16le: AudioFormatConfig;
+    f32le: AudioFormatConfig;
+}
+export interface FFmpegDecoderConfig {
+    /** Index of the stream to decode (default: 0) */
+    streamIndex?: number;
+    /** Input audio bitrate (default: 192000) */
+    inputBitrate?: number;
+    /** Output audio format (default: 's16le') */
+    audioFormat?: AudioFormatName;
+    /** Output sample rate (default: 16000) */
+    sampleRate?: number;
+}
+export interface FFmpegDecoderConstructorParams {
+    config?: FFmpegDecoderConfig;
+    logger?: QvacLogger.LoggerInterface | null;
+    streamIndex?: number;
+    inputBitrate?: number;
+    audioFormat?: AudioFormatName;
+}
 export interface DecoderOutput {
-  outputArray: ArrayBuffer
-}
-
-interface RuntimeStats {
-  decodeTimeMs: number
-  inputBytes: number
-  outputBytes: number
-  samplesDecoded: number
-  codecName: string | null
-  inputSampleRate: number
-  outputSampleRate: number
-  audioFormat: 's16le' | 'f32le'
-}
-
+    /** Raw interleaved PCM in the configured output format. */
+    outputArray: Buffer;
+}
+export interface RuntimeStats {
+    decodeTimeMs: number;
+    inputBytes: number;
+    outputBytes: number;
+    samplesDecoded: number;
+    codecName: string | null;
+    inputSampleRate: number;
+    outputSampleRate: number;
+    audioFormat: AudioFormatName;
+}
+/** Constructor arguments after defaults have been applied. */
+interface ResolvedConfig {
+    streamIndex: number;
+    inputBitrate: number;
+    audioFormat: AudioFormatName;
+    sampleRate: number;
+}
+/**
+ * FFmpeg-based audio decoder (single-threaded)
+ */
 declare class FFmpegDecoder {
-  SUPPORTED_AUDIO_FORMATS: SupportedAudioFormats
-  OUTPUT_CHANNEL_LAYOUT: number | null
-
-  constructor(params?: FFmpegDecoderConstructorParams)
-
-  load(): Promise<void>
-  unload(): Promise<void>
-  run(audioStream: AsyncIterable<Buffer>): QvacResponse<DecoderOutput>
-
-  runtimeStats(): RuntimeStats
-}
-
-export { FFmpegDecoder, RuntimeStats, DecoderOutput }
+    SUPPORTED_AUDIO_FORMATS: SupportedAudioFormats;
+    OUTPUT_CHANNEL_LAYOUT: number | null;
+    config: ResolvedConfig;
+    logger: QvacLogger;
+    isLoaded: boolean;
+    samplesSkipped: number;
+    totalSkipSamples: number;
+    private _cancelled;
+    private readonly _job;
+    private _runtimeStats;
+    /**
+     * Creates an instance of FFmpegDecoder.
+     * @param params - Configuration options. Top-level `streamIndex`, `inputBitrate`
+     *   and `audioFormat` act as fallbacks for the matching `config` fields.
+     */
+    constructor({ config, logger, streamIndex, inputBitrate, audioFormat, }?: FFmpegDecoderConstructorParams);
+    /**
+     * Resets the runtime stats
+     */
+    private _resetStats;
+    /**
+     * Get the current runtime stats
+     * @returns Current runtime stats
+     */
+    runtimeStats(): RuntimeStats;
+    /**
+     * Load and initialize the decoder
+     */
+    load(): Promise<void>;
+    /**
+     * Unload the decoder and clean up resources
+     */
+    unload(): Promise<void>;
+    /**
+     * Run the decoder on an audio stream
+     * @param audioStream - Input audio stream
+     * @returns Response with decoded audio
+     */
+    run(audioStream: AsyncIterable<Buffer>): QvacResponse<DecoderOutput>;
+    private _cancelCurrent;
+    private _getBufferSize;
+    /**
+     * Resolves the output constants populated by `load()`. Unreachable before
+     * `load()` succeeds, since every caller sits behind the `isLoaded` guard.
+     */
+    private _resolveOutputFormat;
+    private _processFrame;
+    private _processPacket;
+    private _processFFmpegStream;
+    private _collectStreamData;
+    private _processStream;
+}
+export { FFmpegDecoder };