Revert "feat: implement AudioConcatenator package with audio processing utilities"

This reverts commit 9274377d1e8d682214a22725451e1033b67391ef.

src/processors/AudioConcatenator/__init__.py

@@ -1,3 +0,0 @@
-# __init__.py for AudioConcatenator package
-
-from .concatenator import AudioConcatenator

src/processors/AudioConcatenator/audio_filter.py

@@ -1,14 +0,0 @@
-"""Audio filtering utilities for AudioConcatenator."""
-
-import numpy as np
-
-class AudioFilter:
-    @staticmethod
-    def remove_clicks_and_pops(audio_data: np.ndarray) -> np.ndarray:
-        try:
-            from scipy import signal
-            sos = signal.butter(2, 80, btype='highpass', fs=22050, output='sos')
-            filtered_audio = signal.sosfilt(sos, audio_data)
-            return filtered_audio.astype(np.float32)
-        except ImportError:
-            return audio_data.astype(np.float32)

src/processors/AudioConcatenator/audio_utils.py

@@ -1,23 +0,0 @@
-"""Audio normalization and fade utilities for AudioConcatenator."""
-
-import numpy as np
-
-class AudioUtils:
-    @staticmethod
-    def normalize_audio(audio_data: np.ndarray) -> np.ndarray:
-        max_val = np.max(np.abs(audio_data))
-        if max_val == 0:
-            return audio_data
-        return (audio_data * (0.95 / max_val)).astype(np.float32)
-
-    @staticmethod
-    def apply_fade_effects(audio_data: np.ndarray, fade_duration: float, sample_rate: int) -> np.ndarray:
-        fade_samples = int(fade_duration * sample_rate)
-        if len(audio_data) < 2 * fade_samples:
-            return audio_data
-        audio_with_fades = audio_data.copy()
-        fade_in = np.linspace(0, 1, fade_samples)
-        audio_with_fades[:fade_samples] *= fade_in
-        fade_out = np.linspace(1, 0, fade_samples)
-        audio_with_fades[-fade_samples:] *= fade_out
-        return audio_with_fades

src/processors/AudioConcatenator/concatenator.py

@@ -1,87 +0,0 @@
-"""AudioConcatenator class implementation."""
-
-import numpy as np
-from typing import List, Tuple, Optional
-import gradio as gr
-from .audio_utils import AudioUtils
-from .audio_filter import AudioFilter
-from .info import AudioConcatenationInfo
-from .progressive import AudioProgressiveConcatenator
-
-class AudioConcatenator:
-    """Handles concatenation of multiple audio chunks."""
-    
-    def __init__(self, silence_duration: float = 0.5, fade_duration: float = 0.1):
-        self.silence_duration = silence_duration
-        self.fade_duration = fade_duration
-
-    def concatenate_audio_chunks(
-        self,
-        audio_chunks: List[Tuple[int, np.ndarray]],
-        progress_callback: Optional[callable] = None
-    ) -> Tuple[int, np.ndarray]:
-        if not audio_chunks:
-            raise gr.Error("No audio chunks to concatenate")
-        if len(audio_chunks) == 1:
-            return audio_chunks[0]
-        if progress_callback:
-            progress_callback(0.1, desc="Preparing audio concatenation...")
-        sample_rates = [chunk[0] for chunk in audio_chunks]
-        if len(set(sample_rates)) > 1:
-            raise gr.Error(f"Inconsistent sample rates found: {set(sample_rates)}. All chunks must have the same sample rate.")
-        sample_rate = sample_rates[0]
-        if progress_callback:
-            progress_callback(0.2, desc="Normalizing audio chunks...")
-        normalized_chunks = []
-        for i, (_, audio_data) in enumerate(audio_chunks):
-            if audio_data.ndim == 1:
-                normalized_audio = audio_data
-            elif audio_data.ndim == 2:
-                normalized_audio = np.mean(audio_data, axis=1)
-            else:
-                raise gr.Error(f"Unsupported audio format in chunk {i + 1}: {audio_data.shape}")
-            normalized_audio = AudioUtils.normalize_audio(normalized_audio)
-            normalized_audio = AudioUtils.apply_fade_effects(normalized_audio, self.fade_duration, sample_rate)
-            normalized_chunks.append(normalized_audio)
-            if progress_callback:
-                progress = 0.2 + (0.5 * (i + 1) / len(audio_chunks))
-                progress_callback(progress, desc=f"Processed chunk {i + 1}/{len(audio_chunks)}")
-        if progress_callback:
-            progress_callback(0.7, desc="Creating silence segments...")
-        silence_samples = int(self.silence_duration * sample_rate)
-        silence = np.zeros(silence_samples, dtype=np.float32)
-        if progress_callback:
-            progress_callback(0.8, desc="Concatenating audio segments...")
-        concatenated_segments = []
-        for i, chunk in enumerate(normalized_chunks):
-            concatenated_segments.append(chunk)
-            if i < len(normalized_chunks) - 1:
-                concatenated_segments.append(silence)
-            if progress_callback:
-                progress = 0.8 + (0.15 * (i + 1) / len(normalized_chunks))
-                progress_callback(progress, desc=f"Concatenated {i + 1}/{len(normalized_chunks)} chunks")
-        final_audio = np.concatenate(concatenated_segments)
-        if progress_callback:
-            progress_callback(0.95, desc="Finalizing audio...")
-        final_audio = AudioUtils.normalize_audio(final_audio)
-        final_audio = AudioFilter.remove_clicks_and_pops(final_audio)
-        if progress_callback:
-            progress_callback(1.0, desc="Audio concatenation complete!")
-        return sample_rate, final_audio
-
-    def get_concatenation_info(self, audio_chunks: List[Tuple[int, np.ndarray]]) -> dict:
-        return AudioConcatenationInfo.get_concatenation_info(audio_chunks, self.silence_duration)
-
-    def concatenate_progressive(
-        self,
-        new_chunk: Tuple[int, np.ndarray],
-        existing_audio: Optional[Tuple[int, np.ndarray]] = None,
-        progress_callback: Optional[callable] = None
-    ) -> Tuple[int, np.ndarray]:
-        return AudioProgressiveConcatenator.concatenate_progressive(
-            new_chunk,
-            existing_audio,
-            silence_duration=self.silence_duration,
-            fade_duration=self.fade_duration,
-            progress_callback=progress_callback
-        )

src/processors/AudioConcatenator/info.py

@@ -1,29 +0,0 @@
-"""AudioConcatenator info utilities."""
-
-import numpy as np
-from typing import List, Tuple
-
-class AudioConcatenationInfo:
-    @staticmethod
-    def get_concatenation_info(audio_chunks: List[Tuple[int, np.ndarray]], silence_duration: float) -> dict:
-        if not audio_chunks:
-            return {}
-        total_duration = 0
-        total_silence_duration = 0
-        chunk_durations = []
-        sample_rate = audio_chunks[0][0]
-        for _, audio_data in audio_chunks:
-            duration = len(audio_data) / sample_rate
-            chunk_durations.append(duration)
-            total_duration += duration
-        if len(audio_chunks) > 1:
-            total_silence_duration = (len(audio_chunks) - 1) * silence_duration
-            total_duration += total_silence_duration
-        return {
-            "num_chunks": len(audio_chunks),
-            "total_duration": total_duration,
-            "total_silence_duration": total_silence_duration,
-            "chunk_durations": chunk_durations,
-            "average_chunk_duration": np.mean(chunk_durations),
-            "sample_rate": sample_rate
-        }

src/processors/AudioConcatenator/progressive.py

@@ -1,58 +0,0 @@
-"""Progressive concatenation for AudioConcatenator."""
-
-import numpy as np
-from typing import Tuple, Optional
-import gradio as gr
-from .audio_utils import AudioUtils
-from .audio_filter import AudioFilter
-
-class AudioProgressiveConcatenator:
-    @staticmethod
-    def concatenate_progressive(
-        new_chunk: Tuple[int, np.ndarray],
-        existing_audio: Optional[Tuple[int, np.ndarray]] = None,
-        silence_duration: float = 0.5,
-        fade_duration: float = 0.1,
-        progress_callback: Optional[callable] = None
-    ) -> Tuple[int, np.ndarray]:
-        if progress_callback:
-            progress_callback(0.1, desc="Adding new audio chunk...")
-        if existing_audio is None:
-            sample_rate, audio_data = new_chunk
-            if audio_data.ndim == 1:
-                normalized_audio = audio_data
-            elif audio_data.ndim == 2:
-                normalized_audio = np.mean(audio_data, axis=1)
-            else:
-                raise gr.Error(f"Unsupported audio format: {audio_data.shape}")
-            normalized_audio = AudioUtils.normalize_audio(normalized_audio)
-            normalized_audio = AudioUtils.apply_fade_effects(normalized_audio, fade_duration, sample_rate)
-            if progress_callback:
-                progress_callback(1.0, desc="First chunk ready!")
-            return sample_rate, normalized_audio
-        existing_sample_rate, existing_audio_data = existing_audio
-        new_sample_rate, new_audio_data = new_chunk
-        if existing_sample_rate != new_sample_rate:
-            raise gr.Error(f"Sample rate mismatch: {existing_sample_rate} vs {new_sample_rate}")
-        if progress_callback:
-            progress_callback(0.3, desc="Processing new chunk...")
-        if new_audio_data.ndim == 1:
-            normalized_new = new_audio_data
-        elif new_audio_data.ndim == 2:
-            normalized_new = np.mean(new_audio_data, axis=1)
-        else:
-            raise gr.Error(f"Unsupported audio format: {new_audio_data.shape}")
-        normalized_new = AudioUtils.normalize_audio(normalized_new)
-        normalized_new = AudioUtils.apply_fade_effects(normalized_new, fade_duration, new_sample_rate)
-        if progress_callback:
-            progress_callback(0.6, desc="Creating silence segment...")
-        silence_samples = int(silence_duration * existing_sample_rate)
-        silence = np.zeros(silence_samples, dtype=np.float32)
-        if progress_callback:
-            progress_callback(0.8, desc="Concatenating audio...")
-        concatenated = np.concatenate([existing_audio_data, silence, normalized_new])
-        final_audio = AudioUtils.normalize_audio(concatenated)
-        final_audio = AudioFilter.remove_clicks_and_pops(final_audio)
-        if progress_callback:
-            progress_callback(1.0, desc="Progressive concatenation complete!")
-        return existing_sample_rate, final_audio

src/processors/audio_concatenator.py

@@ -1,6 +1,194 @@
 """Audio concatenation utility for combining multiple audio chunks into a single audio file."""
 
-# The AudioConcatenator class and related logic have been split into multiple files in the AudioConcatenator package.
-# See: AudioConcatenator/concatenator.py, audio_utils.py, audio_filter.py, info.py, progressive.py
+import numpy as np
+from typing import List, Tuple, Optional
+import gradio as gr
 
-from .AudioConcatenator import AudioConcatenator
+
+class AudioConcatenator:
+    """Handles concatenation of multiple audio chunks."""
+    
+    def __init__(self, silence_duration: float = 0.5, fade_duration: float = 0.1):
+        """
+        Initialize the audio concatenator.
+        
+        Args:
+            silence_duration: Duration of silence between chunks (seconds)
+            fade_duration: Duration of fade in/out effects (seconds)
+        """
+        self.silence_duration = silence_duration
+        self.fade_duration = fade_duration
+    
+    def concatenate_audio_chunks(
+        self, 
+        audio_chunks: List[Tuple[int, np.ndarray]], 
+        progress_callback: Optional[callable] = None
+    ) -> Tuple[int, np.ndarray]:
+        """
+        Concatenate multiple audio chunks into a single audio file.
+        
+        Args:
+            audio_chunks: List of (sample_rate, audio_data) tuples
+            progress_callback: Optional callback for progress updates
+            
+        Returns:
+            Tuple of (sample_rate, concatenated_audio_data)
+        """
+        if not audio_chunks:
+            raise gr.Error("No audio chunks to concatenate")
+        
+        if len(audio_chunks) == 1:
+            return audio_chunks[0]
+        
+        if progress_callback:
+            progress_callback(0.1, desc="Preparing audio concatenation...")
+        
+        # Verify all chunks have the same sample rate
+        sample_rates = [chunk[0] for chunk in audio_chunks]
+        if len(set(sample_rates)) > 1:
+            raise gr.Error(f"Inconsistent sample rates found: {set(sample_rates)}. All chunks must have the same sample rate.")
+        
+        sample_rate = sample_rates[0]
+        
+        if progress_callback:
+            progress_callback(0.2, desc="Normalizing audio chunks...")
+        
+        # Normalize and prepare audio data
+        normalized_chunks = []
+        for i, (_, audio_data) in enumerate(audio_chunks):
+            # Ensure audio data is in the correct format
+            if audio_data.ndim == 1:
+                normalized_audio = audio_data
+            elif audio_data.ndim == 2:
+                # Convert stereo to mono by averaging channels
+                normalized_audio = np.mean(audio_data, axis=1)
+            else:
+                raise gr.Error(f"Unsupported audio format in chunk {i + 1}: {audio_data.shape}")
+            
+            # Normalize audio levels
+            normalized_audio = self._normalize_audio(normalized_audio)
+            
+            # Apply fade effects
+            normalized_audio = self._apply_fade_effects(normalized_audio, sample_rate)
+            
+            normalized_chunks.append(normalized_audio)
+            
+            if progress_callback:
+                progress = 0.2 + (0.5 * (i + 1) / len(audio_chunks))
+                progress_callback(progress, desc=f"Processed chunk {i + 1}/{len(audio_chunks)}")
+        
+        if progress_callback:
+            progress_callback(0.7, desc="Creating silence segments...")
+        
+        # Create silence segments
+        silence_samples = int(self.silence_duration * sample_rate)
+        silence = np.zeros(silence_samples, dtype=np.float32)
+        
+        if progress_callback:
+            progress_callback(0.8, desc="Concatenating audio segments...")
+        
+        # Concatenate all chunks with silence in between
+        concatenated_segments = []
+        for i, chunk in enumerate(normalized_chunks):
+            concatenated_segments.append(chunk)
+            
+            # Add silence between chunks (but not after the last chunk)
+            if i < len(normalized_chunks) - 1:
+                concatenated_segments.append(silence)
+            
+            if progress_callback:
+                progress = 0.8 + (0.15 * (i + 1) / len(normalized_chunks))
+                progress_callback(progress, desc=f"Concatenated {i + 1}/{len(normalized_chunks)} chunks")
+        
+        # Combine all segments
+        final_audio = np.concatenate(concatenated_segments)
+        
+        if progress_callback:
+            progress_callback(0.95, desc="Finalizing audio...")
+        
+        # Final normalization and cleanup
+        final_audio = self._normalize_audio(final_audio)
+        final_audio = self._remove_clicks_and_pops(final_audio)
+        
+        if progress_callback:
+            progress_callback(1.0, desc="Audio concatenation complete!")
+        
+        return sample_rate, final_audio
+    
+    def _normalize_audio(self, audio_data: np.ndarray) -> np.ndarray:
+        """Normalize audio to prevent clipping."""
+        # Find the maximum absolute value
+        max_val = np.max(np.abs(audio_data))
+        
+        if max_val == 0:
+            return audio_data
+        
+        # Normalize to 95% of maximum to leave some headroom
+        normalized = audio_data * (0.95 / max_val)
+        
+        return normalized.astype(np.float32)
+    
+    def _apply_fade_effects(self, audio_data: np.ndarray, sample_rate: int) -> np.ndarray:
+        """Apply fade in and fade out effects to reduce pops and clicks."""
+        fade_samples = int(self.fade_duration * sample_rate)
+        
+        if len(audio_data) < 2 * fade_samples:
+            # If audio is too short for fade effects, return as-is
+            return audio_data
+        
+        audio_with_fades = audio_data.copy()
+          # Apply fade in
+        fade_in = np.linspace(0, 1, fade_samples)
+        audio_with_fades[:fade_samples] *= fade_in
+        
+        # Apply fade out
+        fade_out = np.linspace(1, 0, fade_samples)
+        audio_with_fades[-fade_samples:] *= fade_out
+        
+        return audio_with_fades
+    
+    def _remove_clicks_and_pops(self, audio_data: np.ndarray) -> np.ndarray:
+        """Apply basic filtering to remove clicks and pops."""
+        try:
+            # Simple high-pass filter to remove DC offset and low-frequency artifacts
+            from scipy import signal
+            
+            # Design a high-pass filter (removes frequencies below 80 Hz)
+            # This helps remove some pops and clicks while preserving speech
+            sos = signal.butter(2, 80, btype='highpass', fs=22050, output='sos')
+            filtered_audio = signal.sosfilt(sos, audio_data)
+            
+            return filtered_audio.astype(np.float32)
+        except ImportError:
+            # If scipy is not available, return audio as-is
+            return audio_data.astype(np.float32)
+    
+    def get_concatenation_info(self, audio_chunks: List[Tuple[int, np.ndarray]]) -> dict:
+        """Get information about the concatenation process."""
+        if not audio_chunks:
+            return {}
+        
+        total_duration = 0
+        total_silence_duration = 0
+        chunk_durations = []
+        
+        sample_rate = audio_chunks[0][0]
+        
+        for _, audio_data in audio_chunks:
+            duration = len(audio_data) / sample_rate
+            chunk_durations.append(duration)
+            total_duration += duration
+        
+        # Add silence duration (between chunks)
+        if len(audio_chunks) > 1:
+            total_silence_duration = (len(audio_chunks) - 1) * self.silence_duration
+            total_duration += total_silence_duration
+        
+        return {
+            "num_chunks": len(audio_chunks),
+            "total_duration": total_duration,
+            "total_silence_duration": total_silence_duration,
+            "chunk_durations": chunk_durations,
+            "average_chunk_duration": np.mean(chunk_durations),
+            "sample_rate": sample_rate
+        }

src/processors/parallel_processor.py

@@ -168,83 +168,3 @@ class ParallelAudioProcessor:
         estimated_time = sequential_time * parallel_efficiency
         
         return estimated_time
-    
-    def process_chunks_progressive(
-        self, 
-        text_chunks: List[str], 
-        audio_generator_func: Callable,
-        progress_callback: Optional[Callable] = None
-    ):
-        """
-        Process multiple text chunks in parallel and yield results in order as they become available.
-        
-        Args:
-            text_chunks: List of text chunks to process
-            audio_generator_func: Function to generate audio from text
-            progress_callback: Optional callback for progress updates
-            
-        Yields:
-            Tuples of (chunk_index, audio_result, is_complete, total_chunks)
-            where is_complete indicates if this is the final chunk
-        """
-        if not text_chunks:
-            return
-        
-        total_chunks = len(text_chunks)
-        completed_chunks = 0
-        results = [None] * total_chunks
-        completed_indices = set()
-        next_index_to_yield = 0
-        
-        def update_progress(chunk_index: int, desc: str = ""):
-            nonlocal completed_chunks
-            if progress_callback:
-                progress = completed_chunks / total_chunks
-                progress_callback(progress, desc=f"Processing chunk {completed_chunks + 1}/{total_chunks}{': ' + desc if desc else ''}")
-        
-        def process_single_chunk(chunk_index: int, text_chunk: str) -> Tuple[int, Tuple[int, np.ndarray]]:
-            """Process a single chunk and return the result with its index."""
-            try:
-                # Create a local progress callback for this chunk
-                def chunk_progress(progress: float, desc: str = ""):
-                    update_progress(chunk_index, f"Chunk {chunk_index + 1}: {desc}")
-                
-                # Generate audio for this chunk
-                audio_result = audio_generator_func(text_chunk, None, progress=chunk_progress)
-                return chunk_index, audio_result
-            except Exception as e:
-                raise Exception(f"Error processing chunk {chunk_index + 1}: {str(e)}")
-        
-        # Use ThreadPoolExecutor for parallel processing
-        with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
-            # Submit all chunks for processing
-            future_to_index = {
-                executor.submit(process_single_chunk, i, chunk): i 
-                for i, chunk in enumerate(text_chunks)
-            }
-            
-            # Collect results as they complete
-            for future in concurrent.futures.as_completed(future_to_index):
-                chunk_index = future_to_index[future]
-                try:
-                    index, audio_result = future.result()
-                    results[index] = audio_result
-                    completed_indices.add(index)
-                    completed_chunks += 1
-                    
-                    if progress_callback:
-                        progress = completed_chunks / total_chunks
-                        progress_callback(
-                            progress, 
-                            desc=f"Completed {completed_chunks}/{total_chunks} audio chunks"
-                        )
-                    
-                    # Yield any chunks that are now ready in order
-                    while next_index_to_yield < total_chunks and next_index_to_yield in completed_indices:
-                        chunk_result = results[next_index_to_yield]
-                        is_complete = (next_index_to_yield == total_chunks - 1)
-                        yield (next_index_to_yield, chunk_result, is_complete, total_chunks)
-                        next_index_to_yield += 1
-                        
-                except Exception as e:
-                    raise gr.Error(f"Failed to process chunk {chunk_index + 1}: {str(e)}")