feat: implement AudioConcatenator package with audio processing utilities

src/processors/AudioConcatenator/__init__.py

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

src/processors/AudioConcatenator/audio_filter.py

@@ -0,0 +1,14 @@
+"""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

@@ -0,0 +1,23 @@
+"""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

@@ -0,0 +1,87 @@
+"""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

@@ -0,0 +1,29 @@
+"""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

@@ -0,0 +1,58 @@
+"""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,194 +1,6 @@
 """Audio concatenation utility for combining multiple audio chunks into a single audio file."""
 
-import numpy as np
-from typing import List, Tuple, Optional
-import gradio as gr
+# 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
 
-
-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
-        }
+from .AudioConcatenator import AudioConcatenator

src/processors/parallel_processor.py

@@ -168,3 +168,83 @@ 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)}")