webcodecs-node 0.2.2

package/dist/demos/demo.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Demo: WebCodecs API usage in Node.js
+ *
+ * This demo shows how to:
+ * 1. Create VideoFrames from raw pixel data
+ * 2. Encode frames to H.264
+ * 3. Decode encoded chunks back to frames
+ */
+export {};
+//# sourceMappingURL=demo.d.ts.map

package/dist/demos/demo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demo.d.ts","sourceRoot":"","sources":["../../src/demos/demo.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/demos/demo.js

@@ -0,0 +1,123 @@
+/**
+ * Demo: WebCodecs API usage in Node.js
+ *
+ * This demo shows how to:
+ * 1. Create VideoFrames from raw pixel data
+ * 2. Encode frames to H.264
+ * 3. Decode encoded chunks back to frames
+ */
+import { VideoFrame, VideoEncoder, VideoDecoder, } from '../index.js';
+async function main() {
+    console.log('WebCodecs Node.js Demo');
+    console.log('======================\n');
+    // Configuration
+    const width = 320;
+    const height = 240;
+    const frameCount = 30;
+    const framerate = 30;
+    const codec = 'vp09'; // VP9 - uses IVF container with per-frame parsing
+    // Check encoder support
+    const encoderSupport = await VideoEncoder.isConfigSupported({
+        codec,
+        width,
+        height,
+        bitrate: 1_000_000,
+        framerate,
+    });
+    console.log(`Encoder support for ${codec}: ${encoderSupport.supported}`);
+    // Check decoder support
+    const decoderSupport = await VideoDecoder.isConfigSupported({
+        codec,
+        codedWidth: width,
+        codedHeight: height,
+    });
+    console.log(`Decoder support for ${codec}: ${decoderSupport.supported}\n`);
+    // Storage for encoded chunks and decoded frames
+    const encodedChunks = [];
+    const decodedFrames = [];
+    // Create encoder
+    const encoder = new VideoEncoder({
+        output: (chunk, metadata) => {
+            console.log(`Encoded chunk: type=${chunk.type}, timestamp=${chunk.timestamp}, bytes=${chunk.byteLength}`);
+            if (metadata?.decoderConfig) {
+                console.log(`  Decoder config: ${JSON.stringify(metadata.decoderConfig)}`);
+            }
+            encodedChunks.push(chunk);
+        },
+        error: (err) => {
+            console.error('Encoder error:', err);
+        },
+    });
+    // Configure encoder
+    encoder.configure({
+        codec,
+        width,
+        height,
+        bitrate: 1_000_000,
+        framerate,
+    });
+    console.log('Encoder state:', encoder.state);
+    console.log(`\nEncoding ${frameCount} frames...`);
+    // Generate and encode frames
+    for (let i = 0; i < frameCount; i++) {
+        // Create a simple gradient frame (RGBA)
+        const frameData = new Uint8Array(width * height * 4);
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const idx = (y * width + x) * 4;
+                // Create a moving gradient pattern
+                frameData[idx] = (x + i * 10) % 256; // R
+                frameData[idx + 1] = (y + i * 5) % 256; // G
+                frameData[idx + 2] = (i * 8) % 256; // B
+                frameData[idx + 3] = 255; // A
+            }
+        }
+        const frame = new VideoFrame(frameData, {
+            format: 'RGBA',
+            codedWidth: width,
+            codedHeight: height,
+            timestamp: (i * 1_000_000) / framerate, // microseconds
+            duration: 1_000_000 / framerate,
+        });
+        encoder.encode(frame, { keyFrame: i % 30 === 0 });
+        frame.close();
+    }
+    // Flush encoder
+    console.log('Flushing encoder...');
+    await encoder.flush();
+    console.log(`Encoded ${encodedChunks.length} chunks\n`);
+    // Now decode the chunks
+    console.log('Creating decoder...');
+    const decoder = new VideoDecoder({
+        output: (frame) => {
+            console.log(`Decoded frame: ${frame.codedWidth}x${frame.codedHeight}, timestamp=${frame.timestamp}`);
+            decodedFrames.push(frame);
+        },
+        error: (err) => {
+            console.error('Decoder error:', err);
+        },
+    });
+    // Configure decoder
+    decoder.configure({
+        codec,
+        codedWidth: width,
+        codedHeight: height,
+    });
+    console.log('Decoder state:', decoder.state);
+    console.log(`\nDecoding ${encodedChunks.length} chunks...`);
+    // Decode all chunks
+    for (const chunk of encodedChunks) {
+        decoder.decode(chunk);
+    }
+    // Flush decoder
+    console.log('Flushing decoder...');
+    await decoder.flush();
+    console.log(`\nDecoded ${decodedFrames.length} frames`);
+    // Cleanup
+    encoder.close();
+    decoder.close();
+    decodedFrames.forEach((f) => f.close());
+    console.log('\nDemo complete!');
+}
+main().catch(console.error);
+//# sourceMappingURL=demo.js.map

package/dist/demos/demo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"demo.js","sourceRoot":"","sources":["../../src/demos/demo.ts"],"names":[],"mappings":"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"}

package/dist/encoders/AudioEncoder.d.ts

@@ -0,0 +1,69 @@
+/**
+ * AudioEncoder - Encodes AudioData into EncodedAudioChunks
+ * https://developer.mozilla.org/en-US/docs/Web/API/AudioEncoder
+ */
+import { EventEmitter } from 'events';
+import { AudioData } from '../core/AudioData.js';
+import { EncodedAudioChunk } from '../core/EncodedAudioChunk.js';
+export type CodecState = 'unconfigured' | 'configured' | 'closed';
+export interface AudioEncoderConfig {
+    codec: string;
+    sampleRate: number;
+    numberOfChannels: number;
+    bitrate?: number;
+    bitrateMode?: 'constant' | 'variable';
+    latencyMode?: 'quality' | 'realtime';
+    format?: 'adts' | 'aac';
+}
+export interface AudioEncoderInit {
+    output: (chunk: EncodedAudioChunk, metadata?: AudioEncoderOutputMetadata) => void;
+    error: (error: Error) => void;
+}
+export interface AudioEncoderOutputMetadata {
+    decoderConfig?: {
+        codec: string;
+        sampleRate: number;
+        numberOfChannels: number;
+        description?: Uint8Array;
+    };
+}
+export interface AudioEncoderSupport {
+    supported: boolean;
+    config: AudioEncoderConfig;
+}
+export declare class AudioEncoder extends EventEmitter {
+    private _state;
+    private _encodeQueueSize;
+    private _config;
+    private _outputCallback;
+    private _errorCallback;
+    private _process;
+    private _frameCount;
+    private _firstChunk;
+    private _accumulatedData;
+    private _ffmpegCodec;
+    private _bitstreamFormat;
+    private _codecDescription;
+    constructor(init: AudioEncoderInit);
+    get state(): CodecState;
+    get encodeQueueSize(): number;
+    private get _isProcessHealthy();
+    private _safeErrorCallback;
+    private _safeOutputCallback;
+    static isConfigSupported(config: AudioEncoderConfig): Promise<AudioEncoderSupport>;
+    configure(config: AudioEncoderConfig): void;
+    encode(data: AudioData): void;
+    flush(timeout?: number): Promise<void>;
+    reset(): void;
+    close(): void;
+    private _startFFmpeg;
+    private _stopFFmpeg;
+    private _audioDataToPCM;
+    private _parseEncodedFrames;
+    private _findFrameEnd;
+    private _findADTSFrame;
+    private _findMP3Frame;
+    private _findOggPage;
+    private _emitChunk;
+}
+//# sourceMappingURL=AudioEncoder.d.ts.map

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

@@ -0,0 +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"}

package/dist/encoders/AudioEncoder.js

@@ -0,0 +1,425 @@
+/**
+ * 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 { 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 { buildAudioSpecificConfig, stripAdtsHeader } from '../utils/aac.js';
+const logger = createLogger('AudioEncoder');
+const DEFAULT_FLUSH_TIMEOUT = 30000;
+export class AudioEncoder extends EventEmitter {
+    _state = 'unconfigured';
+    _encodeQueueSize = 0;
+    _config = null;
+    _outputCallback;
+    _errorCallback;
+    _process = null;
+    _frameCount = 0;
+    _firstChunk = true;
+    _accumulatedData = Buffer.alloc(0);
+    _ffmpegCodec = '';
+    _bitstreamFormat = 'adts';
+    _codecDescription = null;
+    constructor(init) {
+        super();
+        if (!init || typeof init.output !== 'function') {
+            throw new TypeError('output callback is required');
+        }
+        if (typeof init.error !== 'function') {
+            throw new TypeError('error callback is required');
+        }
+        this._outputCallback = init.output;
+        this._errorCallback = init.error;
+    }
+    get state() { return this._state; }
+    get encodeQueueSize() { return this._encodeQueueSize; }
+    get _isProcessHealthy() {
+        return this._process !== null && this._process.stdin?.writable === true;
+    }
+    _safeErrorCallback(error) {
+        try {
+            this._errorCallback(error);
+        }
+        catch {
+            this.emit('callbackError', error);
+        }
+    }
+    _safeOutputCallback(chunk, metadata) {
+        try {
+            this._outputCallback(chunk, metadata);
+        }
+        catch (err) {
+            this._safeErrorCallback(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    static async isConfigSupported(config) {
+        if (!config.codec || !config.sampleRate || !config.numberOfChannels) {
+            return { supported: false, config };
+        }
+        const codecBase = config.codec.split('.')[0].toLowerCase();
+        const supported = codecBase in AUDIO_ENCODER_CODEC_MAP || config.codec in AUDIO_ENCODER_CODEC_MAP;
+        return { supported, config };
+    }
+    configure(config) {
+        if (this._state === 'closed') {
+            throw new DOMException('Encoder is closed', 'InvalidStateError');
+        }
+        if (!config || 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');
+        }
+        if (config.bitrate !== undefined && (typeof config.bitrate !== 'number' || config.bitrate <= 0)) {
+            throw new TypeError('bitrate must be a positive number');
+        }
+        if (config.bitrateMode !== undefined && !['constant', 'variable'].includes(config.bitrateMode)) {
+            throw new TypeError("bitrateMode must be 'constant' or 'variable'");
+        }
+        if (config.latencyMode !== undefined && !['quality', 'realtime'].includes(config.latencyMode)) {
+            throw new TypeError("latencyMode must be 'quality' or 'realtime'");
+        }
+        const ffmpegCodec = getAudioEncoderCodec(config.codec);
+        if (!ffmpegCodec) {
+            throw new DOMException(`Codec '${config.codec}' is not supported`, 'NotSupportedError');
+        }
+        if (this._process) {
+            this._process.kill();
+            this._process = null;
+        }
+        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();
+    }
+    encode(data) {
+        if (this._state !== 'configured') {
+            throw new DOMException('Encoder is not configured', 'InvalidStateError');
+        }
+        if (!(data instanceof AudioData)) {
+            throw new TypeError('data must be an AudioData');
+        }
+        if (!this._isProcessHealthy) {
+            this._safeErrorCallback(new Error('Encoder process is not healthy'));
+            return;
+        }
+        this._encodeQueueSize++;
+        const pcmData = this._audioDataToPCM(data);
+        try {
+            this._process.stdin.write(pcmData);
+        }
+        catch {
+            this._encodeQueueSize = Math.max(0, this._encodeQueueSize - 1);
+            this._safeErrorCallback(new Error('Failed to write audio data to encoder'));
+            return;
+        }
+        this._frameCount += data.numberOfFrames;
+    }
+    async flush(timeout = DEFAULT_FLUSH_TIMEOUT) {
+        if (this._state !== 'configured') {
+            throw new DOMException('Encoder is not configured', 'InvalidStateError');
+        }
+        return new Promise((resolve, reject) => {
+            if (!this._process) {
+                resolve();
+                return;
+            }
+            let timeoutId = null;
+            let resolved = false;
+            const cleanup = () => {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+            };
+            const doResolve = () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                cleanup();
+                this._encodeQueueSize = 0;
+                this._frameCount = 0;
+                this._firstChunk = true;
+                this._accumulatedData = Buffer.alloc(0);
+                this._process = null;
+                if (this._config) {
+                    this._startFFmpeg();
+                }
+                resolve();
+            };
+            const doReject = (err) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                cleanup();
+                reject(err);
+            };
+            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();
+        });
+    }
+    reset() {
+        if (this._state === 'closed') {
+            throw new DOMException('Encoder is closed', 'InvalidStateError');
+        }
+        this._stopFFmpeg();
+        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._state = 'closed';
+        this._config = null;
+        this._encodeQueueSize = 0;
+        this._codecDescription = null;
+    }
+    _startFFmpeg() {
+        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._process.stderr?.on('data', (data) => {
+            const msg = data.toString();
+            if (!msg.includes('Discarding ID3')) {
+                logger.warn('FFmpeg stderr', { message: msg });
+            }
+        });
+        this._process.on('close', () => {
+            if (this._accumulatedData.length > 0) {
+                this._emitChunk(this._accumulatedData, 'key');
+                this._accumulatedData = Buffer.alloc(0);
+            }
+        });
+        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;
+        }
+        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)
+            return;
+        const samplesPerFrame = getAudioFrameSize(this._ffmpegCodec) || 1024;
+        const timestamp = (this._frameCount * 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();
+        const isAac = codecBase === 'mp4a' || codecBase === 'aac';
+        if (this._bitstreamFormat === 'aac' && isAac) {
+            const stripped = stripAdtsHeader(new Uint8Array(data));
+            payload = Buffer.from(stripped);
+            if (!this._codecDescription) {
+                this._codecDescription = buildAudioSpecificConfig({
+                    samplingRate: this._config.sampleRate,
+                    channelConfiguration: this._config.numberOfChannels,
+                });
+            }
+        }
+        const chunk = new EncodedAudioChunk({
+            type,
+            timestamp,
+            duration,
+            data: new Uint8Array(payload),
+        });
+        this._encodeQueueSize = Math.max(0, this._encodeQueueSize - 1);
+        this.emit('dequeue');
+        const metadata = this._firstChunk
+            ? {
+                decoderConfig: {
+                    codec: this._config.codec,
+                    sampleRate: this._config.sampleRate,
+                    numberOfChannels: this._config.numberOfChannels,
+                    description: this._codecDescription ?? undefined,
+                },
+            }
+            : undefined;
+        this._firstChunk = false;
+        this._safeOutputCallback(chunk, metadata);
+    }
+}
+//# sourceMappingURL=AudioEncoder.js.map