Fix: Add debug logging and robust padding to audio processing

app/audio.py

@@ -21,27 +21,49 @@ def process_audio(input_data) -> torch.Tensor:
             # Check if it's a file path
             try:
                 if os.path.isfile(input_data):
+                    print(f"DEBUG: Loading audio from file: {input_data}")
                     audio_segment = AudioSegment.from_file(input_data)
                 else:
                     raise FileNotFoundError
             except:
                 # Assume Base64 string if file load fails
-                # 1. Clean up "data:audio/mp3;base64," prefix if present
+                print("DEBUG: Processing input as Base64 string...")
+                
+                # 1. Clean up headers and whitespace
                 clean_b64 = input_data
                 if "," in clean_b64:
                     clean_b64 = clean_b64.split(",", 1)[1]
-                
-                # 2. Remove whitespace/newlines which break some decoders
                 clean_b64 = clean_b64.strip().replace("\n", "").replace(" ", "")
                 
-                decoded_bytes = base64.b64decode(clean_b64)
-                audio_segment = AudioSegment.from_file(io.BytesIO(decoded_bytes))
+                # 2. Fix Padding
+                missing_padding = len(clean_b64) % 4
+                if missing_padding:
+                    clean_b64 += '=' * (4 - missing_padding)
+                
+                print(f"DEBUG: Base64 string length: {len(clean_b64)}")
+                
+                try:
+                    decoded_bytes = base64.b64decode(clean_b64)
+                    print(f"DEBUG: Decoded bytes length: {len(decoded_bytes)}")
+                    print(f"DEBUG: First 16 bytes: {decoded_bytes[:16].hex()}")
+                    
+                    # 3. Explicitly try MP3 first, then let pydub probe
+                    try:
+                        audio_segment = AudioSegment.from_file(io.BytesIO(decoded_bytes), format="mp3")
+                    except Exception as mp3_err:
+                        print(f"DEBUG: Explicit MP3 load failed ({mp3_err}), trying auto-detection...")
+                        audio_segment = AudioSegment.from_file(io.BytesIO(decoded_bytes))
+                        
+                except Exception as b64_err:
+                    print(f"ERROR: Base64 decode failed: {b64_err}")
+                    raise ValueError(f"Invalid Base64 string: {b64_err}")
         elif isinstance(input_data, bytes):
             audio_segment = AudioSegment.from_file(io.BytesIO(input_data))
         else:
             raise ValueError("Unsupported input type. Expected: str (path/base64) or bytes.")
             
     except Exception as e:
+        print(f"CRITICAL ERROR in process_audio: {e}")
         raise ValueError(f"Failed to load audio: {e}")
 
     # 2. Resample to 16kHz

reproduce_error.py

@@ -0,0 +1,44 @@
+import torch
+from app.audio import process_audio
+from pydub import AudioSegment
+import numpy as np
+import io
+import base64
+
+def generate_mp3_base64():
+    """Generates a valid 1-second MP3 sine wave and returns base64 string."""
+    sr = 44100
+    t = np.linspace(0, 1, sr, endpoint=False)
+    x = 0.5 * np.sin(2 * np.pi * 440 * t)
+    x_int = (x * 32767).astype(np.int16)
+    audio = AudioSegment(
+        x_int.tobytes(), 
+        frame_rate=sr,
+        sample_width=2, 
+        channels=1
+    )
+    mp3_io = io.BytesIO()
+    audio.export(mp3_io, format="mp3")
+    return base64.b64encode(mp3_io.getvalue()).decode('utf-8')
+
+def test_reproduce():
+    print("--- 🔍 Testing Valid Audio Processing ---")
+    
+    # 1. Generate Valid MP3
+    valid_b64 = generate_mp3_base64()
+    print(f"Generated Valid B64 Length: {len(valid_b64)}")
+    
+    try:
+        # 2. Test Processing
+        waveform = process_audio(valid_b64)
+        print("\n✅ Success with Valid MP3!")
+        print(f"Waveform shape: {waveform.shape}")
+        
+    except Exception as e:
+        print("\n❌ Failed with Valid MP3!")
+        print(e)
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    test_reproduce()