Pipeline Inferensi Audio Sub-Detik: Desain Arsitektur LPU untuk Pengenalan Suara Berlatensi Rendah

┌─────────────────────────────────────────────────────────────┐
│                 1. Ingestion Layer (Gateway)                │
│   - Menerima payload audio Ogg/Opus dari webhook terenkripsi│
│   - Buffer streaming disimpan murni pada memory (RAM buffer)│
└──────────────────────────────┬──────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────┐
│              2. Signal Pre-Processing & Filter              │
│   - Konversi format via in-memory pipeline:                 │
│     ffmpeg -i pipe:0 -ar 16000 -ac 1 -c:a pcm_s16le pipe:1  │
│   - Trimming silent frames & normalisasi amplitude          │
└──────────────────────────────┬──────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────┐
│             3. LPU Accelerated Inference (Groq)             │
│   - Model: whisper-large-v3-turbo (809M Parameter)          │
│   - Deterministic Tensor Processing Units                   │
│   - Rata-rata Latensi Inferensi: ~180ms - 240ms             │
└──────────────────────────────┬──────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────┐
│                 4. Sanitasi Teks & Routing                  │
│   - Zero-Disk-Retention: Hapus semua buffer memori seketika │
│   - Normalisasi teks dan injeksi ke konteks eksekusi agen   │
└─────────────────────────────────────────────────────────────┘

// src/audio/speech-pipeline.ts
import { spawn } from 'child_process';
import { Readable, PassThrough } from 'stream';

export interface TranscriptionOptions {
  apiKey: string;
  language?: string;
  temperature?: number;
  promptContext?: string;
}

export interface TranscriptionResult {
  text: string;
  durationSeconds: number;
  latencyMs: number;
}

export class SpeechToTextEngine {
  private readonly endpoint = 'https://api.groq.com/openai/v1/audio/transcriptions';

  constructor(private readonly apiKey: string) {}

  /**
   * Mengonversi buffer audio terkompresi (Opus/AAC/MP3) menjadi WAV 16kHz PCM
   * murni di dalam memori buffer (RAM) menggunakan streaming pipes.
   */
  public async transcodeToPCM16k(inputBuffer: Buffer): Promise<Buffer> {
    return new Promise((resolve, reject) => {
      const ffmpeg = spawn('ffmpeg', [
        '-hide_banner',
        '-loglevel', 'error',
        '-i', 'pipe:0',           // Baca dari stdin
        '-f', 'wav',              // Kontainer keluaran WAV
        '-acodec', 'pcm_s16le',   // 16-bit Linear PCM
        '-ac', '1',               // 1 channel (Mono)
        '-ar', '16000',           // 16.000 Hz Sampling Rate
        'pipe:1'                  // Tulis ke stdout
      ]);

      const chunks: Buffer[] = [];
      ffmpeg.stdout.on('data', (chunk: Buffer) => chunks.push(chunk));
      ffmpeg.stderr.on('data', (err) => console.error('[FFMPEG STDERR]', err.toString()));

      ffmpeg.on('close', (code) => {
        if (code === 0) {
          resolve(Buffer.concat(chunks));
        } else {
          reject(new Error(`Transcoding audio gagal dengan exit code: ${code}`));
        }
      });

      ffmpeg.stdin.write(inputBuffer);
      ffmpeg.stdin.end();
    });
  }

  /**
   * Mengirimkan tensor audio terkompresi ke LPU Inference Engine
   */
  public async transcribe(audioBuffer: Buffer, options: Partial<TranscriptionOptions> = {}): Promise<TranscriptionResult> {
    const startTime = performance.now();

    // 1. Transcoding audio ke PCM 16kHz dalam memori
    const normalizedWav = await this.transcodeToPCM16k(audioBuffer);

    // 2. Bentuk multipart form-data sintetis
    const boundary = `----LpuBoundary${crypto.randomUUID().replace(/-/g, '')}`;
    const formChunks: Buffer[] = [];

    // Header Model
    formChunks.push(Buffer.from(
      `--${boundary}\r\nContent-Disposition: form-data; name="model"\r\n\r\nwhisper-large-v3-turbo\r\n`
    ));

    // Bahasa dan Prompt Context opsional
    if (options.language) {
      formChunks.push(Buffer.from(
        `--${boundary}\r\nContent-Disposition: form-data; name="language"\r\n\r\n${options.language}\r\n`
      ));
    }

    // File Audio Payload
    formChunks.push(Buffer.from(
      `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="input.wav"\r\nContent-Type: audio/wav\r\n\r\n`
    ));
    formChunks.push(normalizedWav);
    formChunks.push(Buffer.from(`\r\n--${boundary}--\r\n`));

    const payload = Buffer.concat(formChunks);

    // 3. Eksekusi panggilan HTTP/2 terenkripsi ke endpoint LPU
    const response = await fetch(this.endpoint, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': `multipart/form-data; boundary=${boundary}`,
        'Content-Length': payload.length.toString()
      },
      body: payload
    });

    if (!response.ok) {
      const errText = await response.text();
      throw new Error(`Inference engine error [${response.status}]: ${errText}`);
    }

    const data = await response.json() as { text: string; duration?: number };
    const latencyMs = Math.round(performance.now() - startTime);

    return {
      text: data.text.trim(),
      durationSeconds: data.duration || 0,
      latencyMs
    };
  }
}