webcodecs-node 0.2.2 → 0.5.0

package/dist/encoders/AudioEncoder.d.ts

@@ -2,9 +2,10 @@
  * AudioEncoder - Encodes AudioData into EncodedAudioChunks
  * https://developer.mozilla.org/en-US/docs/Web/API/AudioEncoder
  */
-import { EventEmitter } from 'events';
+import { WebCodecsEventTarget } from '../utils/event-target.js';
 import { AudioData } from '../core/AudioData.js';
 import { EncodedAudioChunk } from '../core/EncodedAudioChunk.js';
+type EventHandler = ((event: Event) => void) | null;
 export type CodecState = 'unconfigured' | 'configured' | 'closed';
 export interface AudioEncoderConfig {
     codec: string;
@@ -31,24 +32,28 @@ export interface AudioEncoderSupport {
     supported: boolean;
     config: AudioEncoderConfig;
 }
-export declare class AudioEncoder extends EventEmitter {
+export declare class AudioEncoder extends WebCodecsEventTarget {
     private _state;
     private _encodeQueueSize;
     private _config;
     private _outputCallback;
     private _errorCallback;
-    private _process;
+    private _encoder;
     private _frameCount;
     private _firstChunk;
-    private _accumulatedData;
     private _ffmpegCodec;
     private _bitstreamFormat;
     private _codecDescription;
+    private _ondequeue;
     constructor(init: AudioEncoderInit);
     get state(): CodecState;
     get encodeQueueSize(): number;
-    private get _isProcessHealthy();
+    /** Event handler called when encodeQueueSize decreases */
+    get ondequeue(): EventHandler;
+    set ondequeue(handler: EventHandler);
     private _safeErrorCallback;
+    /** Fire the dequeue event (both EventTarget and ondequeue handler) */
+    private _fireDequeueEvent;
     private _safeOutputCallback;
     static isConfigSupported(config: AudioEncoderConfig): Promise<AudioEncoderSupport>;
     configure(config: AudioEncoderConfig): void;
@@ -56,14 +61,10 @@ export declare class AudioEncoder extends EventEmitter {
     flush(timeout?: number): Promise<void>;
     reset(): void;
     close(): void;
-    private _startFFmpeg;
-    private _stopFFmpeg;
+    private _startEncoder;
+    private _stopEncoder;
+    private _handleEncodedFrame;
     private _audioDataToPCM;
-    private _parseEncodedFrames;
-    private _findFrameEnd;
-    private _findADTSFrame;
-    private _findMP3Frame;
-    private _findOggPage;
-    private _emitChunk;
 }
+export {};
 //# sourceMappingURL=AudioEncoder.d.ts.map

package/dist/encoders/AudioEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AudioEncoder.d.ts","sourceRoot":"","sources":["../../src/encoders/AudioEncoder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAcjE,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,YAAY,GAAG,QAAQ,CAAC;AAElE,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IACtC,WAAW,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IACrC,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,QAAQ,CAAC,EAAE,0BAA0B,KAAK,IAAI,CAAC;IAClF,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,aAAa,CAAC,EAAE;QACd,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,CAAC,EAAE,UAAU,CAAC;KAC1B,CAAC;CACH;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,kBAAkB,CAAC;CAC5B;AAID,qBAAa,YAAa,SAAQ,YAAY;IAC5C,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,eAAe,CAA4E;IACnG,OAAO,CAAC,cAAc,CAAyB;IAC/C,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,gBAAgB,CAA2B;IACnD,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,iBAAiB,CAA2B;gBAExC,IAAI,EAAE,gBAAgB;IAclC,IAAI,KAAK,IAAI,UAAU,CAAwB;IAC/C,IAAI,eAAe,IAAI,MAAM,CAAkC;IAE/D,OAAO,KAAK,iBAAiB,GAE5B;IAED,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,mBAAmB;WAQd,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAWxF,SAAS,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IAiD3C,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IA6BvB,KAAK,CAAC,OAAO,GAAE,MAA8B,GAAG,OAAO,CAAC,IAAI,CAAC;IAqDnE,KAAK,IAAI,IAAI;IAeb,KAAK,IAAI,IAAI;IAUb,OAAO,CAAC,YAAY;IA8DpB,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,eAAe;IA+BvB,OAAO,CAAC,mBAAmB;IAgB3B,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,aAAa;IAgCrB,OAAO,CAAC,YAAY;IAyBpB,OAAO,CAAC,UAAU;CA8CnB"}
+{"version":3,"file":"AudioEncoder.d.ts","sourceRoot":"","sources":["../../src/encoders/AudioEncoder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAGjE,KAAK,YAAY,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;AAiBpD,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,YAAY,GAAG,QAAQ,CAAC;AAElE,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IACtC,WAAW,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IACrC,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,QAAQ,CAAC,EAAE,0BAA0B,KAAK,IAAI,CAAC;IAClF,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,aAAa,CAAC,EAAE;QACd,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,CAAC,EAAE,UAAU,CAAC;KAC1B,CAAC;CACH;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,kBAAkB,CAAC;CAC5B;AAKD,qBAAa,YAAa,SAAQ,oBAAoB;IACpD,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,eAAe,CAA4E;IACnG,OAAO,CAAC,cAAc,CAAyB;IAC/C,OAAO,CAAC,QAAQ,CAAmC;IACnD,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,iBAAiB,CAA2B;IACpD,OAAO,CAAC,UAAU,CAA6B;gBAEnC,IAAI,EAAE,gBAAgB;IAclC,IAAI,KAAK,IAAI,UAAU,CAAwB;IAC/C,IAAI,eAAe,IAAI,MAAM,CAAkC;IAE/D,0DAA0D;IAC1D,IAAI,SAAS,IAAI,YAAY,CAA4B;IACzD,IAAI,SAAS,CAAC,OAAO,EAAE,YAAY,EAAgC;IAEnE,OAAO,CAAC,kBAAkB;IAQ1B,sEAAsE;IACtE,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,mBAAmB;WAQd,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAWxF,SAAS,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IAwC3C,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IAqDvB,KAAK,CAAC,OAAO,GAAE,MAA8B,GAAG,OAAO,CAAC,IAAI,CAAC;IAoDnE,KAAK,IAAI,IAAI;IAcb,KAAK,IAAI,IAAI;IAUb,OAAO,CAAC,aAAa;IA8BrB,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,mBAAmB;IAqD3B,OAAO,CAAC,eAAe;CAoCxB"}

package/dist/encoders/AudioEncoder.js

@@ -2,29 +2,31 @@
  * AudioEncoder - Encodes AudioData into EncodedAudioChunks
  * https://developer.mozilla.org/en-US/docs/Web/API/AudioEncoder
  */
-import { EventEmitter } from 'events';
-import { spawn } from 'child_process';
+import { WebCodecsEventTarget } from '../utils/event-target.js';
 import { AudioData } from '../core/AudioData.js';
 import { EncodedAudioChunk } from '../core/EncodedAudioChunk.js';
 import { DOMException } from '../types/index.js';
-import { createLogger } from '../utils/index.js';
-import { getAudioEncoderCodec, getAudioEncoderFormat, getAudioFrameSize, AUDIO_ENCODER_CODEC_MAP, } from '../ffmpeg/audio-codecs.js';
+import { getAudioEncoderCodec, getAudioFrameSize, AUDIO_ENCODER_CODEC_MAP, } from '../codec-utils/audio-codecs.js';
 import { buildAudioSpecificConfig, stripAdtsHeader } from '../utils/aac.js';
-const logger = createLogger('AudioEncoder');
+import { NodeAvAudioEncoder } from '../node-av/NodeAvAudioEncoder.js';
+import { validateNonEmptyString, validatePositiveInteger, validateRequired, } from '../utils/validation.js';
+import { getCodecBase } from '../utils/codec-cache.js';
+import { encodingError, wrapAsWebCodecsError } from '../utils/errors.js';
 const DEFAULT_FLUSH_TIMEOUT = 30000;
-export class AudioEncoder extends EventEmitter {
+const MAX_QUEUE_SIZE = 100; // Prevent unbounded memory growth
+export class AudioEncoder extends WebCodecsEventTarget {
     _state = 'unconfigured';
     _encodeQueueSize = 0;
     _config = null;
     _outputCallback;
     _errorCallback;
-    _process = null;
+    _encoder = null;
     _frameCount = 0;
     _firstChunk = true;
-    _accumulatedData = Buffer.alloc(0);
     _ffmpegCodec = '';
     _bitstreamFormat = 'adts';
     _codecDescription = null;
+    _ondequeue = null;
     constructor(init) {
         super();
         if (!init || typeof init.output !== 'function') {
@@ -38,9 +40,9 @@ export class AudioEncoder extends EventEmitter {
     }
     get state() { return this._state; }
     get encodeQueueSize() { return this._encodeQueueSize; }
-    get _isProcessHealthy() {
-        return this._process !== null && this._process.stdin?.writable === true;
-    }
+    /** Event handler called when encodeQueueSize decreases */
+    get ondequeue() { return this._ondequeue; }
+    set ondequeue(handler) { this._ondequeue = handler; }
     _safeErrorCallback(error) {
         try {
             this._errorCallback(error);
@@ -49,19 +51,31 @@ export class AudioEncoder extends EventEmitter {
             this.emit('callbackError', error);
         }
     }
+    /** Fire the dequeue event (both EventTarget and ondequeue handler) */
+    _fireDequeueEvent() {
+        this.emit('dequeue');
+        if (this._ondequeue) {
+            try {
+                this._ondequeue(new Event('dequeue'));
+            }
+            catch {
+                // Ignore errors in user handler per spec
+            }
+        }
+    }
     _safeOutputCallback(chunk, metadata) {
         try {
             this._outputCallback(chunk, metadata);
         }
         catch (err) {
-            this._safeErrorCallback(err instanceof Error ? err : new Error(String(err)));
+            this._safeErrorCallback(wrapAsWebCodecsError(err, 'EncodingError'));
         }
     }
     static async isConfigSupported(config) {
         if (!config.codec || !config.sampleRate || !config.numberOfChannels) {
             return { supported: false, config };
         }
-        const codecBase = config.codec.split('.')[0].toLowerCase();
+        const codecBase = getCodecBase(config.codec);
         const supported = codecBase in AUDIO_ENCODER_CODEC_MAP || config.codec in AUDIO_ENCODER_CODEC_MAP;
         return { supported, config };
     }
@@ -69,18 +83,13 @@ export class AudioEncoder extends EventEmitter {
         if (this._state === 'closed') {
             throw new DOMException('Encoder is closed', 'InvalidStateError');
         }
-        if (!config || typeof config !== 'object') {
+        validateRequired(config, 'config');
+        if (typeof config !== 'object') {
             throw new TypeError('config must be an object');
         }
-        if (typeof config.codec !== 'string' || config.codec.length === 0) {
-            throw new TypeError('codec must be a non-empty string');
-        }
-        if (typeof config.sampleRate !== 'number' || config.sampleRate <= 0 || !Number.isInteger(config.sampleRate)) {
-            throw new TypeError('sampleRate must be a positive integer');
-        }
-        if (typeof config.numberOfChannels !== 'number' || config.numberOfChannels <= 0 || !Number.isInteger(config.numberOfChannels)) {
-            throw new TypeError('numberOfChannels must be a positive integer');
-        }
+        validateNonEmptyString(config.codec, 'codec');
+        validatePositiveInteger(config.sampleRate, 'sampleRate');
+        validatePositiveInteger(config.numberOfChannels, 'numberOfChannels');
         if (config.bitrate !== undefined && (typeof config.bitrate !== 'number' || config.bitrate <= 0)) {
             throw new TypeError('bitrate must be a positive number');
         }
@@ -94,18 +103,14 @@ export class AudioEncoder extends EventEmitter {
         if (!ffmpegCodec) {
             throw new DOMException(`Codec '${config.codec}' is not supported`, 'NotSupportedError');
         }
-        if (this._process) {
-            this._process.kill();
-            this._process = null;
-        }
+        this._stopEncoder();
         this._config = { ...config };
         this._state = 'configured';
         this._frameCount = 0;
         this._firstChunk = true;
-        this._accumulatedData = Buffer.alloc(0);
         this._bitstreamFormat = config.format ?? 'adts';
         this._codecDescription = null;
-        this._startFFmpeg();
+        this._startEncoder();
     }
     encode(data) {
         if (this._state !== 'configured') {
@@ -114,18 +119,39 @@ export class AudioEncoder extends EventEmitter {
         if (!(data instanceof AudioData)) {
             throw new TypeError('data must be an AudioData');
         }
-        if (!this._isProcessHealthy) {
-            this._safeErrorCallback(new Error('Encoder process is not healthy'));
+        if (!this._encoder?.isHealthy) {
+            this._safeErrorCallback(encodingError('Encoder is not healthy'));
+            return;
+        }
+        // Check queue saturation to prevent unbounded memory growth
+        if (this._encodeQueueSize >= MAX_QUEUE_SIZE) {
+            this._safeErrorCallback(new DOMException(`Encoder queue saturated (${MAX_QUEUE_SIZE} frames pending). Wait for dequeue events before encoding more frames.`, 'QuotaExceededError'));
             return;
         }
         this._encodeQueueSize++;
-        const pcmData = this._audioDataToPCM(data);
-        try {
-            this._process.stdin.write(pcmData);
+        const nativeFrame = data._native ?? null;
+        let writeSuccess = false;
+        if (nativeFrame && typeof this._encoder.writeFrame === 'function') {
+            const clone = typeof nativeFrame.clone === 'function' ? nativeFrame.clone() : null;
+            const frameForEncode = clone ?? nativeFrame;
+            try {
+                writeSuccess = this._encoder.writeFrame(frameForEncode, true);
+            }
+            catch {
+                writeSuccess = false;
+            }
+            if (!writeSuccess) {
+                const pcmData = this._audioDataToPCM(data);
+                writeSuccess = this._encoder.write(pcmData);
+            }
         }
-        catch {
+        else {
+            const pcmData = this._audioDataToPCM(data);
+            writeSuccess = this._encoder.write(pcmData);
+        }
+        if (!writeSuccess) {
             this._encodeQueueSize = Math.max(0, this._encodeQueueSize - 1);
-            this._safeErrorCallback(new Error('Failed to write audio data to encoder'));
+            this._safeErrorCallback(encodingError('Failed to write audio data to encoder'));
             return;
         }
         this._frameCount += data.numberOfFrames;
@@ -135,7 +161,7 @@ export class AudioEncoder extends EventEmitter {
             throw new DOMException('Encoder is not configured', 'InvalidStateError');
         }
         return new Promise((resolve, reject) => {
-            if (!this._process) {
+            if (!this._encoder) {
                 resolve();
                 return;
             }
@@ -155,10 +181,9 @@ export class AudioEncoder extends EventEmitter {
                 this._encodeQueueSize = 0;
                 this._frameCount = 0;
                 this._firstChunk = true;
-                this._accumulatedData = Buffer.alloc(0);
-                this._process = null;
+                this._encoder = null;
                 if (this._config) {
-                    this._startFFmpeg();
+                    this._startEncoder();
                 }
                 resolve();
             };
@@ -172,227 +197,83 @@ export class AudioEncoder extends EventEmitter {
             timeoutId = setTimeout(() => {
                 doReject(new DOMException('Flush operation timed out', 'TimeoutError'));
             }, timeout);
-            this._process.once('close', doResolve);
-            this._process.once('error', doReject);
-            this._process.stdin?.end();
+            this._encoder.once('close', doResolve);
+            this._encoder.once('error', doReject);
+            this._encoder.end();
         });
     }
     reset() {
         if (this._state === 'closed') {
             throw new DOMException('Encoder is closed', 'InvalidStateError');
         }
-        this._stopFFmpeg();
+        this._stopEncoder();
         this._state = 'unconfigured';
         this._config = null;
         this._encodeQueueSize = 0;
         this._frameCount = 0;
         this._firstChunk = true;
-        this._accumulatedData = Buffer.alloc(0);
         this._codecDescription = null;
     }
     close() {
         if (this._state === 'closed')
             return;
-        this._stopFFmpeg();
+        this._stopEncoder();
         this._state = 'closed';
         this._config = null;
         this._encodeQueueSize = 0;
         this._codecDescription = null;
     }
-    _startFFmpeg() {
+    _startEncoder() {
         if (!this._config)
             return;
-        // Codec was already validated in configure(), so we can safely use a fallback here
         this._ffmpegCodec = getAudioEncoderCodec(this._config.codec) || 'aac';
-        const format = getAudioEncoderFormat(this._ffmpegCodec);
-        const args = [
-            '-hide_banner', '-loglevel', 'error',
-            '-f', 'f32le',
-            '-ar', String(this._config.sampleRate),
-            '-ac', String(this._config.numberOfChannels),
-            '-i', 'pipe:0',
-            '-c:a', this._ffmpegCodec,
-        ];
-        if (this._config.bitrate) {
-            args.push('-b:a', String(this._config.bitrate));
-        }
-        const isRealtime = this._config.latencyMode === 'realtime';
-        if (this._ffmpegCodec === 'libopus') {
-            args.push('-application', isRealtime ? 'voip' : 'audio');
-            if (isRealtime) {
-                args.push('-frame_duration', '10');
-            }
-            if (this._config.sampleRate !== 48000) {
-                args.push('-ar', '48000');
-            }
-        }
-        else if (this._ffmpegCodec === 'aac') {
-            if (isRealtime) {
-                args.push('-profile:a', 'aac_low');
-            }
-        }
-        args.push('-f', format, 'pipe:1');
-        this._process = spawn('ffmpeg', args, { stdio: ['pipe', 'pipe', 'pipe'] });
-        this._process.stdout?.on('data', (data) => {
-            this._accumulatedData = Buffer.concat([this._accumulatedData, data]);
-            this._parseEncodedFrames();
+        this._encoder = new NodeAvAudioEncoder();
+        this._encoder.startEncoder({
+            codec: this._config.codec,
+            sampleRate: this._config.sampleRate,
+            numberOfChannels: this._config.numberOfChannels,
+            bitrate: this._config.bitrate,
+            bitrateMode: this._config.bitrateMode,
+            latencyMode: this._config.latencyMode,
         });
-        this._process.stderr?.on('data', (data) => {
-            const msg = data.toString();
-            if (!msg.includes('Discarding ID3')) {
-                logger.warn('FFmpeg stderr', { message: msg });
-            }
+        this._encoder.on('encodedFrame', (frame) => {
+            this._handleEncodedFrame(frame);
         });
-        this._process.on('close', () => {
-            if (this._accumulatedData.length > 0) {
-                this._emitChunk(this._accumulatedData, 'key');
-                this._accumulatedData = Buffer.alloc(0);
-            }
+        this._encoder.on('frameAccepted', () => {
+            // Frame has started processing - decrement queue and fire dequeue event
+            this._encodeQueueSize = Math.max(0, this._encodeQueueSize - 1);
+            this._fireDequeueEvent();
+        });
+        this._encoder.on('error', (err) => {
+            this._safeErrorCallback(err);
         });
-        this._process.stdin?.on('error', () => { });
-    }
-    _stopFFmpeg() {
-        if (this._process) {
-            this._process.kill('SIGTERM');
-            this._process = null;
-        }
-    }
-    _audioDataToPCM(data) {
-        const numFrames = data.numberOfFrames;
-        const numChannels = data.numberOfChannels;
-        const bufferSize = numFrames * numChannels * 4;
-        const buffer = Buffer.alloc(bufferSize);
-        const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        const isPlanar = data.format.endsWith('-planar');
-        const tempBuffer = new Float32Array(numFrames);
-        if (isPlanar) {
-            for (let ch = 0; ch < numChannels; ch++) {
-                data.copyTo(new Uint8Array(tempBuffer.buffer), {
-                    planeIndex: ch,
-                    format: 'f32-planar',
-                });
-                for (let frame = 0; frame < numFrames; frame++) {
-                    const offset = (frame * numChannels + ch) * 4;
-                    view.setFloat32(offset, tempBuffer[frame], true);
-                }
-            }
-        }
-        else {
-            const srcBuffer = new Uint8Array(bufferSize);
-            data.copyTo(srcBuffer, { planeIndex: 0, format: 'f32' });
-            buffer.set(srcBuffer);
-        }
-        return buffer;
-    }
-    _parseEncodedFrames() {
-        const minChunkSize = 64;
-        while (this._accumulatedData.length >= minChunkSize) {
-            let frameEnd = this._findFrameEnd();
-            if (frameEnd > 0) {
-                const frameData = Buffer.from(this._accumulatedData.subarray(0, frameEnd));
-                this._accumulatedData = this._accumulatedData.subarray(frameEnd);
-                this._emitChunk(frameData, 'key');
-            }
-            else {
-                break;
-            }
-        }
-    }
-    _findFrameEnd() {
-        if (this._ffmpegCodec === 'aac') {
-            return this._findADTSFrame();
-        }
-        else if (this._ffmpegCodec === 'libmp3lame') {
-            return this._findMP3Frame();
-        }
-        else if (this._ffmpegCodec === 'libopus' || this._ffmpegCodec === 'libvorbis') {
-            return this._findOggPage();
-        }
-        else {
-            return Math.min(this._accumulatedData.length, 4096);
-        }
-    }
-    _findADTSFrame() {
-        if (this._accumulatedData.length < 7)
-            return 0;
-        if ((this._accumulatedData[0] !== 0xFF) || ((this._accumulatedData[1] & 0xF0) !== 0xF0)) {
-            for (let i = 1; i < this._accumulatedData.length - 1; i++) {
-                if (this._accumulatedData[i] === 0xFF && (this._accumulatedData[i + 1] & 0xF0) === 0xF0) {
-                    this._accumulatedData = this._accumulatedData.subarray(i);
-                    return 0;
-                }
-            }
-            return 0;
-        }
-        const frameLength = ((this._accumulatedData[3] & 0x03) << 11) |
-            (this._accumulatedData[4] << 3) |
-            ((this._accumulatedData[5] & 0xE0) >> 5);
-        if (frameLength > this._accumulatedData.length)
-            return 0;
-        return frameLength;
     }
-    _findMP3Frame() {
-        if (this._accumulatedData.length < 4)
-            return 0;
-        if (this._accumulatedData[0] !== 0xFF || (this._accumulatedData[1] & 0xE0) !== 0xE0) {
-            for (let i = 1; i < this._accumulatedData.length - 1; i++) {
-                if (this._accumulatedData[i] === 0xFF && (this._accumulatedData[i + 1] & 0xE0) === 0xE0) {
-                    this._accumulatedData = this._accumulatedData.subarray(i);
-                    return 0;
-                }
-            }
-            return 0;
+    _stopEncoder() {
+        if (this._encoder) {
+            this._encoder.kill();
+            this._encoder = null;
         }
-        const header = this._accumulatedData.readUInt32BE(0);
-        const bitrateIndex = (header >> 12) & 0x0F;
-        const samplingRateIndex = (header >> 10) & 0x03;
-        const padding = (header >> 9) & 0x01;
-        const bitrates = [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0];
-        const sampleRates = [44100, 48000, 32000, 0];
-        const bitrate = bitrates[bitrateIndex] * 1000;
-        const sampleRate = sampleRates[samplingRateIndex];
-        if (bitrate === 0 || sampleRate === 0)
-            return 0;
-        const frameSize = Math.floor((144 * bitrate) / sampleRate) + padding;
-        if (frameSize > this._accumulatedData.length)
-            return 0;
-        return frameSize;
     }
-    _findOggPage() {
-        if (this._accumulatedData.length < 27)
-            return 0;
-        if (this._accumulatedData.toString('ascii', 0, 4) !== 'OggS') {
-            for (let i = 1; i < this._accumulatedData.length - 3; i++) {
-                if (this._accumulatedData.toString('ascii', i, i + 4) === 'OggS') {
-                    this._accumulatedData = this._accumulatedData.subarray(i);
-                    return 0;
-                }
-            }
-            return this._accumulatedData.length;
-        }
-        const numSegments = this._accumulatedData[26];
-        if (this._accumulatedData.length < 27 + numSegments)
-            return 0;
-        let pageSize = 27 + numSegments;
-        for (let i = 0; i < numSegments; i++) {
-            pageSize += this._accumulatedData[27 + i];
-        }
-        if (pageSize > this._accumulatedData.length)
-            return 0;
-        return pageSize;
-    }
-    _emitChunk(data, type) {
-        if (!this._config || data.length === 0)
+    _handleEncodedFrame(frame) {
+        if (!this._config)
             return;
         const samplesPerFrame = getAudioFrameSize(this._ffmpegCodec) || 1024;
-        const timestamp = (this._frameCount * 1_000_000) / this._config.sampleRate;
+        // Use timestamp from backend (in samples) converted to microseconds
+        // Clamp to non-negative (AAC encoder has priming delay causing negative initial timestamps)
+        const timestamp = Math.max(0, (frame.timestamp * 1_000_000) / this._config.sampleRate);
         const duration = (samplesPerFrame * 1_000_000) / this._config.sampleRate;
-        let payload = data;
-        const codecBase = this._config.codec.split('.')[0].toLowerCase();
+        let payload = frame.data;
+        const codecBase = getCodecBase(this._config.codec);
         const isAac = codecBase === 'mp4a' || codecBase === 'aac';
+        // Use description from backend if provided (AAC, FLAC, Vorbis, etc.)
+        // For AAC, the backend provides proper AudioSpecificConfig with correct channelConfiguration
+        if (frame.description && !this._codecDescription) {
+            this._codecDescription = new Uint8Array(frame.description);
+        }
         if (this._bitstreamFormat === 'aac' && isAac) {
-            const stripped = stripAdtsHeader(new Uint8Array(data));
+            const stripped = stripAdtsHeader(new Uint8Array(frame.data));
             payload = Buffer.from(stripped);
+            // Only build AudioSpecificConfig if backend didn't provide one
             if (!this._codecDescription) {
                 this._codecDescription = buildAudioSpecificConfig({
                     samplingRate: this._config.sampleRate,
@@ -401,13 +282,11 @@ export class AudioEncoder extends EventEmitter {
             }
         }
         const chunk = new EncodedAudioChunk({
-            type,
+            type: frame.keyFrame ? 'key' : 'delta',
             timestamp,
             duration,
             data: new Uint8Array(payload),
         });
-        this._encodeQueueSize = Math.max(0, this._encodeQueueSize - 1);
-        this.emit('dequeue');
         const metadata = this._firstChunk
             ? {
                 decoderConfig: {
@@ -421,5 +300,36 @@ export class AudioEncoder extends EventEmitter {
         this._firstChunk = false;
         this._safeOutputCallback(chunk, metadata);
     }
+    _audioDataToPCM(data) {
+        const numFrames = data.numberOfFrames;
+        const numChannels = data.numberOfChannels;
+        const format = data.format;
+        if (!format) {
+            throw encodingError('Cannot convert closed AudioData to PCM');
+        }
+        const bufferSize = numFrames * numChannels * 4;
+        const buffer = Buffer.alloc(bufferSize);
+        const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        const isPlanar = format.endsWith('-planar');
+        const tempBuffer = new Float32Array(numFrames);
+        if (isPlanar) {
+            for (let ch = 0; ch < numChannels; ch++) {
+                data.copyTo(new Uint8Array(tempBuffer.buffer), {
+                    planeIndex: ch,
+                    format: 'f32-planar',
+                });
+                for (let frame = 0; frame < numFrames; frame++) {
+                    const offset = (frame * numChannels + ch) * 4;
+                    view.setFloat32(offset, tempBuffer[frame], true);
+                }
+            }
+        }
+        else {
+            const srcBuffer = new Uint8Array(bufferSize);
+            data.copyTo(srcBuffer, { planeIndex: 0, format: 'f32' });
+            buffer.set(srcBuffer);
+        }
+        return buffer;
+    }
 }
 //# sourceMappingURL=AudioEncoder.js.map