Update src/lib/audio-recorder.ts

src/lib/audio-recorder.ts

@@ -1,417 +1,123 @@
-/**
- * Copyright 2024 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+// src/lib/audio-recorder.ts
 
-import { audioContext } from "./utils";
-import AudioRecordingWorklet from "./worklets/audio-processing";
-import SafariAudioRecordingWorklet from "./worklets/safari-audio-processing";
-import VolMeterWorket from "./worklets/vol-meter";
-
-import { createWorketFromSrc } from "./audioworklet-registry";
-import EventEmitter from "eventemitter3";
-
-function arrayBufferToBase64(buffer: ArrayBuffer) {
-  var binary = "";
-  var bytes = new Uint8Array(buffer);
-  var len = bytes.byteLength;
-  for (var i = 0; i < len; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return window.btoa(binary);
-}
-
-// Add Safari-specific audio context creation
-async function createSafariAudioContext(sampleRate: number): Promise<AudioContext> {
-  console.log('Creating Safari audio context with options:', { sampleRate });
-  
-  // Safari requires webkit prefix
-  const AudioContextClass = (window as any).webkitAudioContext || window.AudioContext;
-  console.log('Using AudioContext class:', AudioContextClass.name);
-  
-  const ctx = new AudioContextClass({
-    sampleRate,
-    latencyHint: 'interactive'
-  });
-  
-  console.log('Safari AudioContext initial state:', {
-    state: ctx.state,
-    sampleRate: ctx.sampleRate,
-    baseLatency: ctx.baseLatency,
-    destination: ctx.destination,
-  });
-
-  // Safari requires user interaction to start audio context
-  if (ctx.state === 'suspended') {
-    console.log('Attempting to resume suspended Safari audio context...');
-    try {
-      await ctx.resume();
-      console.log('Successfully resumed Safari audio context:', ctx.state);
-    } catch (err) {
-      console.error('Failed to resume Safari audio context:', err);
-      throw err;
-    }
-  }
-
-  return ctx;
-}
+import EventEmitter from 'eventemitter3';
+import { audioContext } from './utils';
+import VolMeterWorket from './worklets/vol-meter';
 
 export class AudioRecorder extends EventEmitter {
-  stream: MediaStream | undefined;
-  audioContext: AudioContext | undefined;
-  source: MediaStreamAudioSourceNode | undefined;
-  recording: boolean = false;
-  recordingWorklet: AudioWorkletNode | undefined;
-  vuWorklet: AudioWorkletNode | undefined;
-
-  private starting: Promise<void> | null = null;
-
-  // Add browser detection
-  isSafari: boolean;
-  isIOS: boolean;
-
-  constructor(public sampleRate = 16000) {
+  public recording = false;
+  private mediaStream: MediaStream | null = null;
+  private audioContext: AudioContext | null = null;
+  private processor: ScriptProcessorNode | null = null;
+  private source: MediaStreamAudioSourceNode | null = null;
+  private volMeter: AudioWorkletNode | null = null;
+
+  constructor() {
     super();
-    this.isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
-    this.isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent) && !(window as any).MSStream;
-    console.log('AudioRecorder initialized:', { 
-      isSafari: this.isSafari, 
-      isIOS: this.isIOS,
-      sampleRate: this.sampleRate,
-      userAgent: navigator.userAgent,
-      webAudioSupport: !!(window.AudioContext || (window as any).webkitAudioContext),
-      mediaDevicesSupport: !!navigator.mediaDevices
-    });
   }
 
-  async start() {
-    if (!navigator.mediaDevices?.getUserMedia) {
-      console.error('MediaDevices API not available:', { 
-        mediaDevices: !!navigator.mediaDevices,
-        getUserMedia: !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia)
-      });
-      throw new Error("Could not request user media");
+  private async init() {
+    if (!this.audioContext) {
+      this.audioContext = await audioContext({ id: 'audio-in' });
     }
-
-    console.log('Starting AudioRecorder with full environment info:', {
-      userAgent: navigator.userAgent,
-      platform: navigator.platform,
-      vendor: navigator.vendor,
-      audioWorkletSupport: !!(window.AudioWorklet),
-      sampleRate: this.sampleRate,
-      existingAudioContext: !!this.audioContext,
-      existingStream: !!this.stream,
-      isSafari: this.isSafari
-    });
-
-    this.starting = new Promise(async (resolve, reject) => {
+    if (!this.mediaStream) {
       try {
-        if (this.isSafari) {
-          // Safari implementation
-          console.log('Safari detected - using Safari-specific audio initialization');
-          
-          // 1. First get audio permissions
-          console.log('Requesting audio permissions first for Safari...');
-          const constraints = {
-            audio: {
-              echoCancellation: false,
-              noiseSuppression: false,
-              autoGainControl: false,
-              sampleRate: this.sampleRate,
-              channelCount: 1
-            }
-          };
-          console.log('Safari audio constraints:', constraints);
-          
-          try {
-            this.stream = await navigator.mediaDevices.getUserMedia(constraints);
-            const track = this.stream.getAudioTracks()[0];
-            console.log('Safari audio permissions granted:', {
-              track: track.label,
-              settings: track.getSettings(),
-              constraints: track.getConstraints(),
-              enabled: track.enabled,
-              muted: track.muted,
-              readyState: track.readyState
-            });
-          } catch (err) {
-            console.error('Failed to get Safari audio permissions:', err);
-            throw err;
-          }
-
-          // 2. Create and initialize audio context
-          try {
-            this.audioContext = await createSafariAudioContext(this.sampleRate);
-            console.log('Safari audio context ready:', {
-              state: this.audioContext.state,
-              currentTime: this.audioContext.currentTime
-            });
-          } catch (err) {
-            console.error('Failed to initialize Safari audio context:', err);
-            throw err;
-          }
-
-          // 3. Create and connect audio source
-          try {
-            console.log('Creating Safari audio source...');
-            this.source = this.audioContext.createMediaStreamSource(this.stream);
-            console.log('Safari audio source created successfully:', {
-              numberOfInputs: this.source.numberOfInputs,
-              numberOfOutputs: this.source.numberOfOutputs,
-              channelCount: this.source.channelCount
-            });
-          } catch (err) {
-            console.error('Failed to create Safari audio source:', err);
-            throw err;
-          }
-
-          // 4. Load and create worklet
-          try {
-            const workletName = "audio-recorder-worklet";
-            console.log('Loading Safari audio worklet...');
-            const src = createWorketFromSrc(workletName, SafariAudioRecordingWorklet);
-            await this.audioContext.audioWorklet.addModule(src);
-            console.log('Safari audio worklet module loaded');
-
-            this.recordingWorklet = new AudioWorkletNode(
-              this.audioContext,
-              workletName,
-              {
-                numberOfInputs: 1,
-                numberOfOutputs: 1,
-                channelCount: 1,
-                processorOptions: {
-                  sampleRate: this.sampleRate
-                }
-              }
-            );
-
-            // Add detailed error handlers
-            this.recordingWorklet.onprocessorerror = (event) => {
-              console.error('Safari AudioWorklet processor error:', event);
-            };
-
-            this.recordingWorklet.port.onmessageerror = (event) => {
-              console.error('Safari AudioWorklet message error:', event);
-            };
-
-            // Add data handler with detailed logging
-            this.recordingWorklet.port.onmessage = (ev: MessageEvent) => {
-              const data = ev.data.data;
-              console.log('Safari AudioWorklet message received:', {
-                eventType: ev.data.event,
-                hasData: !!data,
-                dataType: data ? typeof data : null,
-                timestamp: Date.now()
-              });
+        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;
+      }
+    }
+  }
 
-              if (data?.int16arrayBuffer) {
-                console.log('Processing Safari audio chunk:', {
-                  byteLength: data.int16arrayBuffer.byteLength,
-                  timestamp: Date.now()
-                });
-                const arrayBufferString = arrayBufferToBase64(data.int16arrayBuffer);
-                this.emit("data", arrayBufferString);
-              } else {
-                console.warn('Invalid Safari audio chunk received:', ev.data);
-              }
-            };
+  public async start() {
+    if (this.recording) {
+      return;
+    }
+    
+    await this.init();
 
-            console.log('Safari AudioWorkletNode created successfully');
-          } catch (err) {
-            console.error('Failed to setup Safari audio worklet:', err);
-            throw err;
-          }
+    if (!this.audioContext || !this.mediaStream) {
+        console.error("AudioContext or MediaStream not available.");
+        return;
+    }
 
-          // 5. Connect nodes
-          try {
-            console.log('Connecting Safari audio nodes...');
-            this.source.connect(this.recordingWorklet);
-            console.log('Safari audio nodes connected successfully');
-          } catch (err) {
-            console.error('Failed to connect Safari audio nodes:', err);
-            throw err;
-          }
+    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);
+    };
 
-        } else {
-          // Chrome/other browsers implementation
-          console.log('Non-Safari browser detected - using standard audio initialization');
-          
-          // Get media stream first for Chrome
-          const constraints = {
-            audio: {
-              echoCancellation: true,
-              noiseSuppression: true,
-              autoGainControl: true,
-              sampleRate: this.sampleRate
+    // --- بخش کلیدی: اضافه کردن 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);
             }
-          };
-          console.log('Chrome audio constraints:', constraints);
-          
-          try {
-            this.stream = await navigator.mediaDevices.getUserMedia(constraints);
-            const track = this.stream.getAudioTracks()[0];
-            console.log('Chrome audio permissions granted:', {
-              track: track.label,
-              settings: track.getSettings()
-            });
-          } catch (err) {
-            console.error('Failed to get Chrome audio permissions:', err);
-            throw err;
-          }
-
-          // Create audio context after getting stream for Chrome
-          try {
-            console.log('Creating Chrome audio context...');
-            this.audioContext = await audioContext({ sampleRate: this.sampleRate });
-            console.log('Chrome audio context created:', {
-              state: this.audioContext.state,
-              sampleRate: this.audioContext.sampleRate
-            });
-          } catch (err) {
-            console.error('Failed to create Chrome audio context:', err);
-            throw err;
-          }
-
-          // Create media stream source
-          try {
-            console.log('Creating Chrome audio source...');
-            this.source = this.audioContext.createMediaStreamSource(this.stream);
-            console.log('Chrome audio source created');
-          } catch (err) {
-            console.error('Failed to create Chrome audio source:', err);
-            throw err;
-          }
-
-          // Load and create standard worklet
-          try {
-            const workletName = "audio-recorder-worklet";
-            console.log('Loading Chrome audio worklet...');
-            const src = createWorketFromSrc(workletName, AudioRecordingWorklet);
-            await this.audioContext.audioWorklet.addModule(src);
-            console.log('Chrome audio worklet loaded');
-
-            this.recordingWorklet = new AudioWorkletNode(
-              this.audioContext,
-              workletName,
-              {
-                numberOfInputs: 1,
-                numberOfOutputs: 1,
-                channelCount: 1,
-                processorOptions: {
-                  sampleRate: this.sampleRate
-                }
-              }
-            );
-
-            // Add error handlers
-            this.recordingWorklet.onprocessorerror = (event) => {
-              console.error('Chrome AudioWorklet processor error:', event);
-            };
-
-            this.recordingWorklet.port.onmessageerror = (event) => {
-              console.error('Chrome AudioWorklet message error:', event);
-            };
-
-            // Add data handler
-            this.recordingWorklet.port.onmessage = async (ev: MessageEvent) => {
-              const arrayBuffer = ev.data.data?.int16arrayBuffer;
-              if (arrayBuffer) {
-                const arrayBufferString = arrayBufferToBase64(arrayBuffer);
-                this.emit("data", arrayBufferString);
-              } else {
-                console.warn('Invalid Chrome audio chunk received:', ev.data);
-              }
-            };
-
-            console.log('Chrome AudioWorkletNode created');
-          } catch (err) {
-            console.error('Failed to setup Chrome audio worklet:', err);
-            throw err;
-          }
-
-          // Connect nodes
-          try {
-            console.log('Connecting Chrome audio nodes...');
-            this.source.connect(this.recordingWorklet);
-            console.log('Chrome audio nodes connected');
-
-            // Set up VU meter
-            const vuWorkletName = "vu-meter";
-            await this.audioContext.audioWorklet.addModule(
-              createWorketFromSrc(vuWorkletName, VolMeterWorket),
-            );
-            this.vuWorklet = new AudioWorkletNode(this.audioContext, vuWorkletName);
-            this.vuWorklet.port.onmessage = (ev: MessageEvent) => {
-              this.emit("volume", ev.data.volume);
-            };
-            this.source.connect(this.vuWorklet);
-            console.log('Chrome VU meter connected');
-          } catch (err) {
-            console.error('Failed to connect Chrome audio nodes:', err);
-            throw err;
-          }
-        }
+        };
+        this.source.connect(this.volMeter);
+    } catch(err) {
+        console.error("Error adding AudioWorklet module", err);
+    }
+    // ------------------------------------------
 
-        this.recording = true;
-        console.log('Recording started successfully');
-        resolve();
-        this.starting = null;
-      } catch (error) {
-        console.error('Failed to start recording:', error);
-        this.stop();
-        reject(error);
-        this.starting = null;
-      }
-    });
-    return this.starting;
+    this.source.connect(this.processor);
+    this.processor.connect(this.audioContext.destination);
+    
+    this.emit('start');
   }
 
-  stop() {
-    console.log('Stopping audio recorder...');
-    // its plausible that stop would be called before start completes
-    // such as if the websocket immediately hangs up
-    const handleStop = () => {
-      try {
-        if (this.source) {
-          console.log('Disconnecting audio source...');
-          this.source.disconnect();
-        }
-        if (this.stream) {
-          console.log('Stopping media stream tracks...');
-          this.stream.getTracks().forEach(track => {
-            track.stop();
-            console.log('Stopped track:', track.label);
-          });
-        }
-        if (this.audioContext && this.isSafari) {
-          console.log('Closing Safari audio context...');
-          this.audioContext.close();
-        }
-        this.stream = undefined;
-        this.recordingWorklet = undefined;
-        this.vuWorklet = undefined;
-        console.log('Audio recorder stopped successfully');
-      } catch (err) {
-        console.error('Error while stopping audio recorder:', err);
-      }
-    };
-    if (this.starting) {
-      console.log('Stop called while starting - waiting for start to complete...');
-      this.starting.then(handleStop);
+  public stop() {
+    if (!this.recording) {
       return;
     }
-    handleStop();
+    this.recording = false;
+    this.emit('stop');
+    
+    this.source?.disconnect();
+    this.processor?.disconnect();
+    this.volMeter?.disconnect();
+
+    this.source = null;
+    this.processor = null;
+    this.volMeter = null;
+  }
+  
+  // توابع کمکی برای تبدیل فرمت صدا
+  private floatTo16BitPCM(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;
+    }
+    return output;
+  }
+
+  private pcm16ToBase64(pcm16: Int16Array): string {
+    const buffer = pcm16.buffer;
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
   }
-}
+}