sera-ai 1.0.25 → 1.0.26

package/dist/index.js

@@ -46,13 +46,10 @@ var InvalidSampleRateError = class extends Error {
 };
 
 // src/hooks/useFFmpegConverter.ts
-var createFFmpegWorker = () => {
+var createWavConversionWorker = () => {
   const minSampleRate = MIN_VALID_SAMPLE_RATE;
   const maxSampleRate = MAX_VALID_SAMPLE_RATE;
   const workerCode = `
-    let ffmpegModule = null;
-
-    // Injected constants from audio.ts
     const MIN_SAMPLE_RATE = ${minSampleRate};
     const MAX_SAMPLE_RATE = ${maxSampleRate};
 
@@ -62,254 +59,80 @@ var createFFmpegWorker = () => {
       }
     };
 
-    const helperFunctions = {
-      float32ToWavFile: function(left, sampleRate) {
-        validateSampleRate(sampleRate);
-        const length = left.length;
-        const buffer = new ArrayBuffer(44 + length * 2);
-        const view = new DataView(buffer);
-        
-        const writeString = (offset, string) => {
-          for (let i = 0; i < string.length; i++) {
-            view.setUint8(offset + i, string.charCodeAt(i));
-          }
-        };
-        
-        const floatTo16BitPCM = (output, offset, input) => {
-          for (let i = 0; i < input.length; i++, offset += 2) {
-            const s = Math.max(-1, Math.min(1, input[i]));
-            output.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7FFF, true);
-          }
-        };
-        
-        writeString(0, 'RIFF');
-        view.setUint32(4, 36 + length * 2, true);
-        writeString(8, 'WAVE');
-        writeString(12, 'fmt ');
-        view.setUint32(16, 16, true);
-        view.setUint16(20, 1, true);
-        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);
-        writeString(36, 'data');
-        view.setUint32(40, length * 2, true);
-        
-        floatTo16BitPCM(view, 44, left);
-        
-        return buffer;
-      },
-      
-      processAudioData: function(audioBuffer, options = {}) {
-        try {
-          const { quality = 1, bitRate = 128000, sampleRate } = options;
-          validateSampleRate(sampleRate);
-          const float32Array = new Float32Array(audioBuffer);
-          const wavBuffer = this.float32ToWavFile(float32Array, sampleRate);
+    const float32ToWavFile = (left, sampleRate) => {
+      validateSampleRate(sampleRate);
+      const length = left.length;
+      const buffer = new ArrayBuffer(44 + length * 2);
+      const view = new DataView(buffer);
 
-          return {
-            buffer: wavBuffer,
-            size: wavBuffer.byteLength,
-            duration: float32Array.length / sampleRate
-          };
-        } catch (error) {
-          throw new Error('Failed to process audio data: ' + error.message);
+      const writeString = (offset, string) => {
+        for (let i = 0; i < string.length; i++) {
+          view.setUint8(offset + i, string.charCodeAt(i));
         }
-      },
-      
-      removeSilenceFromAudio: function(audioBuffer, options = {}) {
-        try {
-          const {
-            silenceThreshold = 0.005,    // Low threshold to only detect true silence
-            minSilenceDuration = 1.5,    // Only remove silences longer than 1.5 seconds
-            sampleRate
-          } = options;
-          validateSampleRate(sampleRate);
-          
-          const float32Array = new Float32Array(audioBuffer);
-          const minSilenceSamples = Math.floor(minSilenceDuration * sampleRate);
-          const result = [];
-          
-          let silenceStart = -1;
-          let silenceLength = 0;
-          let totalAudioSamples = 0;
-          let totalSilentSamples = 0;
-          
-          // First pass: analyze audio content
-          for (let i = 0; i < float32Array.length; i++) {
-            const sample = Math.abs(float32Array[i]);
-            if (sample > silenceThreshold) {
-              totalAudioSamples++;
-            } else {
-              totalSilentSamples++;
-            }
-          }
-          
-          const audioPercentage = totalAudioSamples / float32Array.length;
-          console.log(\`[AUDIO] Audio content: \${(audioPercentage * 100).toFixed(2)}%\`);
-          
-          // If less than 5% is audio, skip silence removal to prevent over-processing
-          if (audioPercentage < 0.05) {
-            console.warn('[WARN] Audio content too low, skipping silence removal to preserve speech');
-            const wavBuffer = this.float32ToWavFile(float32Array, sampleRate);
-            return {
-              buffer: wavBuffer,
-              size: wavBuffer.byteLength,
-              duration: float32Array.length / sampleRate,
-              originalDuration: float32Array.length / sampleRate,
-              reductionPercentage: 0
-            };
-          }
-          
-          // Second pass: remove long silences
-          for (let i = 0; i < float32Array.length; i++) {
-            const sample = Math.abs(float32Array[i]);
-            
-            if (sample < silenceThreshold) {
-              if (silenceStart === -1) {
-                silenceStart = i;
-              }
-              silenceLength++;
-            } else {
-              // End of silence detected
-              if (silenceStart !== -1) {
-                if (silenceLength < minSilenceSamples) {
-                  // Keep short silences (natural pauses)
-                  for (let j = silenceStart; j < i; j++) {
-                    result.push(float32Array[j]);
-                  }
-                } else {
-                  // Replace long silences with a brief pause (0.15 seconds)
-                  const shortSilenceSamples = Math.floor(0.15 * sampleRate);
-                  for (let j = 0; j < shortSilenceSamples; j++) {
-                    result.push(0);
-                  }
-                }
-                silenceStart = -1;
-                silenceLength = 0;
-              }
-              
-              // Add non-silent sample
-              result.push(float32Array[i]);
-            }
-          }
-          
-          // Handle trailing silence
-          if (silenceStart !== -1 && silenceLength >= minSilenceSamples) {
-            const shortSilenceSamples = Math.floor(0.15 * sampleRate);
-            for (let j = 0; j < shortSilenceSamples; j++) {
-              result.push(0);
-            }
-          } else if (silenceStart !== -1) {
-            for (let j = silenceStart; j < float32Array.length; j++) {
-              result.push(float32Array[j]);
-            }
-          }
-          
-          const processedArray = new Float32Array(result);
-          
-          // Safety check: ensure we haven't removed too much content
-          const reductionPercentage = Math.round((1 - processedArray.length / float32Array.length) * 100);
-          if (reductionPercentage > 80) {
-            console.warn('[WARN] Excessive silence removal detected, skipping to preserve speech naturalness');
-            const wavBuffer = this.float32ToWavFile(float32Array, sampleRate);
-            return {
-              buffer: wavBuffer,
-              size: wavBuffer.byteLength,
-              duration: float32Array.length / sampleRate,
-              originalDuration: float32Array.length / sampleRate,
-              reductionPercentage: 0
-            };
-          }
-          
-          const wavBuffer = this.float32ToWavFile(processedArray, sampleRate);
-          
-          console.log(\`[SUCCESS] Silence removal complete. Original Duration: \${(float32Array.length / sampleRate).toFixed(2)}s, Processed Duration: \${(processedArray.length / sampleRate).toFixed(2)}s, Reduction: \${reductionPercentage}%\`);
-          
-          return {
-            buffer: wavBuffer,
-            size: wavBuffer.byteLength,
-            duration: processedArray.length / sampleRate,
-            originalDuration: float32Array.length / sampleRate,
-            reductionPercentage: reductionPercentage
-          };
-        } catch (error) {
-          throw new Error('Failed to remove silence: ' + error.message);
+      };
+
+      const floatTo16BitPCM = (output, offset, input) => {
+        for (let i = 0; i < input.length; i++, offset += 2) {
+          const s = Math.max(-1, Math.min(1, input[i]));
+          output.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7FFF, true);
         }
-      }
+      };
+
+      writeString(0, 'RIFF');
+      view.setUint32(4, 36 + length * 2, true);
+      writeString(8, 'WAVE');
+      writeString(12, 'fmt ');
+      view.setUint32(16, 16, true);
+      view.setUint16(20, 1, true);
+      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);
+      writeString(36, 'data');
+      view.setUint32(40, length * 2, true);
+
+      floatTo16BitPCM(view, 44, left);
+
+      return buffer;
     };
 
     self.onmessage = function(e) {
       const { type, audioBuffer, options } = e.data;
-      
+
       if (type === 'convertWav') {
         try {
           self.postMessage({ type: 'progress', data: { progress: 10, message: 'Starting conversion...' } });
-          
-          const result = helperFunctions.processAudioData(audioBuffer, options);
-          
+
+          const { sampleRate } = options;
+          validateSampleRate(sampleRate);
+          const float32Array = new Float32Array(audioBuffer);
+          const wavBuffer = float32ToWavFile(float32Array, sampleRate);
+
           self.postMessage({ type: 'progress', data: { progress: 50, message: 'Processing audio...' } });
-          
+
           setTimeout(() => {
             self.postMessage({ type: 'progress', data: { progress: 90, message: 'Finalizing...' } });
-            
-            setTimeout(() => {
-              self.postMessage({ 
-                type: 'complete', 
-                data: { 
-                  buffer: result.buffer,
-                  size: result.size,
-                  duration: result.duration 
-                } 
-              });
-            }, 100);
-          }, 100);
-          
-        } catch (error) {
-          self.postMessage({ 
-            type: 'error', 
-            error: error.message || 'Unknown conversion error' 
-          });
-        }
-      } else if (type === 'removeSilence') {
-        try {
-          self.postMessage({ type: 'progress', progress: 10, message: 'Analyzing audio...' });
-          
-          const result = helperFunctions.removeSilenceFromAudio(audioBuffer, options);
-          
-          self.postMessage({ type: 'progress', progress: 70, message: 'Removing silence...' });
-          
-          setTimeout(() => {
-            self.postMessage({ type: 'progress', progress: 90, message: 'Finalizing...' });
-            
+
             setTimeout(() => {
-              self.postMessage({ 
-                type: 'complete', 
-                result: {
-                  data: result.buffer,
-                  name: options.fileName || 'processed_audio.wav',
-                  type: options.fileType || 'audio/wav',
-                  stats: {
-                    originalDuration: result.originalDuration,
-                    processedDuration: result.duration,
-                    reductionPercentage: result.reductionPercentage,
-                    originalSize: options.originalSize || 0,
-                    processedSize: result.size
-                  }
+              self.postMessage({
+                type: 'complete',
+                data: {
+                  buffer: wavBuffer,
+                  size: wavBuffer.byteLength,
+                  duration: float32Array.length / sampleRate
                 }
               });
             }, 100);
           }, 100);
-          
+
         } catch (error) {
-          self.postMessage({ 
-            type: 'error', 
-            error: error.message || 'Unknown silence removal error' 
+          self.postMessage({
+            type: 'error',
+            error: error.message || 'Unknown conversion error'
           });
         }
       } else if (type === 'init') {
-        // For compatibility with existing code
         self.postMessage({ type: 'ready' });
       }
     };
@@ -376,7 +199,7 @@ var useFFmpegConverter = () => {
       setError(null);
       setStatusMessage("Converting audio...");
       try {
-        const workerUrl = createFFmpegWorker();
+        const workerUrl = createWavConversionWorker();
         const worker = new Worker(workerUrl);
         return new Promise((resolve, reject) => {
           worker.onmessage = (e) => {
@@ -495,164 +318,79 @@ var useFFmpegConverter = () => {
     }
     const maxFileSize = 50 * 1024 * 1024;
     if (file.size > maxFileSize) {
-      console.warn(`File too large (${file.size} bytes), skipping silence removal`);
+      console.warn(`[SILENCE] File too large (${file.size} bytes), skipping silence removal`);
       return file;
     }
     try {
       setIsConverting(true);
       setError(null);
       setProgress(0);
-      setStatusMessage("Starting audio processing...");
-      const arrayBuffer = await file.arrayBuffer();
-      console.log(`[INFO] Processing WAV file: ${file.size} bytes, name: ${file.name}`);
-      const dataView = new DataView(arrayBuffer);
-      const riffSignature = String.fromCharCode(
-        dataView.getUint8(0),
-        dataView.getUint8(1),
-        dataView.getUint8(2),
-        dataView.getUint8(3)
-      );
-      if (riffSignature !== "RIFF") {
-        console.error("Invalid WAV file: Missing RIFF header");
-        return file;
-      }
-      const waveSignature = String.fromCharCode(
-        dataView.getUint8(8),
-        dataView.getUint8(9),
-        dataView.getUint8(10),
-        dataView.getUint8(11)
-      );
-      if (waveSignature !== "WAVE") {
-        console.error("Invalid WAV file: Missing WAVE signature");
-        return file;
-      }
-      let dataChunkOffset = 12;
-      let audioDataStart = -1;
-      let audioDataLength = 0;
-      while (dataChunkOffset < arrayBuffer.byteLength - 8) {
-        const chunkId = String.fromCharCode(
-          dataView.getUint8(dataChunkOffset),
-          dataView.getUint8(dataChunkOffset + 1),
-          dataView.getUint8(dataChunkOffset + 2),
-          dataView.getUint8(dataChunkOffset + 3)
-        );
-        const chunkSize = dataView.getUint32(dataChunkOffset + 4, true);
-        if (chunkId === "data") {
-          audioDataStart = dataChunkOffset + 8;
-          audioDataLength = chunkSize;
-          break;
-        }
-        dataChunkOffset += 8 + chunkSize;
-      }
-      if (audioDataStart === -1) {
-        console.error("No audio data chunk found in WAV file");
-        return file;
-      }
-      const originalSampleRate = dataView.getUint32(24, true);
-      console.log(`[AUDIO] Found audio data: start=${audioDataStart}, length=${audioDataLength} bytes, sampleRate=${originalSampleRate}Hz`);
-      const audioData = new Int16Array(arrayBuffer, audioDataStart, audioDataLength / 2);
-      if (audioData.length === 0) {
-        console.error("No audio data extracted from WAV file");
-        return file;
-      }
-      const float32Data = new Float32Array(audioData.length);
-      let nonZeroCount = 0;
-      for (let i = 0; i < audioData.length; i++) {
-        float32Data[i] = audioData[i] / 32768;
-        if (Math.abs(float32Data[i]) > 1e-3) nonZeroCount++;
-      }
-      const audioPercentage = nonZeroCount / float32Data.length;
-      console.log(`[INFO] Audio validation: ${audioData.length} samples, ${nonZeroCount} non-zero samples (${(audioPercentage * 100).toFixed(2)}%)`);
-      if (audioPercentage < 0.01) {
-        console.warn(`[WARN] Very little audio content (${(audioPercentage * 100).toFixed(2)}%), skipping silence removal`);
-        return file;
-      }
-      const workerUrl = createFFmpegWorker();
-      const worker = new Worker(workerUrl);
-      return new Promise((resolve, reject) => {
-        const messageHandler = (e) => {
-          const { type, progress: workerProgress, message, result, error: error2 } = e.data;
-          switch (type) {
-            case "progress":
-              setProgress(workerProgress);
-              setStatusMessage(message);
-              break;
-            case "complete":
-              worker.removeEventListener("message", messageHandler);
-              worker.terminate();
-              URL.revokeObjectURL(workerUrl);
-              try {
-                const processedFile = new File([new Uint8Array(result.data)], result.name, {
-                  type: result.type
-                });
-                console.log("[INFO] Silence removal + audio compression results:", result.stats);
-                setProgress(100);
-                setStatusMessage("Processing complete!");
-                setTimeout(() => {
-                  setIsConverting(false);
-                  setProgress(0);
-                  setStatusMessage("");
-                }, 1e3);
-                resolve(processedFile);
-              } catch (fileError) {
-                console.error("Error creating processed file:", fileError);
-                setIsConverting(false);
-                setProgress(0);
-                setStatusMessage("");
-                resolve(file);
-              }
-              break;
-            case "error":
-              worker.removeEventListener("message", messageHandler);
-              worker.terminate();
-              URL.revokeObjectURL(workerUrl);
-              console.error("Worker processing error:", error2);
-              setError(`Processing failed: ${error2}`);
-              setIsConverting(false);
-              setProgress(0);
-              setStatusMessage("");
-              resolve(file);
-              break;
-          }
-        };
-        worker.addEventListener("message", messageHandler);
-        worker.onerror = (workerError) => {
-          worker.removeEventListener("message", messageHandler);
-          worker.terminate();
-          URL.revokeObjectURL(workerUrl);
-          console.error("Worker error during processing:", workerError);
-          setError("Worker processing failed");
+      setStatusMessage("Removing silence...");
+      console.log(`[SILENCE] Processing file: ${file.size} bytes, name: ${file.name}`);
+      if (!ffmpegInstance) {
+        setStatusMessage("Loading FFmpeg for silence removal...");
+        const loaded = await loadFFmpeg();
+        if (!loaded || !ffmpegInstance) {
+          console.error("[SILENCE] Failed to load FFmpeg");
           setIsConverting(false);
           setProgress(0);
           setStatusMessage("");
-          resolve(file);
-        };
-        worker.postMessage({
-          type: "removeSilence",
-          audioBuffer: float32Data.buffer,
-          options: {
-            silenceThreshold: 5e-3,
-            // Lower threshold to only detect true silence
-            minSilenceDuration: 1.5,
-            // Only remove silences longer than 1.5 seconds
-            sampleRate: originalSampleRate,
-            // Preserve original sample rate to avoid speed changes
-            fileName: file.name,
-            fileType: file.type,
-            originalSize: file.size
-          }
-        });
-        console.log(`\u{1F680} Sent ${float32Data.length} samples to silence removal worker`);
-      });
+          return file;
+        }
+      }
+      setProgress(10);
+      setStatusMessage("Writing audio to FFmpeg...");
+      const inputFileName = "input-silence.wav";
+      const outputFileName = "output-nosilence.wav";
+      const wavData = await ffmpeg.fetchFile(file);
+      ffmpegInstance.FS("writeFile", inputFileName, wavData);
+      const originalSize = file.size;
+      console.log(`[SILENCE] Input file written: ${originalSize} bytes`);
+      setProgress(30);
+      setStatusMessage("Analyzing and removing silence...");
+      await ffmpegInstance.run(
+        "-i",
+        inputFileName,
+        "-af",
+        "silenceremove=stop_periods=-1:stop_threshold=-35dB:stop_duration=0.5:detection=peak,apad=pad_dur=0.5",
+        "-acodec",
+        "pcm_s16le",
+        outputFileName
+      );
+      setProgress(80);
+      setStatusMessage("Reading processed audio...");
+      const outputData = ffmpegInstance.FS("readFile", outputFileName);
+      try {
+        ffmpegInstance.FS("unlink", inputFileName);
+        ffmpegInstance.FS("unlink", outputFileName);
+      } catch (cleanupErr) {
+        console.warn("[SILENCE] Cleanup warning:", cleanupErr);
+      }
+      const processedSize = outputData.length;
+      const reductionPercent = Math.round((1 - processedSize / originalSize) * 100);
+      console.log(`[SILENCE] Complete: ${originalSize} bytes -> ${processedSize} bytes (${reductionPercent}% reduction)`);
+      const processedFile = new File(
+        [new Uint8Array(outputData)],
+        file.name,
+        { type: "audio/wav" }
+      );
+      setProgress(100);
+      setStatusMessage("Silence removal complete");
+      setTimeout(() => {
+        setIsConverting(false);
+        setProgress(0);
+        setStatusMessage("");
+      }, 500);
+      return processedFile;
     } catch (err) {
-      console.error("Worker removeSilence failed:", err);
-      setError("Audio processing failed");
+      console.error("[SILENCE] FFmpeg silence removal failed:", err);
+      setError("Silence removal failed");
       setIsConverting(false);
       setProgress(0);
       setStatusMessage("");
       return file;
     }
-  }, []);
+  }, [loadFFmpeg]);
   const reset = React3.useCallback(() => {
     setIsConverting(false);
     setProgress(0);