web-audio-recorder-ts 1.0.4 → 1.0.6

package/dist/encoders/Mp3LameEncoder.d.ts

@@ -12,6 +12,8 @@ export declare class Mp3LameEncoderWrapper implements AudioEncoder {
     private sampleRate;
     private numChannels;
     private bitrate;
+    private bufferCount;
+    private totalSamples;
     /**
      * Cria uma instância do encoder MP3 LAME
      *

package/dist/encoders/OggVorbisEncoder.d.ts

@@ -12,6 +12,8 @@ export declare class OggVorbisEncoderWrapper implements AudioEncoder {
     private sampleRate;
     private numChannels;
     private quality;
+    private bufferCount;
+    private totalSamples;
     /**
      * Cria uma instância do encoder OGG Vorbis
      *

package/dist/index.cjs.js

@@ -99,14 +99,36 @@ class WebAudioRecorder {
                 }
                 try {
                     const inputBuffer = event.inputBuffer;
+                    const actualChannels = inputBuffer.numberOfChannels;
                     const buffers = [];
-                    // Extrair dados de cada canal
-                    for (let channel = 0; channel < this.numChannels; channel++) {
+                    // Extrair dados de cada canal disponível
+                    for (let channel = 0; channel < actualChannels; channel++) {
                         const channelData = inputBuffer.getChannelData(channel);
                         buffers.push(new Float32Array(channelData));
                     }
+                    // Se o número de canais do buffer não corresponde ao esperado, ajustar
+                    if (actualChannels !== this.numChannels) {
+                        if (actualChannels === 1 && this.numChannels === 2) {
+                            // Mono -> Estéreo: duplicar o canal
+                            buffers.push(new Float32Array(buffers[0]));
+                        }
+                        else if (actualChannels === 2 && this.numChannels === 1) {
+                            // Estéreo -> Mono: usar apenas o primeiro canal
+                            buffers.splice(1);
+                        }
+                        else {
+                            // Outros casos: usar apenas os canais disponíveis até o limite esperado
+                            while (buffers.length < this.numChannels && buffers.length > 0) {
+                                // Duplicar o último canal se necessário
+                                buffers.push(new Float32Array(buffers[buffers.length - 1]));
+                            }
+                            if (buffers.length > this.numChannels) {
+                                buffers.splice(this.numChannels);
+                            }
+                        }
+                    }
                     // Codificar os dados
-                    if (this.encoder) {
+                    if (this.encoder && buffers.length > 0) {
                         this.encoder.encode(buffers);
                     }
                 }
@@ -147,6 +169,9 @@ class WebAudioRecorder {
             if (!this.encoder) {
                 throw new Error('Encoder is not initialized');
             }
+            // Aguardar um pouco para garantir que todos os callbacks de áudio foram processados
+            // Isso evita condições de corrida onde finish() é chamado antes de todos os buffers serem processados
+            await new Promise(resolve => setTimeout(resolve, 50));
             const blob = this.encoder.finish(mimeType);
             const url = URL.createObjectURL(blob);
             const timecode = Date.now() - this.startTime;
@@ -643,15 +668,43 @@ class OggVorbisEncoderWrapper {
      */
     constructor(sampleRate, numChannels, options = {}) {
         this.encoder = null;
+        this.bufferCount = 0;
+        this.totalSamples = 0;
+        // Validar parâmetros
+        if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+            throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+        }
+        if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+            throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+        }
         this.sampleRate = sampleRate;
         this.numChannels = numChannels;
-        this.quality = options.quality ?? 0.5;
+        // Validar e limitar qualidade (-0.1 a 1.0 para Vorbis)
+        const rawQuality = options.quality ?? 0.5;
+        if (!Number.isFinite(rawQuality)) {
+            console.warn(`Invalid quality value: ${rawQuality}. Using default 0.5`);
+            this.quality = 0.5;
+        }
+        else {
+            // Clamp quality to valid range
+            this.quality = Math.max(-0.1, Math.min(1.0, rawQuality));
+            if (rawQuality !== this.quality) {
+                console.warn(`Quality value ${rawQuality} clamped to valid range: ${this.quality}`);
+            }
+        }
         // Verificar se OggVorbisEncoder está disponível
         if (typeof OggVorbisEncoder === 'undefined') {
             throw new Error('OggVorbisEncoder is not loaded. Make sure to load OggVorbisEncoder.min.js before using this encoder.');
         }
-        // Criar instância do encoder
-        this.encoder = new OggVorbisEncoder(sampleRate, numChannels, this.quality);
+        try {
+            // Criar instância do encoder
+            this.encoder = new OggVorbisEncoder(sampleRate, numChannels, this.quality);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to initialize OGG encoder: ${errorMsg}. ` +
+                `Parameters: sampleRate=${sampleRate}, numChannels=${numChannels}, quality=${this.quality}`);
+        }
     }
     /**
      * Codifica buffers de áudio
@@ -665,7 +718,60 @@ class OggVorbisEncoderWrapper {
         if (buffers.length !== this.numChannels) {
             throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
         }
-        this.encoder.encode(buffers);
+        // Validar que todos os buffers têm o mesmo tamanho
+        if (buffers.length > 0) {
+            const expectedLength = buffers[0].length;
+            for (let i = 1; i < buffers.length; i++) {
+                if (buffers[i].length !== expectedLength) {
+                    throw new Error(`Channel ${i} has length ${buffers[i].length}, expected ${expectedLength}`);
+                }
+            }
+            // Validar que há dados para processar
+            if (expectedLength === 0) {
+                // Buffer vazio, não há nada para codificar
+                return;
+            }
+        }
+        else {
+            // Nenhum buffer fornecido
+            return;
+        }
+        // Criar cópias dos buffers e validar valores (NaN, Infinity)
+        const safeBuffers = buffers.map((buffer, channelIndex) => {
+            const safeBuffer = new Float32Array(buffer.length);
+            let hasInvalidValues = false;
+            for (let i = 0; i < buffer.length; i++) {
+                const value = buffer[i];
+                // Verificar NaN e Infinity
+                if (!Number.isFinite(value)) {
+                    hasInvalidValues = true;
+                    // Substituir valores inválidos por 0
+                    safeBuffer[i] = 0;
+                }
+                else {
+                    // Clamp valores para o range válido de áudio (-1.0 a 1.0)
+                    safeBuffer[i] = Math.max(-1, Math.min(1.0, value));
+                }
+            }
+            if (hasInvalidValues) {
+                console.warn(`OGG Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                    `Replaced with 0. Buffer length: ${buffer.length}`);
+            }
+            return safeBuffer;
+        });
+        try {
+            this.encoder.encode(safeBuffers);
+            // Contar buffers processados para garantir que há dados antes de finalizar
+            this.bufferCount++;
+            this.totalSamples += safeBuffers[0].length;
+        }
+        catch (error) {
+            // Melhorar mensagem de erro para incluir informações de debug
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`OGG encoding error: ${errorMsg}. ` +
+                `Buffers: ${buffers.length} channels, lengths: ${buffers.map(b => b.length).join(', ')}, ` +
+                `Total buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}`);
+        }
     }
     /**
      * Finaliza o encoding e retorna o Blob OGG
@@ -677,7 +783,25 @@ class OggVorbisEncoderWrapper {
         if (!this.encoder) {
             throw new Error('Encoder is not initialized');
         }
-        return this.encoder.finish(mimeType);
+        // Verificar se há dados processados
+        if (this.bufferCount === 0) {
+            console.warn('OGG Encoder: finish() called but no buffers were encoded. This may cause issues with the Emscripten encoder.');
+            // Ainda tentar finalizar, mas avisar
+        }
+        try {
+            const blob = this.encoder.finish(mimeType);
+            // Validar que o blob não está vazio
+            if (blob.size === 0) {
+                console.warn('OGG Encoder: finish() returned empty blob. This may indicate insufficient audio data was encoded.');
+            }
+            return blob;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`OGG finish() error: ${errorMsg}. ` +
+                `Buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}, ` +
+                `Sample rate: ${this.sampleRate}, Channels: ${this.numChannels}, Quality: ${this.quality}`);
+        }
     }
     /**
      * Cancela o encoding
@@ -687,6 +811,9 @@ class OggVorbisEncoderWrapper {
             this.encoder.cancel();
             this.encoder = null;
         }
+        // Reset contadores
+        this.bufferCount = 0;
+        this.totalSamples = 0;
     }
 }
 /**
@@ -841,15 +968,43 @@ class Mp3LameEncoderWrapper {
      */
     constructor(sampleRate, numChannels, options = {}) {
         this.encoder = null;
+        this.bufferCount = 0;
+        this.totalSamples = 0;
+        // Validar parâmetros
+        if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+            throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+        }
+        if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+            throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+        }
         this.sampleRate = sampleRate;
         this.numChannels = numChannels;
-        this.bitrate = options.bitrate ?? 128;
+        // Validar e limitar bitrate (32 a 320 kbps para MP3)
+        const rawBitrate = options.bitrate ?? 128;
+        if (!Number.isFinite(rawBitrate) || !Number.isInteger(rawBitrate)) {
+            console.warn(`Invalid bitrate value: ${rawBitrate}. Using default 128`);
+            this.bitrate = 128;
+        }
+        else {
+            // Clamp bitrate to valid range
+            this.bitrate = Math.max(32, Math.min(320, rawBitrate));
+            if (rawBitrate !== this.bitrate) {
+                console.warn(`Bitrate value ${rawBitrate} clamped to valid range: ${this.bitrate}`);
+            }
+        }
         // Verificar se Mp3LameEncoder está disponível
         if (typeof Mp3LameEncoder === 'undefined') {
             throw new Error('Mp3LameEncoder is not loaded. Make sure to load Mp3LameEncoder.min.js before using this encoder.');
         }
-        // Criar instância do encoder
-        this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+        try {
+            // Criar instância do encoder
+            this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to initialize MP3 encoder: ${errorMsg}. ` +
+                `Parameters: sampleRate=${sampleRate}, numChannels=${numChannels}, bitrate=${this.bitrate}`);
+        }
     }
     /**
      * Codifica buffers de áudio
@@ -863,7 +1018,60 @@ class Mp3LameEncoderWrapper {
         if (buffers.length !== this.numChannels) {
             throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
         }
-        this.encoder.encode(buffers);
+        // Validar que todos os buffers têm o mesmo tamanho
+        if (buffers.length > 0) {
+            const expectedLength = buffers[0].length;
+            for (let i = 1; i < buffers.length; i++) {
+                if (buffers[i].length !== expectedLength) {
+                    throw new Error(`Channel ${i} has length ${buffers[i].length}, expected ${expectedLength}`);
+                }
+            }
+            // Validar que há dados para processar
+            if (expectedLength === 0) {
+                // Buffer vazio, não há nada para codificar
+                return;
+            }
+        }
+        else {
+            // Nenhum buffer fornecido
+            return;
+        }
+        // Criar cópias dos buffers e validar valores (NaN, Infinity)
+        const safeBuffers = buffers.map((buffer, channelIndex) => {
+            const safeBuffer = new Float32Array(buffer.length);
+            let hasInvalidValues = false;
+            for (let i = 0; i < buffer.length; i++) {
+                const value = buffer[i];
+                // Verificar NaN e Infinity
+                if (!Number.isFinite(value)) {
+                    hasInvalidValues = true;
+                    // Substituir valores inválidos por 0
+                    safeBuffer[i] = 0;
+                }
+                else {
+                    // Clamp valores para o range válido de áudio (-1.0 a 1.0)
+                    safeBuffer[i] = Math.max(-1, Math.min(1.0, value));
+                }
+            }
+            if (hasInvalidValues) {
+                console.warn(`MP3 Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                    `Replaced with 0. Buffer length: ${buffer.length}`);
+            }
+            return safeBuffer;
+        });
+        try {
+            this.encoder.encode(safeBuffers);
+            // Contar buffers processados para garantir que há dados antes de finalizar
+            this.bufferCount++;
+            this.totalSamples += safeBuffers[0].length;
+        }
+        catch (error) {
+            // Melhorar mensagem de erro para incluir informações de debug
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`MP3 encoding error: ${errorMsg}. ` +
+                `Buffers: ${buffers.length} channels, lengths: ${buffers.map(b => b.length).join(', ')}, ` +
+                `Total buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}`);
+        }
     }
     /**
      * Finaliza o encoding e retorna o Blob MP3
@@ -875,7 +1083,25 @@ class Mp3LameEncoderWrapper {
         if (!this.encoder) {
             throw new Error('Encoder is not initialized');
         }
-        return this.encoder.finish(mimeType);
+        // Verificar se há dados processados
+        if (this.bufferCount === 0) {
+            console.warn('MP3 Encoder: finish() called but no buffers were encoded. This may cause issues with the Emscripten encoder.');
+            // Ainda tentar finalizar, mas avisar
+        }
+        try {
+            const blob = this.encoder.finish(mimeType);
+            // Validar que o blob não está vazio
+            if (blob.size === 0) {
+                console.warn('MP3 Encoder: finish() returned empty blob. This may indicate insufficient audio data was encoded.');
+            }
+            return blob;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`MP3 finish() error: ${errorMsg}. ` +
+                `Buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}, ` +
+                `Sample rate: ${this.sampleRate}, Channels: ${this.numChannels}, Bitrate: ${this.bitrate}`);
+        }
     }
     /**
      * Cancela o encoding
@@ -885,6 +1111,9 @@ class Mp3LameEncoderWrapper {
             this.encoder.cancel();
             this.encoder = null;
         }
+        // Reset contadores
+        this.bufferCount = 0;
+        this.totalSamples = 0;
     }
 }
 /**

package/dist/index.esm.js

@@ -96,14 +96,36 @@ class WebAudioRecorder {
                 }
                 try {
                     const inputBuffer = event.inputBuffer;
+                    const actualChannels = inputBuffer.numberOfChannels;
                     const buffers = [];
-                    // Extrair dados de cada canal
-                    for (let channel = 0; channel < this.numChannels; channel++) {
+                    // Extrair dados de cada canal disponível
+                    for (let channel = 0; channel < actualChannels; channel++) {
                         const channelData = inputBuffer.getChannelData(channel);
                         buffers.push(new Float32Array(channelData));
                     }
+                    // Se o número de canais do buffer não corresponde ao esperado, ajustar
+                    if (actualChannels !== this.numChannels) {
+                        if (actualChannels === 1 && this.numChannels === 2) {
+                            // Mono -> Estéreo: duplicar o canal
+                            buffers.push(new Float32Array(buffers[0]));
+                        }
+                        else if (actualChannels === 2 && this.numChannels === 1) {
+                            // Estéreo -> Mono: usar apenas o primeiro canal
+                            buffers.splice(1);
+                        }
+                        else {
+                            // Outros casos: usar apenas os canais disponíveis até o limite esperado
+                            while (buffers.length < this.numChannels && buffers.length > 0) {
+                                // Duplicar o último canal se necessário
+                                buffers.push(new Float32Array(buffers[buffers.length - 1]));
+                            }
+                            if (buffers.length > this.numChannels) {
+                                buffers.splice(this.numChannels);
+                            }
+                        }
+                    }
                     // Codificar os dados
-                    if (this.encoder) {
+                    if (this.encoder && buffers.length > 0) {
                         this.encoder.encode(buffers);
                     }
                 }
@@ -144,6 +166,9 @@ class WebAudioRecorder {
             if (!this.encoder) {
                 throw new Error('Encoder is not initialized');
             }
+            // Aguardar um pouco para garantir que todos os callbacks de áudio foram processados
+            // Isso evita condições de corrida onde finish() é chamado antes de todos os buffers serem processados
+            await new Promise(resolve => setTimeout(resolve, 50));
             const blob = this.encoder.finish(mimeType);
             const url = URL.createObjectURL(blob);
             const timecode = Date.now() - this.startTime;
@@ -640,15 +665,43 @@ class OggVorbisEncoderWrapper {
      */
     constructor(sampleRate, numChannels, options = {}) {
         this.encoder = null;
+        this.bufferCount = 0;
+        this.totalSamples = 0;
+        // Validar parâmetros
+        if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+            throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+        }
+        if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+            throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+        }
         this.sampleRate = sampleRate;
         this.numChannels = numChannels;
-        this.quality = options.quality ?? 0.5;
+        // Validar e limitar qualidade (-0.1 a 1.0 para Vorbis)
+        const rawQuality = options.quality ?? 0.5;
+        if (!Number.isFinite(rawQuality)) {
+            console.warn(`Invalid quality value: ${rawQuality}. Using default 0.5`);
+            this.quality = 0.5;
+        }
+        else {
+            // Clamp quality to valid range
+            this.quality = Math.max(-0.1, Math.min(1.0, rawQuality));
+            if (rawQuality !== this.quality) {
+                console.warn(`Quality value ${rawQuality} clamped to valid range: ${this.quality}`);
+            }
+        }
         // Verificar se OggVorbisEncoder está disponível
         if (typeof OggVorbisEncoder === 'undefined') {
             throw new Error('OggVorbisEncoder is not loaded. Make sure to load OggVorbisEncoder.min.js before using this encoder.');
         }
-        // Criar instância do encoder
-        this.encoder = new OggVorbisEncoder(sampleRate, numChannels, this.quality);
+        try {
+            // Criar instância do encoder
+            this.encoder = new OggVorbisEncoder(sampleRate, numChannels, this.quality);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to initialize OGG encoder: ${errorMsg}. ` +
+                `Parameters: sampleRate=${sampleRate}, numChannels=${numChannels}, quality=${this.quality}`);
+        }
     }
     /**
      * Codifica buffers de áudio
@@ -662,7 +715,60 @@ class OggVorbisEncoderWrapper {
         if (buffers.length !== this.numChannels) {
             throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
         }
-        this.encoder.encode(buffers);
+        // Validar que todos os buffers têm o mesmo tamanho
+        if (buffers.length > 0) {
+            const expectedLength = buffers[0].length;
+            for (let i = 1; i < buffers.length; i++) {
+                if (buffers[i].length !== expectedLength) {
+                    throw new Error(`Channel ${i} has length ${buffers[i].length}, expected ${expectedLength}`);
+                }
+            }
+            // Validar que há dados para processar
+            if (expectedLength === 0) {
+                // Buffer vazio, não há nada para codificar
+                return;
+            }
+        }
+        else {
+            // Nenhum buffer fornecido
+            return;
+        }
+        // Criar cópias dos buffers e validar valores (NaN, Infinity)
+        const safeBuffers = buffers.map((buffer, channelIndex) => {
+            const safeBuffer = new Float32Array(buffer.length);
+            let hasInvalidValues = false;
+            for (let i = 0; i < buffer.length; i++) {
+                const value = buffer[i];
+                // Verificar NaN e Infinity
+                if (!Number.isFinite(value)) {
+                    hasInvalidValues = true;
+                    // Substituir valores inválidos por 0
+                    safeBuffer[i] = 0;
+                }
+                else {
+                    // Clamp valores para o range válido de áudio (-1.0 a 1.0)
+                    safeBuffer[i] = Math.max(-1, Math.min(1.0, value));
+                }
+            }
+            if (hasInvalidValues) {
+                console.warn(`OGG Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                    `Replaced with 0. Buffer length: ${buffer.length}`);
+            }
+            return safeBuffer;
+        });
+        try {
+            this.encoder.encode(safeBuffers);
+            // Contar buffers processados para garantir que há dados antes de finalizar
+            this.bufferCount++;
+            this.totalSamples += safeBuffers[0].length;
+        }
+        catch (error) {
+            // Melhorar mensagem de erro para incluir informações de debug
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`OGG encoding error: ${errorMsg}. ` +
+                `Buffers: ${buffers.length} channels, lengths: ${buffers.map(b => b.length).join(', ')}, ` +
+                `Total buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}`);
+        }
     }
     /**
      * Finaliza o encoding e retorna o Blob OGG
@@ -674,7 +780,25 @@ class OggVorbisEncoderWrapper {
         if (!this.encoder) {
             throw new Error('Encoder is not initialized');
         }
-        return this.encoder.finish(mimeType);
+        // Verificar se há dados processados
+        if (this.bufferCount === 0) {
+            console.warn('OGG Encoder: finish() called but no buffers were encoded. This may cause issues with the Emscripten encoder.');
+            // Ainda tentar finalizar, mas avisar
+        }
+        try {
+            const blob = this.encoder.finish(mimeType);
+            // Validar que o blob não está vazio
+            if (blob.size === 0) {
+                console.warn('OGG Encoder: finish() returned empty blob. This may indicate insufficient audio data was encoded.');
+            }
+            return blob;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`OGG finish() error: ${errorMsg}. ` +
+                `Buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}, ` +
+                `Sample rate: ${this.sampleRate}, Channels: ${this.numChannels}, Quality: ${this.quality}`);
+        }
     }
     /**
      * Cancela o encoding
@@ -684,6 +808,9 @@ class OggVorbisEncoderWrapper {
             this.encoder.cancel();
             this.encoder = null;
         }
+        // Reset contadores
+        this.bufferCount = 0;
+        this.totalSamples = 0;
     }
 }
 /**
@@ -838,15 +965,43 @@ class Mp3LameEncoderWrapper {
      */
     constructor(sampleRate, numChannels, options = {}) {
         this.encoder = null;
+        this.bufferCount = 0;
+        this.totalSamples = 0;
+        // Validar parâmetros
+        if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+            throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+        }
+        if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+            throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+        }
         this.sampleRate = sampleRate;
         this.numChannels = numChannels;
-        this.bitrate = options.bitrate ?? 128;
+        // Validar e limitar bitrate (32 a 320 kbps para MP3)
+        const rawBitrate = options.bitrate ?? 128;
+        if (!Number.isFinite(rawBitrate) || !Number.isInteger(rawBitrate)) {
+            console.warn(`Invalid bitrate value: ${rawBitrate}. Using default 128`);
+            this.bitrate = 128;
+        }
+        else {
+            // Clamp bitrate to valid range
+            this.bitrate = Math.max(32, Math.min(320, rawBitrate));
+            if (rawBitrate !== this.bitrate) {
+                console.warn(`Bitrate value ${rawBitrate} clamped to valid range: ${this.bitrate}`);
+            }
+        }
         // Verificar se Mp3LameEncoder está disponível
         if (typeof Mp3LameEncoder === 'undefined') {
             throw new Error('Mp3LameEncoder is not loaded. Make sure to load Mp3LameEncoder.min.js before using this encoder.');
         }
-        // Criar instância do encoder
-        this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+        try {
+            // Criar instância do encoder
+            this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to initialize MP3 encoder: ${errorMsg}. ` +
+                `Parameters: sampleRate=${sampleRate}, numChannels=${numChannels}, bitrate=${this.bitrate}`);
+        }
     }
     /**
      * Codifica buffers de áudio
@@ -860,7 +1015,60 @@ class Mp3LameEncoderWrapper {
         if (buffers.length !== this.numChannels) {
             throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
         }
-        this.encoder.encode(buffers);
+        // Validar que todos os buffers têm o mesmo tamanho
+        if (buffers.length > 0) {
+            const expectedLength = buffers[0].length;
+            for (let i = 1; i < buffers.length; i++) {
+                if (buffers[i].length !== expectedLength) {
+                    throw new Error(`Channel ${i} has length ${buffers[i].length}, expected ${expectedLength}`);
+                }
+            }
+            // Validar que há dados para processar
+            if (expectedLength === 0) {
+                // Buffer vazio, não há nada para codificar
+                return;
+            }
+        }
+        else {
+            // Nenhum buffer fornecido
+            return;
+        }
+        // Criar cópias dos buffers e validar valores (NaN, Infinity)
+        const safeBuffers = buffers.map((buffer, channelIndex) => {
+            const safeBuffer = new Float32Array(buffer.length);
+            let hasInvalidValues = false;
+            for (let i = 0; i < buffer.length; i++) {
+                const value = buffer[i];
+                // Verificar NaN e Infinity
+                if (!Number.isFinite(value)) {
+                    hasInvalidValues = true;
+                    // Substituir valores inválidos por 0
+                    safeBuffer[i] = 0;
+                }
+                else {
+                    // Clamp valores para o range válido de áudio (-1.0 a 1.0)
+                    safeBuffer[i] = Math.max(-1, Math.min(1.0, value));
+                }
+            }
+            if (hasInvalidValues) {
+                console.warn(`MP3 Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                    `Replaced with 0. Buffer length: ${buffer.length}`);
+            }
+            return safeBuffer;
+        });
+        try {
+            this.encoder.encode(safeBuffers);
+            // Contar buffers processados para garantir que há dados antes de finalizar
+            this.bufferCount++;
+            this.totalSamples += safeBuffers[0].length;
+        }
+        catch (error) {
+            // Melhorar mensagem de erro para incluir informações de debug
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`MP3 encoding error: ${errorMsg}. ` +
+                `Buffers: ${buffers.length} channels, lengths: ${buffers.map(b => b.length).join(', ')}, ` +
+                `Total buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}`);
+        }
     }
     /**
      * Finaliza o encoding e retorna o Blob MP3
@@ -872,7 +1080,25 @@ class Mp3LameEncoderWrapper {
         if (!this.encoder) {
             throw new Error('Encoder is not initialized');
         }
-        return this.encoder.finish(mimeType);
+        // Verificar se há dados processados
+        if (this.bufferCount === 0) {
+            console.warn('MP3 Encoder: finish() called but no buffers were encoded. This may cause issues with the Emscripten encoder.');
+            // Ainda tentar finalizar, mas avisar
+        }
+        try {
+            const blob = this.encoder.finish(mimeType);
+            // Validar que o blob não está vazio
+            if (blob.size === 0) {
+                console.warn('MP3 Encoder: finish() returned empty blob. This may indicate insufficient audio data was encoded.');
+            }
+            return blob;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`MP3 finish() error: ${errorMsg}. ` +
+                `Buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}, ` +
+                `Sample rate: ${this.sampleRate}, Channels: ${this.numChannels}, Bitrate: ${this.bitrate}`);
+        }
     }
     /**
      * Cancela o encoding
@@ -882,6 +1108,9 @@ class Mp3LameEncoderWrapper {
             this.encoder.cancel();
             this.encoder = null;
         }
+        // Reset contadores
+        this.bufferCount = 0;
+        this.totalSamples = 0;
     }
 }
 /**

package/dist/index.umd.js

@@ -103,14 +103,36 @@
                     }
                     try {
                         const inputBuffer = event.inputBuffer;
+                        const actualChannels = inputBuffer.numberOfChannels;
                         const buffers = [];
-                        // Extrair dados de cada canal
-                        for (let channel = 0; channel < this.numChannels; channel++) {
+                        // Extrair dados de cada canal disponível
+                        for (let channel = 0; channel < actualChannels; channel++) {
                             const channelData = inputBuffer.getChannelData(channel);
                             buffers.push(new Float32Array(channelData));
                         }
+                        // Se o número de canais do buffer não corresponde ao esperado, ajustar
+                        if (actualChannels !== this.numChannels) {
+                            if (actualChannels === 1 && this.numChannels === 2) {
+                                // Mono -> Estéreo: duplicar o canal
+                                buffers.push(new Float32Array(buffers[0]));
+                            }
+                            else if (actualChannels === 2 && this.numChannels === 1) {
+                                // Estéreo -> Mono: usar apenas o primeiro canal
+                                buffers.splice(1);
+                            }
+                            else {
+                                // Outros casos: usar apenas os canais disponíveis até o limite esperado
+                                while (buffers.length < this.numChannels && buffers.length > 0) {
+                                    // Duplicar o último canal se necessário
+                                    buffers.push(new Float32Array(buffers[buffers.length - 1]));
+                                }
+                                if (buffers.length > this.numChannels) {
+                                    buffers.splice(this.numChannels);
+                                }
+                            }
+                        }
                         // Codificar os dados
-                        if (this.encoder) {
+                        if (this.encoder && buffers.length > 0) {
                             this.encoder.encode(buffers);
                         }
                     }
@@ -151,6 +173,9 @@
                 if (!this.encoder) {
                     throw new Error('Encoder is not initialized');
                 }
+                // Aguardar um pouco para garantir que todos os callbacks de áudio foram processados
+                // Isso evita condições de corrida onde finish() é chamado antes de todos os buffers serem processados
+                await new Promise(resolve => setTimeout(resolve, 50));
                 const blob = this.encoder.finish(mimeType);
                 const url = URL.createObjectURL(blob);
                 const timecode = Date.now() - this.startTime;
@@ -647,15 +672,43 @@
          */
         constructor(sampleRate, numChannels, options = {}) {
             this.encoder = null;
+            this.bufferCount = 0;
+            this.totalSamples = 0;
+            // Validar parâmetros
+            if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+                throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+            }
+            if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+                throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+            }
             this.sampleRate = sampleRate;
             this.numChannels = numChannels;
-            this.quality = options.quality ?? 0.5;
+            // Validar e limitar qualidade (-0.1 a 1.0 para Vorbis)
+            const rawQuality = options.quality ?? 0.5;
+            if (!Number.isFinite(rawQuality)) {
+                console.warn(`Invalid quality value: ${rawQuality}. Using default 0.5`);
+                this.quality = 0.5;
+            }
+            else {
+                // Clamp quality to valid range
+                this.quality = Math.max(-0.1, Math.min(1.0, rawQuality));
+                if (rawQuality !== this.quality) {
+                    console.warn(`Quality value ${rawQuality} clamped to valid range: ${this.quality}`);
+                }
+            }
             // Verificar se OggVorbisEncoder está disponível
             if (typeof OggVorbisEncoder === 'undefined') {
                 throw new Error('OggVorbisEncoder is not loaded. Make sure to load OggVorbisEncoder.min.js before using this encoder.');
             }
-            // Criar instância do encoder
-            this.encoder = new OggVorbisEncoder(sampleRate, numChannels, this.quality);
+            try {
+                // Criar instância do encoder
+                this.encoder = new OggVorbisEncoder(sampleRate, numChannels, this.quality);
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to initialize OGG encoder: ${errorMsg}. ` +
+                    `Parameters: sampleRate=${sampleRate}, numChannels=${numChannels}, quality=${this.quality}`);
+            }
         }
         /**
          * Codifica buffers de áudio
@@ -669,7 +722,60 @@
             if (buffers.length !== this.numChannels) {
                 throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
             }
-            this.encoder.encode(buffers);
+            // Validar que todos os buffers têm o mesmo tamanho
+            if (buffers.length > 0) {
+                const expectedLength = buffers[0].length;
+                for (let i = 1; i < buffers.length; i++) {
+                    if (buffers[i].length !== expectedLength) {
+                        throw new Error(`Channel ${i} has length ${buffers[i].length}, expected ${expectedLength}`);
+                    }
+                }
+                // Validar que há dados para processar
+                if (expectedLength === 0) {
+                    // Buffer vazio, não há nada para codificar
+                    return;
+                }
+            }
+            else {
+                // Nenhum buffer fornecido
+                return;
+            }
+            // Criar cópias dos buffers e validar valores (NaN, Infinity)
+            const safeBuffers = buffers.map((buffer, channelIndex) => {
+                const safeBuffer = new Float32Array(buffer.length);
+                let hasInvalidValues = false;
+                for (let i = 0; i < buffer.length; i++) {
+                    const value = buffer[i];
+                    // Verificar NaN e Infinity
+                    if (!Number.isFinite(value)) {
+                        hasInvalidValues = true;
+                        // Substituir valores inválidos por 0
+                        safeBuffer[i] = 0;
+                    }
+                    else {
+                        // Clamp valores para o range válido de áudio (-1.0 a 1.0)
+                        safeBuffer[i] = Math.max(-1, Math.min(1.0, value));
+                    }
+                }
+                if (hasInvalidValues) {
+                    console.warn(`OGG Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                        `Replaced with 0. Buffer length: ${buffer.length}`);
+                }
+                return safeBuffer;
+            });
+            try {
+                this.encoder.encode(safeBuffers);
+                // Contar buffers processados para garantir que há dados antes de finalizar
+                this.bufferCount++;
+                this.totalSamples += safeBuffers[0].length;
+            }
+            catch (error) {
+                // Melhorar mensagem de erro para incluir informações de debug
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                throw new Error(`OGG encoding error: ${errorMsg}. ` +
+                    `Buffers: ${buffers.length} channels, lengths: ${buffers.map(b => b.length).join(', ')}, ` +
+                    `Total buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}`);
+            }
         }
         /**
          * Finaliza o encoding e retorna o Blob OGG
@@ -681,7 +787,25 @@
             if (!this.encoder) {
                 throw new Error('Encoder is not initialized');
             }
-            return this.encoder.finish(mimeType);
+            // Verificar se há dados processados
+            if (this.bufferCount === 0) {
+                console.warn('OGG Encoder: finish() called but no buffers were encoded. This may cause issues with the Emscripten encoder.');
+                // Ainda tentar finalizar, mas avisar
+            }
+            try {
+                const blob = this.encoder.finish(mimeType);
+                // Validar que o blob não está vazio
+                if (blob.size === 0) {
+                    console.warn('OGG Encoder: finish() returned empty blob. This may indicate insufficient audio data was encoded.');
+                }
+                return blob;
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                throw new Error(`OGG finish() error: ${errorMsg}. ` +
+                    `Buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}, ` +
+                    `Sample rate: ${this.sampleRate}, Channels: ${this.numChannels}, Quality: ${this.quality}`);
+            }
         }
         /**
          * Cancela o encoding
@@ -691,6 +815,9 @@
                 this.encoder.cancel();
                 this.encoder = null;
             }
+            // Reset contadores
+            this.bufferCount = 0;
+            this.totalSamples = 0;
         }
     }
     /**
@@ -845,15 +972,43 @@
          */
         constructor(sampleRate, numChannels, options = {}) {
             this.encoder = null;
+            this.bufferCount = 0;
+            this.totalSamples = 0;
+            // Validar parâmetros
+            if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+                throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+            }
+            if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+                throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+            }
             this.sampleRate = sampleRate;
             this.numChannels = numChannels;
-            this.bitrate = options.bitrate ?? 128;
+            // Validar e limitar bitrate (32 a 320 kbps para MP3)
+            const rawBitrate = options.bitrate ?? 128;
+            if (!Number.isFinite(rawBitrate) || !Number.isInteger(rawBitrate)) {
+                console.warn(`Invalid bitrate value: ${rawBitrate}. Using default 128`);
+                this.bitrate = 128;
+            }
+            else {
+                // Clamp bitrate to valid range
+                this.bitrate = Math.max(32, Math.min(320, rawBitrate));
+                if (rawBitrate !== this.bitrate) {
+                    console.warn(`Bitrate value ${rawBitrate} clamped to valid range: ${this.bitrate}`);
+                }
+            }
             // Verificar se Mp3LameEncoder está disponível
             if (typeof Mp3LameEncoder === 'undefined') {
                 throw new Error('Mp3LameEncoder is not loaded. Make sure to load Mp3LameEncoder.min.js before using this encoder.');
             }
-            // Criar instância do encoder
-            this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+            try {
+                // Criar instância do encoder
+                this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to initialize MP3 encoder: ${errorMsg}. ` +
+                    `Parameters: sampleRate=${sampleRate}, numChannels=${numChannels}, bitrate=${this.bitrate}`);
+            }
         }
         /**
          * Codifica buffers de áudio
@@ -867,7 +1022,60 @@
             if (buffers.length !== this.numChannels) {
                 throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
             }
-            this.encoder.encode(buffers);
+            // Validar que todos os buffers têm o mesmo tamanho
+            if (buffers.length > 0) {
+                const expectedLength = buffers[0].length;
+                for (let i = 1; i < buffers.length; i++) {
+                    if (buffers[i].length !== expectedLength) {
+                        throw new Error(`Channel ${i} has length ${buffers[i].length}, expected ${expectedLength}`);
+                    }
+                }
+                // Validar que há dados para processar
+                if (expectedLength === 0) {
+                    // Buffer vazio, não há nada para codificar
+                    return;
+                }
+            }
+            else {
+                // Nenhum buffer fornecido
+                return;
+            }
+            // Criar cópias dos buffers e validar valores (NaN, Infinity)
+            const safeBuffers = buffers.map((buffer, channelIndex) => {
+                const safeBuffer = new Float32Array(buffer.length);
+                let hasInvalidValues = false;
+                for (let i = 0; i < buffer.length; i++) {
+                    const value = buffer[i];
+                    // Verificar NaN e Infinity
+                    if (!Number.isFinite(value)) {
+                        hasInvalidValues = true;
+                        // Substituir valores inválidos por 0
+                        safeBuffer[i] = 0;
+                    }
+                    else {
+                        // Clamp valores para o range válido de áudio (-1.0 a 1.0)
+                        safeBuffer[i] = Math.max(-1, Math.min(1.0, value));
+                    }
+                }
+                if (hasInvalidValues) {
+                    console.warn(`MP3 Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                        `Replaced with 0. Buffer length: ${buffer.length}`);
+                }
+                return safeBuffer;
+            });
+            try {
+                this.encoder.encode(safeBuffers);
+                // Contar buffers processados para garantir que há dados antes de finalizar
+                this.bufferCount++;
+                this.totalSamples += safeBuffers[0].length;
+            }
+            catch (error) {
+                // Melhorar mensagem de erro para incluir informações de debug
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                throw new Error(`MP3 encoding error: ${errorMsg}. ` +
+                    `Buffers: ${buffers.length} channels, lengths: ${buffers.map(b => b.length).join(', ')}, ` +
+                    `Total buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}`);
+            }
         }
         /**
          * Finaliza o encoding e retorna o Blob MP3
@@ -879,7 +1087,25 @@
             if (!this.encoder) {
                 throw new Error('Encoder is not initialized');
             }
-            return this.encoder.finish(mimeType);
+            // Verificar se há dados processados
+            if (this.bufferCount === 0) {
+                console.warn('MP3 Encoder: finish() called but no buffers were encoded. This may cause issues with the Emscripten encoder.');
+                // Ainda tentar finalizar, mas avisar
+            }
+            try {
+                const blob = this.encoder.finish(mimeType);
+                // Validar que o blob não está vazio
+                if (blob.size === 0) {
+                    console.warn('MP3 Encoder: finish() returned empty blob. This may indicate insufficient audio data was encoded.');
+                }
+                return blob;
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                throw new Error(`MP3 finish() error: ${errorMsg}. ` +
+                    `Buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}, ` +
+                    `Sample rate: ${this.sampleRate}, Channels: ${this.numChannels}, Bitrate: ${this.bitrate}`);
+            }
         }
         /**
          * Cancela o encoding
@@ -889,6 +1115,9 @@
                 this.encoder.cancel();
                 this.encoder = null;
             }
+            // Reset contadores
+            this.bufferCount = 0;
+            this.totalSamples = 0;
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-audio-recorder-ts",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "type": "module",
   "description": "TypeScript port of web-audio-recorder-js with full type support for WAV, OGG Vorbis, and MP3 audio recording",
   "main": "dist/index.cjs.js",