audio_processing/effect_chain.py

"""
Effect Chain - Pedalboard 기반 오디오 이펙트 처리
=================================================
V6: Compressor threshold 범위 수정 (0 ~ -5dB)
"""

import numpy as np
import soundfile as sf
from typing import Dict
from pedalboard import (
    Pedalboard, 
    Compressor, 
    Gain,
    HighShelfFilter,
    LowShelfFilter,
    PeakFilter,
    Delay,
    Reverb,
    Limiter
)


class EffectChain:
    def __init__(self, sample_rate: int = 44100):
        self.sample_rate = sample_rate
    
    def _get_param(self, params: Dict[str, float], *keys, default=0.0) -> float:
        for key in keys:
            if key in params:
                return params[key]
        return default
    
    def _build_pedalboard(self, params: Dict[str, float]) -> Pedalboard:
        effects = []
        
        # Compressor (V6: 0 ~ -5dB 범위)
        comp_threshold = self._get_param(params, "compressor.threshold", default=-3.0)
        comp_ratio = self._get_param(params, "compressor.ratio", default=2.0)
        effects.append(Compressor(
            threshold_db=max(-5.0, min(0.0, comp_threshold)),  # V6: 0 ~ -5dB
            ratio=max(1.5, min(4.0, comp_ratio)),
            attack_ms=10.0,
            release_ms=100.0
        ))
        
        # EQ Peak 1
        freq1 = self._get_param(params, "eq_peak1.params.freq", default=1000.0)
        gain1 = self._get_param(params, "eq_peak1.params.gain", default=0.0)
        q1 = self._get_param(params, "eq_peak1.params.Q", "eq_peak1.params.q", default=1.0)
        if abs(gain1) > 0.1:
            effects.append(PeakFilter(
                cutoff_frequency_hz=max(20, min(20000, freq1)),
                gain_db=max(-12, min(12, gain1)),
                q=max(0.1, min(10, q1))
            ))
        
        # EQ Peak 2
        freq2 = self._get_param(params, "eq_peak2.params.freq", default=4000.0)
        gain2 = self._get_param(params, "eq_peak2.params.gain", default=0.0)
        q2 = self._get_param(params, "eq_peak2.params.Q", "eq_peak2.params.q", default=1.0)
        if abs(gain2) > 0.1:
            effects.append(PeakFilter(
                cutoff_frequency_hz=max(20, min(20000, freq2)),
                gain_db=max(-12, min(12, gain2)),
                q=max(0.1, min(10, q2))
            ))
        
        # Low Shelf
        freq_low = self._get_param(params, "eq_lowshelf.params.freq", default=200.0)
        gain_low = self._get_param(params, "eq_lowshelf.params.gain", default=0.0)
        if abs(gain_low) > 0.1:
            effects.append(LowShelfFilter(
                cutoff_frequency_hz=max(20, min(2000, freq_low)),
                gain_db=max(-12, min(12, gain_low)),
                q=0.707
            ))
        
        # High Shelf
        freq_high = self._get_param(params, "eq_highshelf.params.freq", default=8000.0)
        gain_high = self._get_param(params, "eq_highshelf.params.gain", default=0.0)
        if abs(gain_high) > 0.1:
            effects.append(HighShelfFilter(
                cutoff_frequency_hz=max(1000, min(20000, freq_high)),
                gain_db=max(-12, min(12, gain_high)),
                q=0.707
            ))
        
        # Delay
        delay_time = self._get_param(params, "delay.delay_time", default=0.02)
        delay_feedback = self._get_param(params, "delay.feedback", default=0.15)
        delay_mix = self._get_param(params, "delay.mix", default=0.1)
        if delay_mix > 0.01:
            effects.append(Delay(
                delay_seconds=max(0.01, min(0.3, delay_time)),
                feedback=max(0.0, min(0.25, delay_feedback)),
                mix=max(0.0, min(0.2, delay_mix))
            ))
        
        # Reverb
        room_size = self._get_param(params, "reverb.room_size", default=0.3)
        reverb_wet = self._get_param(params, "reverb.wet_level", default=0.0)
        reverb_dry = self._get_param(params, "reverb.dry_level", default=1.0)
        reverb_damping = self._get_param(params, "reverb.damping", default=0.5)
        if reverb_wet > 0.01:
            effects.append(Reverb(
                room_size=max(0.0, min(0.6, room_size)),
                damping=max(0.0, min(1.0, reverb_damping)),
                wet_level=max(0.0, min(0.3, reverb_wet)),
                dry_level=max(0.7, min(1.0, reverb_dry))
            ))
        
        # Limiter
        effects.append(Limiter(threshold_db=-6.0))
        
        return Pedalboard(effects)
    
    def process(self, input_path: str, output_path: str, parameters: Dict[str, float]) -> bool:
        try:
            audio, sr = sf.read(input_path)
            
            if len(audio.shape) == 1:
                audio = audio.reshape(-1, 1)
            
            audio = audio.astype(np.float32)
            
            # 입력 정규화
            input_peak = np.max(np.abs(audio))
            if input_peak > 0.5:
                audio = audio * (0.5 / input_peak)
                print(f"[EffectChain] 입력 정규화: peak {input_peak:.3f} → 0.5")
            
            board = self._build_pedalboard(parameters)
            processed = board(audio, sr)
            
            # Wet/Dry 믹스
            wet_mix = self._get_param(parameters, "final_wet_mix", default=0.5)
            wet_mix = max(0.3, min(0.7, wet_mix))
            
            min_len = min(len(audio), len(processed))
            output = audio[:min_len] * (1 - wet_mix) + processed[:min_len] * wet_mix
            
            # 출력 정규화
            output_peak = np.max(np.abs(output))
            if output_peak > 0.9:
                output = output * (0.9 / output_peak)
                print(f"[EffectChain] 출력 정규화: peak {output_peak:.3f} → 0.9")
            
            output = np.clip(output, -1.0, 1.0)
            sf.write(output_path, output, sr)
            
            print(f"[EffectChain] ✅ 처리 완료: {output_path}")
            print(f"[EffectChain] 적용된 파라미터:")
            print(f"  - Compressor: threshold={self._get_param(parameters, 'compressor.threshold', default=-3.0):.1f}dB, ratio={self._get_param(parameters, 'compressor.ratio', default=2.0):.1f}")
            print(f"  - EQ Peak1 Gain: {self._get_param(parameters, 'eq_peak1.params.gain'):.2f} dB")
            print(f"  - EQ Peak2 Gain: {self._get_param(parameters, 'eq_peak2.params.gain'):.2f} dB")
            print(f"  - Low Shelf Gain: {self._get_param(parameters, 'eq_lowshelf.params.gain'):.2f} dB")
            print(f"  - High Shelf Gain: {self._get_param(parameters, 'eq_highshelf.params.gain'):.2f} dB")
            print(f"  - Distortion: DISABLED")
            print(f"  - Delay: time={self._get_param(parameters, 'delay.delay_time', default=0.02):.3f}s, fb={self._get_param(parameters, 'delay.feedback', default=0.15):.2f}, mix={self._get_param(parameters, 'delay.mix', default=0.1):.2f}")
            print(f"  - Reverb: room={self._get_param(parameters, 'reverb.room_size', default=0.3):.2f}, wet={self._get_param(parameters, 'reverb.wet_level', default=0.0):.2f}")
            print(f"  - Wet Mix: {wet_mix:.2f}")
            
            return True
            
        except Exception as e:
            print(f"[EffectChain] ❌ 처리 실패: {e}")
            import traceback
            traceback.print_exc()
            raise e