@series-inc/stowkit-cli 0.1.7 → 0.1.9

package/dist/encoders/aac-encoder.d.ts

@@ -1,12 +1,10 @@
 import { AacQuality } from '../core/types.js';
 import type { IAacEncoder, IAudioDecoder, DecodedPcm } from './interfaces.js';
 export declare class NodeAacEncoder implements IAacEncoder {
-    private ffmpegPath;
     initialize(): Promise<void>;
     encode(channels: Float32Array[], sampleRate: number, quality: AacQuality): Promise<Uint8Array>;
 }
 export declare class NodeAudioDecoder implements IAudioDecoder {
-    private ffmpegPath;
     initialize(): Promise<void>;
     decodeToPcm(audioData: Uint8Array, _fileName: string): Promise<DecodedPcm>;
 }

package/dist/encoders/aac-encoder.js

@@ -1,10 +1,5 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
-import * as path from 'node:path';
 import { AacQuality } from '../core/types.js';
-const execFileAsync = promisify(execFile);
+import { createFFmpegAudio } from '@strangeape/ffmpeg-audio-wasm';
 // ─── Quality mapping ────────────────────────────────────────────────────────
 const QUALITY_TO_VBR = {
     [AacQuality.Lowest]: '0.1',
@@ -44,136 +39,89 @@ function createWavBuffer(channels, sampleRate) {
     }
     return new Uint8Array(buffer);
 }
-// ─── Resolve ffmpeg binary ──────────────────────────────────────────────────
-async function getFfmpegPath() {
-    try {
-        // Try ffmpeg-static first
-        const mod = await import('ffmpeg-static');
-        const p = (mod.default ?? mod);
-        if (p)
-            return p;
+// ─── Parse audio info from ffmpeg stderr ────────────────────────────────────
+function parseAudioInfo(stderr) {
+    let sampleRate = 44100;
+    let numChannels = 2;
+    const srMatch = stderr.match(/(\d+)\s*Hz/);
+    if (srMatch)
+        sampleRate = parseInt(srMatch[1]);
+    const chMatch = stderr.match(/(\d+)\s*channels/) || stderr.match(/(mono|stereo)/i);
+    if (chMatch) {
+        if (chMatch[1] === 'mono')
+            numChannels = 1;
+        else if (chMatch[1] === 'stereo')
+            numChannels = 2;
+        else
+            numChannels = parseInt(chMatch[1]) || 2;
     }
-    catch {
-        // Fallback to PATH
-    }
-    return 'ffmpeg';
+    return { sampleRate, numChannels };
 }
 // ─── NodeAacEncoder ─────────────────────────────────────────────────────────
 export class NodeAacEncoder {
-    ffmpegPath = null;
-    async initialize() {
-        this.ffmpegPath = await getFfmpegPath();
-    }
+    async initialize() { }
     async encode(channels, sampleRate, quality) {
-        if (!this.ffmpegPath)
-            await this.initialize();
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'stowkit-'));
-        const inFile = path.join(tmpDir, 'in.wav');
-        const outFile = path.join(tmpDir, 'out.m4a');
-        try {
-            const wavBytes = createWavBuffer(channels, sampleRate);
-            await fs.writeFile(inFile, wavBytes);
-            const vbr = QUALITY_TO_VBR[quality];
-            await execFileAsync(this.ffmpegPath, [
-                '-y',
-                '-i', inFile,
-                '-c:a', 'aac',
-                '-q:a', vbr,
-                outFile,
-            ]);
-            const result = await fs.readFile(outFile);
-            return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
-        }
-        finally {
-            await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+        const ffmpeg = await createFFmpegAudio();
+        const wavBytes = createWavBuffer(channels, sampleRate);
+        ffmpeg.writeFile('/input.wav', wavBytes);
+        const vbr = QUALITY_TO_VBR[quality];
+        const code = await ffmpeg.exec([
+            '-y',
+            '-i', '/input.wav',
+            '-c:a', 'aac',
+            '-q:a', vbr,
+            '/output.m4a',
+        ]);
+        if (code !== 0) {
+            throw new Error(`FFmpeg AAC encode failed (code ${code}): ${ffmpeg.getLastStderr()}`);
         }
+        return ffmpeg.readFile('/output.m4a');
     }
 }
 // ─── NodeAudioDecoder ───────────────────────────────────────────────────────
 export class NodeAudioDecoder {
-    ffmpegPath = null;
-    async initialize() {
-        this.ffmpegPath = await getFfmpegPath();
-    }
+    async initialize() { }
     async decodeToPcm(audioData, _fileName) {
-        if (!this.ffmpegPath)
-            await this.initialize();
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'stowkit-'));
-        const inFile = path.join(tmpDir, 'input');
-        const outFile = path.join(tmpDir, 'output.raw');
-        try {
-            await fs.writeFile(inFile, audioData);
-            // First, get audio info
-            const { stdout } = await execFileAsync(this.ffmpegPath, [
-                '-i', inFile,
-                '-hide_banner',
-            ], { encoding: 'utf-8' }).catch(e => {
-                // ffmpeg exits non-zero when only probing, but prints info to stderr
-                return { stdout: '', stderr: e.stderr ?? '' };
-            });
-            const infoText = stdout || '';
-            // Parse sample rate and channels from ffmpeg output
-            const sampleRateMatch = infoText.match(/(\d+) Hz/);
-            const channelsMatch = infoText.match(/(\d+) channels/) || infoText.match(/(mono|stereo)/i);
-            // Use ffprobe-style approach: decode to raw PCM f32le
-            await execFileAsync(this.ffmpegPath, [
-                '-y',
-                '-i', inFile,
-                '-f', 'f32le',
-                '-acodec', 'pcm_f32le',
-                outFile,
-            ]);
-            // Get the actual sample rate and channel count via a second pass
-            const probeResult = await execFileAsync(this.ffmpegPath, [
-                '-i', inFile,
-                '-show_entries', 'stream=sample_rate,channels',
-                '-of', 'json',
-                '-v', 'quiet',
-            ]).catch(() => null);
-            let sampleRate = 44100;
-            let numChannels = 2;
-            if (probeResult) {
-                try {
-                    const info = JSON.parse(probeResult.stdout);
-                    if (info.streams?.[0]) {
-                        sampleRate = parseInt(info.streams[0].sample_rate) || 44100;
-                        numChannels = info.streams[0].channels || 2;
-                    }
-                }
-                catch {
-                    // Use ffmpeg stderr parsing fallback
-                    if (sampleRateMatch)
-                        sampleRate = parseInt(sampleRateMatch[1]);
-                    if (channelsMatch) {
-                        if (channelsMatch[1] === 'mono')
-                            numChannels = 1;
-                        else if (channelsMatch[1] === 'stereo')
-                            numChannels = 2;
-                        else
-                            numChannels = parseInt(channelsMatch[1]) || 2;
-                    }
-                }
-            }
-            const rawBuf = await fs.readFile(outFile);
-            const rawF32 = new Float32Array(rawBuf.buffer, rawBuf.byteOffset, rawBuf.byteLength / 4);
-            const numSamples = Math.floor(rawF32.length / numChannels);
-            // Deinterleave
-            const channels = [];
-            for (let ch = 0; ch < numChannels; ch++) {
-                const channelData = new Float32Array(numSamples);
-                for (let i = 0; i < numSamples; i++) {
-                    channelData[i] = rawF32[i * numChannels + ch];
-                }
-                channels.push(channelData);
-            }
-            return {
-                channels,
-                sampleRate,
-                durationMs: Math.round((numSamples / sampleRate) * 1000),
-            };
+        // First pass: probe audio info via a null mux
+        const probeFFmpeg = await createFFmpegAudio();
+        probeFFmpeg.writeFile('/input', audioData);
+        await probeFFmpeg.exec([
+            '-i', '/input',
+            '-f', 'null',
+            '-',
+        ]);
+        const { sampleRate, numChannels } = parseAudioInfo(probeFFmpeg.getLastStderr());
+        // Second pass: decode to f32le WAV (ffmpeg 4.4 needs WAV muxer for pcm_f32le output)
+        const ffmpeg = await createFFmpegAudio();
+        ffmpeg.writeFile('/input', audioData);
+        const code = await ffmpeg.exec([
+            '-y',
+            '-i', '/input',
+            '-f', 'wav',
+            '-acodec', 'pcm_f32le',
+            '/output.wav',
+        ]);
+        if (code !== 0) {
+            throw new Error(`FFmpeg decode failed (code ${code}): ${ffmpeg.getLastStderr()}`);
         }
-        finally {
-            await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+        const wavBuf = ffmpeg.readFile('/output.wav');
+        // Skip 44-byte WAV header to get raw PCM f32le data
+        const rawBuf = wavBuf.slice(44);
+        const rawF32 = new Float32Array(rawBuf.buffer, rawBuf.byteOffset, rawBuf.byteLength / 4);
+        const numSamples = Math.floor(rawF32.length / numChannels);
+        // Deinterleave
+        const deinterleaved = [];
+        for (let ch = 0; ch < numChannels; ch++) {
+            const channelData = new Float32Array(numSamples);
+            for (let i = 0; i < numSamples; i++) {
+                channelData[i] = rawF32[i * numChannels + ch];
+            }
+            deinterleaved.push(channelData);
         }
+        return {
+            channels: deinterleaved,
+            sampleRate,
+            durationMs: Math.round((numSamples / sampleRate) * 1000),
+        };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/stowkit-cli",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "bin": {
     "stowkit": "./dist/cli.js"
@@ -21,7 +21,7 @@
     "@series-inc/stowkit-editor": "^0.1.1",
     "draco3d": "^1.5.7",
     "fbx-parser": "^2.1.3",
-    "ffmpeg-static": "^5.2.0",
+    "@strangeape/ffmpeg-audio-wasm": "^0.1.0",
     "sharp": "^0.33.5",
     "three": "^0.182.0",
     "ws": "^8.18.0"