@coeiro-operator/audio 1.0.3 → 1.2.0

package/dist/audio-player.js

@@ -1,19 +1,16 @@
 /**
  * src/say/audio-player.ts: 音声再生管理
- * speakerライブラリによるネイティブ音声出力を担当
+ * @echogarden/audio-ioによる音声出力を担当
  */
 import { writeFile } from 'fs/promises';
 import * as Echogarden from 'echogarden';
-// @ts-ignore - dsp.jsには型定義がない
+// @ts-expect-error - dsp.jsには型定義がない
 import DSP from 'dsp.js';
 import { Transform } from 'stream';
-import { EventEmitter } from 'events';
+import { createAudioOutput } from '@echogarden/audio-io';
 import { logger } from '@coeiro-operator/common';
+import { OpenPromise } from './open-promise.js';
 import { SAMPLE_RATES, AUDIO_FORMAT, BUFFER_SIZES, FILTER_SETTINGS, CROSSFADE_SETTINGS, PADDING_SETTINGS, } from './constants.js';
-// テスト用のモックインスタンスを外部から注入可能にする
-export const forTests = {
-    mockSpeakerInstance: null,
-};
 export class AudioPlayer {
     synthesisRate = SAMPLE_RATES.SYNTHESIS;
     playbackRate = SAMPLE_RATES.PLAYBACK;
@@ -26,6 +23,13 @@ export class AudioPlayer {
     isInitialized = false;
     audioConfig;
     config;
+    // チャンク境界での停止制御フラグ
+    shouldStop = false;
+    // @echogarden/audio-io関連
+    audioOutput = null;
+    chunkQueue = [];
+    currentChunkOffset = 0;
+    completionPromise = null;
     /**
      * AudioPlayerの初期化
      */
@@ -137,7 +141,7 @@ export class AudioPlayer {
             if (this.noiseReductionEnabled) {
                 await this.initializeEchogarden();
             }
-            logger.info(`音声プレーヤー初期化: speakerライブラリ使用（ネイティブ出力）${this.noiseReductionEnabled ? ' + Echogarden' : ''} - Speaker遅延初期化`);
+            logger.info(`音声プレーヤー初期化: @echogarden/audio-io使用（プリコンパイル済みバイナリ）${this.noiseReductionEnabled ? ' + Echogarden' : ''}`);
             this.isInitialized = true;
             return true;
         }
@@ -170,7 +174,7 @@ export class AudioPlayer {
             }
             else {
                 // シンプルな直接再生
-                return this.playPCMData(pcmData, bufferSize);
+                return await this.playPCMData(pcmData, bufferSize);
             }
         }
         catch (error) {
@@ -179,45 +183,54 @@ export class AudioPlayer {
     }
     /**
      * ストリーミング音声処理パイプライン
-     * 処理順序: 1) リサンプリング 2) ローパスフィルター 3) ノイズリダクション 4) Speaker出力
+     * 処理順序: 1) リサンプリング 2) ローパスフィルター 3) ノイズリダクション 4) 出力
      */
     async processAudioStreamPipeline(pcmData) {
         logger.log('高品質音声処理パイプライン開始');
-        // Speakerインスタンスを新規作成
-        const streamSpeaker = await this.createSpeaker(this.playbackRate, BUFFER_SIZES.DEFAULT);
-        return new Promise((resolve, reject) => {
-            streamSpeaker.on('close', () => {
-                resolve();
-            });
-            streamSpeaker.on('error', (error) => {
-                logger.error(`ストリームスピーカーエラー: ${error.message}`);
-                reject(new Error(`音声再生エラー: ${error.message}`));
-            });
-            try {
-                // 1. リサンプリング（Transform stream）
-                const resampleTransform = this.createResampleTransform();
-                // 2. ローパスフィルター（Transform stream）
-                const lowpassTransform = this.createLowpassTransform();
-                // 3. ノイズリダクション（Transform stream）
-                const noiseReductionTransform = this.createNoiseReductionTransform();
-                // パイプライン構築: リサンプリング → ローパス → ノイズ除去 → Speaker
-                let pipeline = resampleTransform;
-                if (this.lowpassFilterEnabled) {
-                    pipeline = pipeline.pipe(lowpassTransform);
-                }
-                if (this.noiseReductionEnabled) {
-                    pipeline = pipeline.pipe(noiseReductionTransform);
-                }
-                pipeline.pipe(streamSpeaker);
+        // Transform streamを通して処理し、最終的にキューに追加
+        const processedChunks = [];
+        try {
+            // 1. リサンプリング（Transform stream）
+            const resampleTransform = this.createResampleTransform();
+            // 2. ローパスフィルター（Transform stream）
+            const lowpassTransform = this.createLowpassTransform();
+            // 3. ノイズリダクション（Transform stream）
+            const noiseReductionTransform = this.createNoiseReductionTransform();
+            // パイプライン構築: リサンプリング → ローパス → ノイズ除去
+            let pipeline = resampleTransform;
+            if (this.lowpassFilterEnabled) {
+                pipeline = pipeline.pipe(lowpassTransform);
+            }
+            if (this.noiseReductionEnabled) {
+                pipeline = pipeline.pipe(noiseReductionTransform);
+            }
+            // パイプラインの出力を収集
+            return new Promise((resolve, reject) => {
+                pipeline.on('data', (chunk) => {
+                    processedChunks.push(chunk);
+                });
+                pipeline.on('end', async () => {
+                    // すべての処理済みデータを結合
+                    const combinedBuffer = Buffer.concat(processedChunks);
+                    const int16Data = this.convertToInt16Array(new Uint8Array(combinedBuffer));
+                    // AudioOutputを遅延作成
+                    await this.ensureAudioOutput();
+                    // チャンクをキューに追加
+                    this.chunkQueue.push(int16Data);
+                    logger.debug(`処理済みチャンクをキューに追加、現在のキューサイズ: ${this.chunkQueue.length}`);
+                    resolve();
+                });
+                pipeline.on('error', (error) => {
+                    reject(new Error(`パイプライン処理エラー: ${error.message}`));
+                });
                 // PCMデータをパイプラインに送信
                 resampleTransform.write(Buffer.from(pcmData));
                 resampleTransform.end();
-            }
-            catch (error) {
-                logger.error(`パイプライン構築エラー: ${error.message}`);
-                reject(new Error(`パイプライン構築エラー: ${error.message}`));
-            }
-        });
+            });
+        }
+        catch (error) {
+            throw new Error(`パイプライン構築エラー: ${error.message}`);
+        }
     }
     /**
      * リサンプリング用Transform streamを作成
@@ -234,7 +247,6 @@ export class AudioPlayer {
         // 簡易的な線形補間によるリサンプリング実装
         const ratio = this.playbackRate / this.synthesisRate;
         logger.log(`リサンプリング: ${this.synthesisRate}Hz → ${this.playbackRate}Hz (比率: ${ratio})`);
-        let carryOverSample = null;
         return new Transform({
             transform: (chunk, encoding, callback) => {
                 try {
@@ -324,200 +336,154 @@ export class AudioPlayer {
             if (!this.isInitialized) {
                 throw new Error('AudioPlayer is not initialized');
             }
+            // 再生開始時に停止フラグをリセット
+            this.shouldStop = false;
+            // 新しい完了Promiseを作成
+            this.completionPromise = new OpenPromise();
             for await (const audioResult of audioStream) {
+                // チャンク境界で停止チェック
+                if (this.shouldStop) {
+                    logger.info('チャンク境界で再生を停止しました');
+                    break;
+                }
                 // PCMデータを抽出して即座に再生
                 await this.playAudioStream(audioResult, bufferSize);
             }
+            // すべてのチャンクが再生されるまで待機
+            await this.waitForCompletion();
         }
         catch (error) {
             throw new Error(`ストリーミング音声再生エラー: ${error.message}`);
         }
     }
     /**
-     * 並列ストリーミング再生（最初のチャンクから再生開始、以降は自動継続）
+     * キューが空になるまで待機（@echogarden/audio-io用）
      */
-    async playStreamingAudioParallel(audioStream) {
-        try {
-            if (!this.isInitialized) {
-                throw new Error('AudioPlayer is not initialized');
+    async waitForCompletion() {
+        if (!this.audioOutput)
+            return;
+        // キューが既に空の場合は即座に完了
+        if (this.chunkQueue.length === 0 && this.currentChunkOffset === 0) {
+            return;
+        }
+        // OpenPromiseがまだない場合は作成
+        if (!this.completionPromise || !this.completionPromise.isPending) {
+            this.completionPromise = new OpenPromise();
+        }
+        return this.completionPromise.promise;
+    }
+    /**
+     * @echogarden/audio-io用のaudioOutputを遅延作成
+     */
+    async ensureAudioOutput() {
+        if (!this.audioOutput) {
+            logger.debug('AudioOutput作成中...');
+            // bufferDurationの計算（latencyModeに基づく）
+            let bufferDuration;
+            switch (this.audioConfig.latencyMode) {
+                case 'ultra-low':
+                    bufferDuration = 20; // 20ms
+                    break;
+                case 'quality':
+                    bufferDuration = 200; // 200ms
+                    break;
+                default: // balanced
+                    bufferDuration = 100; // 100ms
             }
-            const playQueue = [];
-            for await (const audioResult of audioStream) {
-                // 各チャンクを非同期で再生（順序は保たない、低レイテンシ優先）
-                const playPromise = this.playAudioStream(audioResult).catch((error) => {
-                    logger.warn(`チャンク${audioResult.chunk.index}再生エラー:`, error);
-                });
-                playQueue.push(playPromise);
-                // 最大3チャンクまでの並列再生
-                if (playQueue.length >= 3) {
-                    await Promise.race(playQueue);
-                    // 完了したプロミスを削除
-                    const completedIndex = playQueue.findIndex(p => p === Promise.resolve());
-                    if (completedIndex !== -1) {
-                        playQueue.splice(completedIndex, 1);
-                    }
-                }
+            try {
+                this.audioOutput = await createAudioOutput({
+                    sampleRate: this.playbackRate,
+                    channelCount: this.channels,
+                    bufferDuration,
+                }, this.audioOutputHandler);
+                logger.info(`AudioOutput作成完了: ${this.playbackRate}Hz, ${this.channels}ch, buffer: ${bufferDuration}ms`);
+            }
+            catch (error) {
+                throw new Error(`AudioOutput作成エラー: ${error.message}`);
             }
-            // 残りのチャンクの再生完了を待機
-            await Promise.all(playQueue);
-        }
-        catch (error) {
-            throw new Error(`並列ストリーミング音声再生エラー: ${error.message}`);
         }
     }
     /**
-     * Speakerインスタンスを作成（環境変数によるモック対応）
+     * @echogarden/audio-io用のコールバックハンドラ
      */
-    async createSpeaker(sampleRate, bufferSize) {
-        logger.debug(`新しいSpeaker作成: ${sampleRate}Hz, ${this.channels}ch, ${this.bitDepth}bit, buffer:${bufferSize}`);
-        const config = {
-            channels: this.channels,
-            bitDepth: this.bitDepth,
-            sampleRate: sampleRate,
-            highWaterMark: bufferSize,
-        };
-        // テスト用のモックインスタンスが設定されている場合はそれを返す
-        if (forTests.mockSpeakerInstance) {
-            logger.debug('Using forTests.mockSpeakerInstance');
-            return forTests.mockSpeakerInstance;
-        }
-        // CI環境またはテスト環境でモックSpeakerを返す
-        const isTestEnv = process.env.NODE_ENV === 'test';
-        const isCIEnv = process.env.CI === 'true';
-        logger.debug(`Environment check - NODE_ENV: ${process.env.NODE_ENV}, CI: ${process.env.CI}, isTestEnv: ${isTestEnv}, isCIEnv: ${isCIEnv}`);
-        if (isTestEnv || isCIEnv) {
-            logger.debug('Using mock Speaker for test/CI environment');
-            const mockSpeaker = new EventEmitter();
-            // Writable Streamの基本メソッド
-            mockSpeaker.write = (chunk, encoding, callback) => {
-                const cb = typeof encoding === 'function' ? encoding : callback;
-                if (cb)
-                    cb();
-                return true;
-            };
-            mockSpeaker.end = (chunk, encoding, callback) => {
-                let cb;
-                if (typeof chunk === 'function') {
-                    cb = chunk;
-                }
-                else if (typeof encoding === 'function') {
-                    cb = encoding;
-                }
-                else {
-                    cb = callback;
+    audioOutputHandler = (outputBuffer) => {
+        let bufferOffset = 0;
+        while (bufferOffset < outputBuffer.length && !this.shouldStop) {
+            if (this.chunkQueue.length > 0) {
+                const currentChunk = this.chunkQueue[0];
+                const remainingInChunk = currentChunk.length - this.currentChunkOffset;
+                const remainingInBuffer = outputBuffer.length - bufferOffset;
+                const copyLength = Math.min(remainingInChunk, remainingInBuffer);
+                // データをコピー
+                outputBuffer.set(currentChunk.subarray(this.currentChunkOffset, this.currentChunkOffset + copyLength), bufferOffset);
+                bufferOffset += copyLength;
+                this.currentChunkOffset += copyLength;
+                // チャンクを使い切ったら次へ
+                if (this.currentChunkOffset >= currentChunk.length) {
+                    this.chunkQueue.shift();
+                    this.currentChunkOffset = 0;
+                    logger.debug(`チャンク消費完了、残りキュー: ${this.chunkQueue.length}`);
                 }
-                // endが呼ばれたら少し遅延してcloseイベントを発火
-                setImmediate(() => {
-                    mockSpeaker.emit('close');
-                });
-                if (cb)
-                    cb();
-            };
-            // EventEmitterのメソッド
-            mockSpeaker.removeAllListeners = () => mockSpeaker;
-            // pipe関連のメソッド（Transform Streamとの連携用）
-            mockSpeaker.pipe = (destination) => destination;
-            mockSpeaker.unpipe = () => mockSpeaker;
-            // Writable Streamの状態
-            mockSpeaker._writableState = { ended: false };
-            mockSpeaker.writable = true;
-            mockSpeaker.destroyed = false;
-            // destroyメソッド（リソース解放用）
-            mockSpeaker.destroy = (error) => {
-                mockSpeaker.destroyed = true;
-                if (error) {
-                    mockSpeaker.emit('error', error);
+            }
+            else {
+                // キューが空なら無音で埋める
+                outputBuffer.fill(0, bufferOffset);
+                // キューが空になったら完了を通知
+                if (this.completionPromise && this.completionPromise.isPending) {
+                    this.completionPromise.resolve();
                 }
-                mockSpeaker.emit('close');
-            };
-            return mockSpeaker;
+                break;
+            }
         }
-        // 本番環境では実際のSpeakerを動的インポート
-        try {
-            logger.debug('Dynamically importing real Speaker (production mode)');
-            const SpeakerModule = await import('speaker');
-            const SpeakerClass = SpeakerModule.default || SpeakerModule;
-            return new SpeakerClass(config);
+        // 停止フラグが立っていたら無音で埋める
+        if (this.shouldStop) {
+            outputBuffer.fill(0, bufferOffset);
+            // 停止時も完了を通知
+            if (this.completionPromise && this.completionPromise.isPending) {
+                this.completionPromise.resolve();
+            }
         }
-        catch (error) {
-            logger.error(`Failed to import Speaker module: ${error.message}`);
-            // CI環境でSpeakerがロードできない場合はモックを返す
-            logger.debug('Falling back to mock Speaker due to import failure');
-            const mockSpeaker = new EventEmitter();
-            // Writable Streamの基本メソッド
-            mockSpeaker.write = (chunk, encoding, callback) => {
-                const cb = typeof encoding === 'function' ? encoding : callback;
-                if (cb)
-                    cb();
-                return true;
-            };
-            mockSpeaker.end = (chunk, encoding, callback) => {
-                let cb;
-                if (typeof chunk === 'function') {
-                    cb = chunk;
-                }
-                else if (typeof encoding === 'function') {
-                    cb = encoding;
-                }
-                else {
-                    cb = callback;
-                }
-                // endが呼ばれたら少し遅延してcloseイベントを発火
-                setImmediate(() => {
-                    mockSpeaker.emit('close');
-                });
-                if (cb)
-                    cb();
-            };
-            mockSpeaker.removeAllListeners = () => mockSpeaker;
-            mockSpeaker.pipe = (destination) => destination;
-            mockSpeaker.unpipe = () => mockSpeaker;
-            mockSpeaker._writableState = { ended: false };
-            mockSpeaker.writable = true;
-            mockSpeaker.destroyed = false;
-            mockSpeaker.destroy = (error) => {
-                mockSpeaker.destroyed = true;
-                if (error) {
-                    mockSpeaker.emit('error', error);
-                }
-                mockSpeaker.emit('close');
-            };
-            return mockSpeaker;
+    };
+    /**
+     * Uint8ArrayからInt16Arrayに変換（リトルエンディアン）
+     */
+    convertToInt16Array(pcmData) {
+        const int16Data = new Int16Array(pcmData.length / 2);
+        for (let i = 0; i < int16Data.length; i++) {
+            const low = pcmData[i * 2];
+            const high = pcmData[i * 2 + 1];
+            // リトルエンディアンで16bit整数を構築
+            int16Data[i] = (high << 8) | low;
+            // 符号付き整数に変換（-32768 ~ 32767）
+            if (int16Data[i] >= 32768) {
+                int16Data[i] -= 65536;
+            }
         }
+        return int16Data;
     }
     /**
-     * PCMデータを直接スピーカーに再生（改善版：Speakerインスタンス使い回し）
-     * synthesis/playbackレートが異なる場合は適切なSpeaker設定を使用
+     * PCMデータを音声出力キューに追加
      */
     async playPCMData(pcmData, bufferSize, chunk) {
-        // synthesisRateとplaybackRateが異なる場合は、実際の生成レートを使用
-        const actualSampleRate = this.synthesisRate === this.playbackRate ? this.playbackRate : this.synthesisRate;
-        const finalBufferSize = bufferSize || BUFFER_SIZES.DEFAULT;
-        // Speakerインスタンスを新規作成
-        const speaker = await this.createSpeaker(actualSampleRate, finalBufferSize);
-        return new Promise((resolve, reject) => {
-            // 一時的なイベントリスナーを設定（既存リスナーと競合しないようonce使用）
-            speaker.once('close', () => {
-                logger.debug('Speaker close event received');
-                resolve();
-            });
-            speaker.once('error', (error) => {
-                logger.error(`Speaker再生エラー: ${error.message}`);
-                reject(error);
-            });
-            // クロスフェード処理を適用（設定に基づく）
-            let processedData = pcmData;
-            const crossfadeEnabled = this.audioConfig.crossfadeSettings?.enabled && chunk;
-            if (crossfadeEnabled) {
-                const skipFirst = this.audioConfig.crossfadeSettings?.skipFirstChunk && chunk?.isFirst;
-                if (!skipFirst) {
-                    const overlapSamples = this.audioConfig.crossfadeSettings?.overlapSamples || 24;
-                    processedData = this.applyCrossfade(pcmData, overlapSamples, chunk?.isFirst || false);
-                }
+        // AudioOutputを遅延作成
+        await this.ensureAudioOutput();
+        // クロスフェード処理を適用（設定に基づく）
+        let processedData = pcmData;
+        const crossfadeEnabled = this.audioConfig.crossfadeSettings?.enabled && chunk;
+        if (crossfadeEnabled) {
+            const skipFirst = this.audioConfig.crossfadeSettings?.skipFirstChunk && chunk?.isFirst;
+            if (!skipFirst) {
+                const overlapSamples = this.audioConfig.crossfadeSettings?.overlapSamples || 24;
+                processedData = this.applyCrossfade(pcmData, overlapSamples, chunk?.isFirst || false);
             }
-            // PCMデータをスピーカーに書き込み
-            speaker.end(Buffer.from(processedData));
-        });
+        }
+        // PCMデータをInt16Arrayに変換
+        const int16Data = this.convertToInt16Array(processedData);
+        // チャンクをキューに追加
+        this.chunkQueue.push(int16Data);
+        logger.debug(`チャンクをキューに追加、現在のキューサイズ: ${this.chunkQueue.length}`);
+        // コールバックベースなので、ここでは追加のみ
+        // 実際の再生はaudioOutputHandlerで処理される
     }
     /**
      * 音声ファイルを保存
@@ -664,6 +630,48 @@ export class AudioPlayer {
         const bytesCount = samplesCount * 2; // 16bit = 2bytes per sample
         return new Uint8Array(bytesCount); // すべて0で初期化される（無音）
     }
+    /**
+     * 無音WAVデータを生成（句読点ポーズ用）
+     * @param durationMs 無音の長さ（ミリ秒）
+     * @param sampleRate サンプルレート（デフォルト：24000Hz）
+     * @returns WAVフォーマットの無音データ
+     */
+    generateSilenceWAV(durationMs, sampleRate = SAMPLE_RATES.SYNTHESIS) {
+        const numSamples = Math.floor((sampleRate * durationMs) / 1000);
+        const numBytes = numSamples * 2; // 16bit = 2bytes per sample
+        const arrayBuffer = new ArrayBuffer(44 + numBytes); // WAVヘッダー(44bytes) + データ
+        const view = new DataView(arrayBuffer);
+        // WAVヘッダーを書き込み
+        // "RIFF"
+        view.setUint32(0, 0x52494646, false);
+        // ファイルサイズ - 8
+        view.setUint32(4, 36 + numBytes, true);
+        // "WAVE"
+        view.setUint32(8, 0x57415645, false);
+        // "fmt "
+        view.setUint32(12, 0x666d7420, false);
+        // fmt チャンクサイズ
+        view.setUint32(16, 16, true);
+        // フォーマットタイプ (1 = PCM)
+        view.setUint16(20, 1, true);
+        // チャンネル数 (1 = モノラル)
+        view.setUint16(22, 1, true);
+        // サンプルレート
+        view.setUint32(24, sampleRate, true);
+        // バイトレート
+        view.setUint32(28, sampleRate * 2, true);
+        // ブロックアライン
+        view.setUint16(32, 2, true);
+        // ビット深度
+        view.setUint16(34, 16, true);
+        // "data"
+        view.setUint32(36, 0x64617461, false);
+        // データチャンクサイズ
+        view.setUint32(40, numBytes, true);
+        // 無音データ（すべて0）
+        // ArrayBufferは初期化時に0で埋められるので追加の処理は不要
+        return arrayBuffer;
+    }
     /**
      * ドライバーウォームアップ用の無音再生
      * 短い無音を再生してSpeakerドライバーを起動・安定化
@@ -684,6 +692,17 @@ export class AudioPlayer {
             // エラーが発生しても処理を継続（ウォームアップは補助機能）
         }
     }
+    /**
+     * 音声再生の停止（チャンク境界で停止）
+     * 現在再生中のチャンクは最後まで再生され、次のチャンクから停止します
+     */
+    async stopPlayback() {
+        logger.info('音声再生の停止要求を受信しました');
+        this.shouldStop = true;
+        // キューをクリア
+        this.chunkQueue = [];
+        this.currentChunkOffset = 0;
+    }
     /**
      * AudioPlayerのクリーンアップ（リソース解放）
      * 長時間運用やシャットダウン時に呼び出し
@@ -691,6 +710,13 @@ export class AudioPlayer {
     async cleanup() {
         logger.debug('AudioPlayer cleanup開始');
         try {
+            // AudioOutputの破棄
+            if (this.audioOutput) {
+                await this.audioOutput.dispose();
+                this.audioOutput = null;
+                this.chunkQueue = [];
+                this.currentChunkOffset = 0;
+            }
             // Echogardenリソースの解放
             if (this.echogardenInitialized) {
                 // Echogardenには明示的なクリーンアップメソッドがないため、フラグのみリセット