Update stablecuda12build1.py

i love math! its so much fun optimization CBR floats oh boy sure do love it yuppers

stablecuda12build1.py

@@ -1,3 +1,4 @@
+
 import os
 import torch
 import torchaudio
@@ -124,9 +125,22 @@ def check_disk_space(path="."):
         return False
 
 # Audio processing functions (CPU-based)
+def ensure_stereo(audio_segment, sample_rate=16000, sample_width=2):
+    """Ensure the audio segment is stereo (2 channels)."""
+    try:
+        if audio_segment.channels != 2:
+            logger.debug(f"Converting to stereo: {audio_segment.channels} channels detected")
+            audio_segment = audio_segment.set_channels(2)
+        return audio_segment
+    except Exception as e:
+        logger.error(f"Failed to ensure stereo: {e}")
+        logger.error(traceback.format_exc())
+        return audio_segment
+
 def balance_stereo(audio_segment, noise_threshold=-60, sample_rate=16000):
     logger.debug(f"Balancing stereo for segment with sample rate {sample_rate}")
     try:
+        audio_segment = ensure_stereo(audio_segment, sample_rate, audio_segment.sample_width)
         samples = np.array(audio_segment.get_array_of_samples(), dtype=np.float32)
         if audio_segment.channels == 2:
             stereo_samples = samples.reshape(-1, 2)
@@ -135,7 +149,7 @@ def balance_stereo(audio_segment, noise_threshold=-60, sample_rate=16000):
             stereo_samples = stereo_samples * mask
             left_nonzero = stereo_samples[:, 0][stereo_samples[:, 0] != 0]
             right_nonzero = stereo_samples[:, 1][stereo_samples[:, 1] != 0]
-            left_rms = np.sqrt(np.mean(left_nonzero**2)) if len(left_nonzero) > 0 else 0
+            left_rms = np.sqrt(np.mean(left_nonzero**2)) if len(left_nonzero) > 0 machts 0
             right_rms = np.sqrt(np.mean(right_nonzero**2)) if len(right_nonzero) > 0 else 0
             if left_rms > 0 and right_rms > 0:
                 avg_rms = (left_rms + right_rms) / 2
@@ -150,7 +164,7 @@ def balance_stereo(audio_segment, noise_threshold=-60, sample_rate=16000):
             )
             logger.debug("Stereo balancing completed")
             return balanced_segment
-        logger.debug("Segment is not stereo, returning unchanged")
+        logger.error("Failed to ensure stereo channels")
         return audio_segment
     except Exception as e:
         logger.error(f"Failed to balance stereo: {e}")
@@ -171,6 +185,7 @@ def calculate_rms(segment):
 def rms_normalize(segment, target_rms_db=-23.0, peak_limit_db=-3.0, sample_rate=16000):
     logger.debug(f"Normalizing RMS for segment with target {target_rms_db} dBFS")
     try:
+        segment = ensure_stereo(segment, sample_rate, segment.sample_width)
         target_rms = 10 ** (target_rms_db / 20) * (2**23 if segment.sample_width == 3 else 32767)
         current_rms = calculate_rms(segment)
         if current_rms > 0:
@@ -187,6 +202,7 @@ def rms_normalize(segment, target_rms_db=-23.0, peak_limit_db=-3.0, sample_rate=
 def hard_limit(audio_segment, limit_db=-3.0, sample_rate=16000):
     logger.debug(f"Applying hard limit at {limit_db} dBFS")
     try:
+        audio_segment = ensure_stereo(audio_segment, sample_rate, audio_segment.sample_width)
         limit = 10 ** (limit_db / 20.0) * (2**23 if audio_segment.sample_width == 3 else 32767)
         samples = np.array(audio_segment.get_array_of_samples(), dtype=np.float32)
         samples = np.clip(samples, -limit, limit).astype(np.int32 if audio_segment.sample_width == 3 else np.int16)
@@ -194,7 +210,7 @@ def hard_limit(audio_segment, limit_db=-3.0, sample_rate=16000):
             samples.tobytes(),
             frame_rate=sample_rate,
             sample_width=audio_segment.sample_width,
-            channels=audio_segment.channels
+            channels=2
         )
         logger.debug("Hard limit applied")
         return limited_segment
@@ -206,6 +222,7 @@ def hard_limit(audio_segment, limit_db=-3.0, sample_rate=16000):
 def apply_eq(segment, sample_rate=16000):
     logger.debug(f"Applying EQ with sample rate {sample_rate}")
     try:
+        segment = ensure_stereo(segment, sample_rate, segment.sample_width)
         segment = segment.high_pass_filter(20)
         segment = segment.low_pass_filter(20000)
         logger.debug("EQ applied")
@@ -218,6 +235,7 @@ def apply_eq(segment, sample_rate=16000):
 def apply_fade(segment, fade_in_duration=500, fade_out_duration=500):
     logger.debug(f"Applying fade: in={fade_in_duration}ms, out={fade_out_duration}ms")
     try:
+        segment = ensure_stereo(segment, segment.frame_rate, segment.sample_width)
         segment = segment.fade_in(fade_in_duration)
         segment = segment.fade_out(fade_out_duration)
         logger.debug("Fade applied")
@@ -535,6 +553,7 @@ def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p
         max_duration = min(max_steps_int / 50, 30)  # Convert steps to seconds, cap at 30s
         total_duration = min(max(total_duration, 30), 120)  # Clamp between 30s and 120s
         processing_sample_rate = 16000  # Fixed for processing
+        channels = 2  # Enforce stereo
         audio_segments = []
         overlap_duration = 0.2  # 200ms for continuation and crossfade
         remaining_duration = total_duration
@@ -598,6 +617,9 @@ def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p
                             if prev_sr != processing_sample_rate:
                                 logger.debug(f"Resampling from {prev_sr} to {processing_sample_rate}")
                                 prev_audio = torchaudio.transforms.Resample(prev_sr, processing_sample_rate)(prev_audio)
+                            if prev_audio.shape[0] != 2:
+                                logger.debug(f"Converting to stereo: {prev_audio.shape[0]} channels detected")
+                                prev_audio = prev_audio.repeat(2, 1)[:, :prev_audio.shape[1]]
                             prev_audio = prev_audio.to(device)
                             os.remove(temp_wav_path)
                             logger.debug(f"Deleted temporary file {temp_wav_path}")
@@ -622,7 +644,7 @@ def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p
                     logger.debug("Converting mono to stereo on CPU")
                     audio_np = np.stack([audio_np, audio_np], axis=0)
                 elif audio_np.ndim == 2 and audio_np.shape[0] != 2:
-                    logger.debug("Adjusting to stereo on CPU")
+                    logger.debug(f"Adjusting to stereo on CPU: {audio_np.shape[0]} channels detected")
                     audio_np = np.concatenate([audio_np, audio_np], axis=0)[:2]
                 if audio_np.shape[0] != 2:
                     logger.error(f"Expected stereo audio with shape (2, samples), got shape {audio_np.shape}")
@@ -666,6 +688,7 @@ def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p
                 continue
 
             try:
+                segment = ensure_stereo(segment, processing_sample_rate, sample_width)
                 segment = segment - 15
                 if segment.frame_rate != processing_sample_rate:
                     logger.debug(f"Setting segment sample rate to {processing_sample_rate}")
@@ -696,26 +719,48 @@ def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p
         logger.info("Combining audio chunks...")
         try:
             final_segment = audio_segments[0][:min(max_duration, total_duration) * 1000]
+            final_segment = ensure_stereo(final_segment, processing_sample_rate, sample_width)
             overlap_ms = int(overlap_duration * 1000)
 
             for i in range(1, len(audio_segments)):
                 current_segment = audio_segments[i]
                 current_segment = current_segment[:min(max_duration, total_duration - (i * max_duration)) * 1000]
+                current_segment = ensure_stereo(current_segment, processing_sample_rate, sample_width)
 
                 if overlap_ms > 0 and len(current_segment) > overlap_ms:
                     logger.debug(f"Applying crossfade between chunks {i} and {i+1}")
                     prev_overlap = final_segment[-overlap_ms:]
                     curr_overlap = current_segment[:overlap_ms]
-                    num_samples = len(np.array(prev_overlap.get_array_of_samples(), dtype=np.float32)) // 2
+                    # Ensure stereo and consistent sample length
+                    prev_overlap = ensure_stereo(prev_overlap, processing_sample_rate, sample_width)
+                    curr_overlap = ensure_stereo(curr_overlap, processing_sample_rate, sample_width)
+                    # Calculate samples using torchaudio for precision
+                    prev_audio, _ = torchaudio.load(io.BytesIO(prev_overlap.raw_data))
+                    curr_audio, _ = torchaudio.load(io.BytesIO(curr_overlap.raw_data))
+                    num_samples = min(prev_audio.shape[1], curr_audio.shape[1])
+                    # Ensure num_samples is even for stereo
+                    num_samples = num_samples - (num_samples % 2)
+                    if num_samples <= 0:
+                        logger.warning(f"Skipping crossfade for chunk {i+1} due to insufficient samples")
+                        final_segment += current_segment
+                        continue
                     blended_samples = np.zeros((num_samples, 2), dtype=np.float32)
-                    prev_samples = np.array(prev_overlap.get_array_of_samples(), dtype=np.float32).reshape(-1, 2)
-                    curr_samples = np.array(curr_overlap.get_array_of_samples(), dtype=np.float32).reshape(-1, 2)
+                    prev_samples = prev_audio[:, :num_samples].numpy().T
+                    curr_samples = curr_audio[:, :num_samples].numpy().T
                     hann_window = 0.5 * (1 - np.cos(2 * np.pi * np.arange(num_samples) / num_samples))
                     fade_out = hann_window[::-1]
                     fade_in = hann_window
                     blended_samples = (prev_samples * fade_out[:, None] + curr_samples * fade_in[:, None])
+                    # Ensure byte length is multiple of sample_width * channels
+                    blended_samples = blended_samples.astype(np.int32 if sample_width == 3 else np.int16)
+                    byte_data = blended_samples.tobytes()
+                    byte_length = len(byte_data)
+                    expected_length = byte_length - (byte_length % (sample_width * channels))
+                    if byte_length != expected_length:
+                        logger.debug(f"Truncating blended samples from {byte_length} to {expected_length} bytes")
+                        byte_data = byte_data[:expected_length]
                     blended_segment = AudioSegment(
-                        blended_samples.astype(np.int32 if sample_width == 3 else np.int16).tobytes(),
+                        byte_data,
                         frame_rate=processing_sample_rate,
                         sample_width=sample_width,
                         channels=2
@@ -739,6 +784,7 @@ def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p
             logger.info("⚠️ WARNING: Audio is set to safe levels (~ -23 dBFS RMS, -3 dBFS peak). Start playback at LOW volume (10-20%) and adjust gradually.")
             logger.info("VERIFY: Open the file in Audacity to check for static. RMS should be ~ -23 dBFS, peaks ≤ -3 dBFS. Report any static or issues.")
             try:
+                clean_memory()  # Pre-export cleanup
                 logger.debug(f"Exporting final audio to {mp3_path} with bitrate {bitrate}, sample rate {output_sample_rate_int} Hz, bit depth {bit_depth_int}-bit")
                 final_segment.export(
                     mp3_path,