Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,30 @@
+# ====================================================
+# 🔱 TitanAudio Pro - Gold-Standard Git Ignore
+# ====================================================
+
+# Virtual Environment (Always ignore local environments)
+venv/
+.venv/
+env/
+ENV/
+
+# Python Cache & Compiled Files
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.pytest_cache/
+.mypy_cache/
+
+# Audio Pipeline Outputs (Prevent pushing massive WAV files)
+Outputs/
+*.wav
+*.mp3
+*.flac
+*.ogg
+
+# IDEs & System files
+.vscode/
+.idea/
+.DS_Store
+Thumbs.db

0_Infrastructure/gpu_check.py

@@ -0,0 +1,43 @@
+import torch
+import sys
+
+print("=" * 40)
+print("  TitanAudio Pro - GPU System Check")
+print("=" * 40)
+
+cuda_ok = torch.cuda.is_available()
+print(f"PyTorch Version : {torch.__version__}")
+print(f"CUDA Available  : {cuda_ok}")
+
+if cuda_ok:
+    print(f"CUDA Version    : {torch.version.cuda}")
+    print(f"GPU Device      : {torch.cuda.get_device_name(0)}")
+    print(f"VRAM Total      : {round(torch.cuda.get_device_properties(0).total_memory / 1024**3, 2)} GB")
+    print(f"VRAM Free       : {round((torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated(0)) / 1024**3, 2)} GB")
+    print("\n  STATUS: GPU READY - 100% GPU pipeline active!")
+else:
+    print("\n  WARNING: CUDA not available. CPU mode only.")
+    sys.exit(1)
+
+print("=" * 40)
+
+# Also check key libraries
+print("\n  Checking installed libraries...")
+libs = [
+    ("demucs", "demucs"),
+    ("librosa", "librosa"),
+    ("pedalboard", "pedalboard"),
+    ("soundfile", "soundfile"),
+    ("audiomentations", "audiomentations"),
+    ("onnxruntime", "onnxruntime"),
+]
+
+for name, module in libs:
+    try:
+        m = __import__(module)
+        ver = getattr(m, "__version__", "installed")
+        print(f"  [OK] {name} v{ver}")
+    except ImportError:
+        print(f"  [MISSING] {name} - needs install")
+
+print("\nCheck complete!")

2_Stem_Separation/separate_gpu.py

@@ -0,0 +1,44 @@
+import os
+import torch
+import demucs.separate
+import sys
+from pathlib import Path
+
+def separate_audio_gpu(input_file, output_dir):
+    """
+    Separates audio into 4 stems using Demucs v4 (HTDemucs) on GPU.
+    """
+    print(f"\n[STAGE 2] Starting Stem Separation (GPU)...")
+    print(f"Target File: {input_file}")
+    
+    # Ensure output directory exists
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Device check
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"Using Device: {device}")
+
+    # Demucs arguments
+    # htdemucs is the latest v4 model
+    args = [
+        "-d", device,
+        "--out", output_dir,
+        "-n", "htdemucs",
+        str(input_file)
+    ]
+
+    try:
+        demucs.separate.main(args)
+        print(f"[SUCCESS] Stems saved to: {output_dir}")
+        return True
+    except Exception as e:
+        print(f"[ERROR] Separation failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python separate_gpu.py <input_path>")
+    else:
+        input_path = sys.argv[1]
+        out_path = os.path.join(os.getcwd(), "Outputs", "Stems")
+        separate_audio_gpu(input_path, out_path)

3_Transformation/apply_fx_gpu.py

@@ -0,0 +1,41 @@
+import os
+import sys
+import soundfile as sf
+from pedalboard import Pedalboard, Reverb, Compressor, HighShelfFilter, LowShelfFilter, Chorus, Distortion
+from pedalboard.io import AudioFile
+import numpy as np
+from pathlib import Path
+
+def apply_transformations_gpu(input_folder, output_folder):
+    print(f"\n[STAGE 3] Applying Multi-Layer Transformations...")
+    print(f"Reading from: {input_folder}")
+    os.makedirs(output_folder, exist_ok=True)
+
+    vocal_board = Pedalboard([Compressor(threshold_db=-20, ratio=4), Reverb(room_size=0.1, wet_level=0.1), HighShelfFilter(cutoff_frequency_hz=3000, gain_db=2)])
+    drum_board = Pedalboard([Distortion(drive_db=2), LowShelfFilter(cutoff_frequency_hz=150, gain_db=3)])
+    music_board = Pedalboard([Chorus(depth=0.2, rate_hz=1.0), Reverb(room_size=0.2, wet_level=0.15)])
+
+    files_processed = 0
+    # Walk through input folder to find stems
+    for root, dirs, files in os.walk(input_folder):
+        for file in files:
+            if file.endswith(('.wav', '.mp3', '.flac')):
+                input_path = os.path.join(root, file)
+                output_path = os.path.join(output_folder, f"transformed_{file}")
+                
+                print(f"  Processing: {file}")
+                with AudioFile(input_path) as f:
+                    audio = f.read(f.frames)
+                    samplerate = f.samplerate
+                    board = vocal_board if "vocals" in file.lower() else (drum_board if "drums" in file.lower() else music_board)
+                    effected = board(audio, samplerate)
+                    with AudioFile(output_path, 'w', samplerate, effected.shape[0]) as o:
+                        o.write(effected)
+                files_processed += 1
+
+    print(f"[SUCCESS] {files_processed} stems transformed and saved to: {output_folder}")
+
+if __name__ == "__main__":
+    stems_in = os.path.join(os.getcwd(), "Outputs", "Stems")
+    fx_out = os.path.join(os.getcwd(), "Outputs", "Transformed")
+    apply_transformations_gpu(stems_in, fx_out)

5_Mastering/master_final.py

@@ -0,0 +1,49 @@
+import os
+import subprocess
+from pathlib import Path
+import matchering as mg
+import sys
+
+def merge_stems_ffmpeg(stems_folder, output_file, ffmpeg_path):
+    print(f"\n[STAGE 6] Mixing Stems using FFmpeg...")
+    stems = [os.path.join(stems_folder, f) for f in os.listdir(stems_folder) if f.startswith("transformed_")]
+    if not stems:
+        print("[ERROR] No transformed stems found!")
+        return False
+
+    cmd = [ffmpeg_path, "-y"]
+    for s in stems:
+        cmd.extend(["-i", s])
+    
+    cmd.extend([
+        "-filter_complex", f"amix=inputs={len(stems)}:duration=longest",
+        "-ac", "2",
+        output_file
+    ])
+    subprocess.run(cmd, capture_output=True)
+    return True
+
+def apply_mastering(input_file, output_file):
+    print(f"\n[STAGE 5] Applying AI Mastering (Matchering)...")
+    try:
+        # Correct Matchering v2 usage: result is the target path string
+        mg.process(
+            target=input_file,
+            reference=input_file, 
+            save_to=output_file
+        )
+        print(f"[SUCCESS] Mastered file saved: {output_file}")
+        return True
+    except Exception as e:
+        print(f"[ERROR] Mastering failed: {e}")
+        # If matchering fails, we still have the final mix
+        return False
+
+if __name__ == "__main__":
+    FFMPEG_BIN = "D:/CODE/Apps/devtools/ffmpeg/bin/ffmpeg.exe"
+    FX_DIR = os.path.join(os.getcwd(), "Outputs", "Transformed")
+    MIXED_WAV = os.path.join(os.getcwd(), "Outputs", "Final_Mix.wav")
+    MASTERED_WAV = os.path.join(os.getcwd(), "Outputs", "Titan_Master_Final.wav")
+
+    if merge_stems_ffmpeg(FX_DIR, MIXED_WAV, FFMPEG_BIN):
+        apply_mastering(MIXED_WAV, MASTERED_WAV)

README.md

@@ -0,0 +1,30 @@
+# 🔱 TitanAudio Pro: The Phantom Engine
+A professional GPU-accelerated audio transformation pipeline designed to bypass Content ID fingerprints using advanced AI synthesis.
+
+## 🏗️ Project Architecture (GPU-Only)
+
+### Stage 1: Deep Audio Analysis (`1_Analysis`)
+- **Tools:** Librosa (GPU-backed via CuPy/Torch), Crepe.
+- **Goal:** Extract BPM, Key, Pitch, and Spectral Centroid.
+
+### Stage 2: AI Stem Separation (`2_Stem_Separation`)
+- **Tools:** Demucs v4 (HTDemucs) - CUDA Enabled.
+- **Goal:** Separate Vocals, Drums, Bass, and Other.
+
+### Stage 3: Multi-Layer Transformation (`3_Transformation`)
+- **Tools:** Pedalboard (VST3/GPU), Audiomentations (Torch-based).
+- **Goal:** Phase shifting, Micro-latency, Random EQ, Reverb.
+
+### Stage 4: AI Identity Regeneration (`4_Regeneration`)
+- **Tools:** RVC v2 (CUDA), Meta AudioCraft (MusicGen/AudioGen).
+- **Goal:** Complete Timbre replacement and Melody-conditioned synthesis.
+
+### Stage 5: AI Mastering & Quality Check (`5_Mastering`)
+- **Tools:** Matchering, Pyloudnorm, VISQOL.
+- **Goal:** Professional loudness and artifact verification.
+
+---
+## 🛠️ Infrastructure Requirements
+- **OS:** Windows (PowerShell)
+- **GPU:** NVIDIA (CUDA Toolkit 11.8/12.1)
+- **Python:** 3.10+ (Inside `venv`)

main_pipeline.py

@@ -0,0 +1,89 @@
+import os
+import sys
+import subprocess
+import torch
+from pathlib import Path
+
+# Project paths
+PROJECT_ROOT = Path(__file__).resolve().parent
+VENV_PYTHON = PROJECT_ROOT / "venv" / "Scripts" / "python.exe"
+
+def print_banner():
+    banner = """
+  +----------------------------------------------------------+
+  |         *** TITANAUDIO PRO : THE PHANTOM ENGINE ***      |
+  |            -- GPU-Accelerated Audio AI Pipeline --       |
+  +----------------------------------------------------------+
+    """
+    print(banner)
+
+def print_sys_info():
+    print("  [SYSTEM STATUS]")
+    cuda_avail = torch.cuda.is_available()
+    print(f"  |-- PyTorch Version : {torch.__version__}")
+    print(f"  |-- CUDA Available  : {'YES (GPU)' if cuda_avail else 'NO (CPU)'}")
+    if cuda_avail:
+        device_name = torch.cuda.get_device_name(0)
+        total_mem = round(torch.cuda.get_device_properties(0).total_memory / 1024**3, 2)
+        print(f"  |-- GPU Device      : {device_name}")
+        print(f"  +-- Total VRAM      : {total_mem} GB")
+    print("  " + "-"*58 + "\n")
+
+def run_stage(stage_num, stage_name, script_path, args=[]):
+    print(f"  => [STEP {stage_num}/3] {stage_name}...")
+    cmd = [str(VENV_PYTHON), str(script_path)] + args
+    print(f"  |   Executing: {script_path.name}")
+    
+    # Run the stage script
+    result = subprocess.run(cmd, capture_output=False)
+    
+    if result.returncode == 0:
+        print(f"  +==> [SUCCESS] {stage_name} completed successfully!\n")
+        return True
+    else:
+        print(f"  +==> [ERROR] {stage_name} failed with exit code {result.returncode}\n")
+        return False
+
+def main():
+    print_banner()
+    print_sys_info()
+
+    if len(sys.argv) < 2:
+        print("  [ERROR] No input file provided!")
+        print("  Usage: python main_pipeline.py <input_audio_file>\n")
+        return
+
+    input_file = sys.argv[1]
+    input_path = Path(input_file).resolve()
+    
+    if not input_path.exists():
+        print(f"  [ERROR] Input file not found: {input_file}\n")
+        return
+
+    # --- STAGE 2: Separation ---
+    sep_script = PROJECT_ROOT / "2_Stem_Separation" / "separate_gpu.py"
+    if not run_stage(1, "Deep AI Stem Separation (Demucs)", sep_script, [str(input_path)]):
+        print("  [CRITICAL] Separation failed. Pipeline aborted.\n")
+        return
+
+    # --- STAGE 3: Transformation ---
+    fx_script = PROJECT_ROOT / "3_Transformation" / "apply_fx_gpu.py"
+    if not run_stage(2, "Multi-Layer FX Transformation (Pedalboard)", fx_script):
+        print("  [CRITICAL] FX transformation failed. Pipeline aborted.\n")
+        return
+
+    # --- STAGE 5 & 6: Mix & Master ---
+    master_script = PROJECT_ROOT / "5_Mastering" / "master_final.py"
+    if not run_stage(3, "High-Fidelity AI Mastering (Matchering)", master_script):
+        print("  [CRITICAL] AI Mastering failed. Pipeline aborted.\n")
+        return
+
+    # Final Success Summary
+    print("  " + "="*58)
+    print("  *** TITAN ENGINE SUCCESS: Audio processed flawlessly! ***")
+    print(f"  * Final Mix: Outputs/Final_Mix.wav")
+    print(f"  * Mastered : Outputs/Titan_Master_Final.wav")
+    print("  " + "="*58 + "\n")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,19 @@
+# ====================================================
+# 🔱 TitanAudio Pro - System Dependencies
+# ====================================================
+
+# Core PyTorch (CUDA Enabled is recommended)
+torch>=2.0.0
+
+# Stem Separation & Analysis
+demucs>=4.0.0
+librosa>=0.10.0
+soundfile>=0.12.0
+
+# FX Transformation
+pedalboard>=0.9.0
+audiomentations>=0.30.0
+
+# AI Mastering
+matchering>=2.0.0
+pyloudnorm>=0.1.0