Update src/lib/audio-recorder.ts

src/lib/audio-recorder.ts

@@ -1,120 +1,105 @@
 // src/lib/audio-recorder.ts
 
-import EventEmitter from 'eventemitter3';
-import { audioContext } from './utils';
-import VolMeterWorket from './worklets/vol-meter';
+import EventEmitter from "eventemitter3";
+import { audioContext } from "./utils";
+import VolMeterWorket from "./worklets/vol-meter";
+
+const CHUNK_SIZE = 2048;
 
 export class AudioRecorder extends EventEmitter {
-  public recording = false;
-  private mediaStream: MediaStream | null = null;
-  private audioContext: AudioContext | null = null;
+  recording = false;
+  private audioCtx: AudioContext | null = null;
+  private microphone: MediaStreamAudioSourceNode | null = null;
   private processor: ScriptProcessorNode | null = null;
-  private source: MediaStreamAudioSourceNode | null = null;
-  private volMeter: AudioWorkletNode | null = null;
+  private worklet: AudioWorkletNode | null = null;
+  private stream: MediaStream | null = null;
 
-  constructor() {
-    super();
-  }
+  async start(): Promise<void> {
+    if (this.recording) return;
 
-  private async init() {
-    if (!this.audioContext) {
-      this.audioContext = await audioContext({ id: 'audio-in' });
-    }
-    if (!this.mediaStream) {
-      try {
-        this.mediaStream = await navigator.mediaDevices.getUserMedia({
-          audio: {
-            sampleRate: 16000,
-            channelCount: 1,
-            echoCancellation: true,
-            noiseSuppression: true,
-          },
-          video: false,
-        });
-      } catch (err) {
-        console.error('Error getting media stream:', err);
-        this.emit('error', err);
-        return;
+    try {
+      this.stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      this.audioCtx = await audioContext({ id: "audio-in" });
+
+      if (this.audioCtx.state === "suspended") {
+        await this.audioCtx.resume();
       }
+
+      await this.audioCtx.audioWorklet.addModule(VolMeterWorket);
+      
+      this.microphone = this.audioCtx.createMediaStreamSource(this.stream);
+      this.processor = this.audioCtx.createScriptProcessor(CHUNK_SIZE, 1, 1);
+      
+      this.worklet = new AudioWorkletNode(this.audioCtx, "vumeter-in");
+      this.worklet.port.onmessage = (ev) => {
+        // رویداد جدید برای ارسال ولوم
+        this.emit("volume", ev.data.volume);
+      };
+
+      this.processor.onaudioprocess = (e: AudioProcessingEvent) => {
+        if (!this.recording) return;
+        const inputData = e.inputBuffer.getChannelData(0);
+        const pcm16Data = this.convertToPCM16(inputData);
+        const base64 = this.toBase64(pcm16Data);
+        // محاسبه ولوم در اینجا و ارسال آن همراه با داده‌ها
+        const volume = this.getVolume(inputData);
+        this.emit("data", base64, volume);
+      };
+
+      this.microphone.connect(this.processor);
+      this.microphone.connect(this.worklet); // اتصال worklet برای گرفتن ولوم
+      this.processor.connect(this.audioCtx.destination);
+
+      this.recording = true;
+      this.emit("start");
+    } catch (err) {
+      console.error("Error starting audio recording:", err);
+      this.emit("error", err);
     }
   }
 
-  public async start() {
-    if (this.recording) {
-      return;
-    }
-    
-    await this.init();
+  stop(): void {
+    if (!this.recording) return;
 
-    if (!this.audioContext || !this.mediaStream) {
-        console.error("AudioContext or MediaStream not available.");
-        return;
-    }
+    this.recording = false;
+    this.emit("stop");
 
-    this.recording = true;
-    this.source = this.audioContext.createMediaStreamSource(this.mediaStream);
-    this.processor = this.audioContext.createScriptProcessor(1024, 1, 1);
-    
-    this.processor.onaudioprocess = (e) => {
-      if (!this.recording) return;
-      const inputData = e.inputBuffer.getChannelData(0);
-      const pcm16 = this.floatTo16BitPCM(inputData);
-      const base64 = this.pcm16ToBase64(pcm16);
-      this.emit('data', base64);
-    };
-
-    // --- بخش کلیدی: اضافه کردن Volume Meter ---
-    try {
-        await this.audioContext.audioWorklet.addModule(VolMeterWorket);
-        this.volMeter = new AudioWorkletNode(this.audioContext, 'vumeter');
-        this.volMeter.port.onmessage = (event) => {
-            if(event.data.volume) {
-                // ارسال رویداد جدید به همراه حجم صدا
-                this.emit('volume', event.data.volume);
-            }
-        };
-        this.source.connect(this.volMeter);
-    } catch(err) {
-        console.error("Error adding AudioWorklet module", err);
+    if (this.stream) {
+      this.stream.getTracks().forEach((track) => track.stop());
+    }
+    if (this.microphone) {
+      this.microphone.disconnect();
+    }
+    if (this.processor) {
+      this.processor.disconnect();
+    }
+    if (this.worklet) {
+        this.worklet.disconnect();
     }
-    // ------------------------------------------
-
-    this.source.connect(this.processor);
-    this.processor.connect(this.audioContext.destination);
-    
-    this.emit('start');
   }
 
-  public stop() {
-    if (!this.recording) {
-      return;
+  private getVolume(data: Float32Array): number {
+    let sum = 0;
+    for (let i = 0; i < data.length; i++) {
+        sum += data[i] * data[i];
     }
-    this.recording = false;
-    this.emit('stop');
-    
-    this.source?.disconnect();
-    this.processor?.disconnect();
-    this.volMeter?.disconnect();
-
-    this.source = null;
-    this.processor = null;
-    this.volMeter = null;
+    const rms = Math.sqrt(sum / data.length);
+    // نرمال‌سازی ولوم به یک مقدار بین 0 و 1
+    return Math.min(1, rms * 5); // ضریب 5 برای محسوس‌تر کردن
   }
-  
-  // توابع کمکی برای تبدیل فرمت صدا
-  private floatTo16BitPCM(input: Float32Array): Int16Array {
+
+  private convertToPCM16(input: Float32Array): Int16Array {
     const output = new Int16Array(input.length);
     for (let i = 0; i < input.length; i++) {
       const s = Math.max(-1, Math.min(1, input[i]));
-      output[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+      output[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
     }
     return output;
   }
 
-  private pcm16ToBase64(pcm16: Int16Array): string {
-    const buffer = pcm16.buffer;
-    const bytes = new Uint8Array(buffer);
-    let binary = '';
+  private toBase64(pcm16Data: Int16Array): string {
+    const bytes = new Uint8Array(pcm16Data.buffer);
+    let binary = "";
     for (let i = 0; i < bytes.byteLength; i++) {
       binary += String.fromCharCode(bytes[i]);
     }