1039 lines
34 KiB
Python
1039 lines
34 KiB
Python
"""
|
|
混响效果处理器
|
|
实现专业的音频混响效果处理
|
|
"""
|
|
|
|
import uuid
|
|
import math
|
|
import numpy as np
|
|
from typing import Dict, List, Any, Optional
|
|
from scipy import signal
|
|
|
|
class ReverbProcessor:
|
|
"""
|
|
混响效果处理器
|
|
实现专业的音频混响效果处理
|
|
"""
|
|
|
|
def __init__(self, plugin):
|
|
"""
|
|
初始化混响效果处理器
|
|
|
|
Args:
|
|
plugin: 音频效果插件实例
|
|
"""
|
|
self.plugin = plugin
|
|
self.effects: Dict[str, Dict[str, Any]] = {}
|
|
self.comb_filters = {} # 梳状滤波器
|
|
self.allpass_filters = {} # 全通滤波器
|
|
self.stats = {
|
|
'total_effects': 0,
|
|
'active_effects': 0,
|
|
'effects_processed': 0,
|
|
'processing_time': 0.0,
|
|
'memory_usage': 0
|
|
}
|
|
self.buffer_size = plugin.buffer_size if plugin else 4096
|
|
self.sample_rate = 44100 # 默认采样率
|
|
|
|
# 初始化混响参数
|
|
self._initialize_reverb_parameters()
|
|
|
|
def _initialize_reverb_parameters(self):
|
|
"""初始化混响参数"""
|
|
# 梳状滤波器延迟时间（毫秒）
|
|
self.comb_delays = [1116, 1188, 1277, 1356, 1422, 1491, 1557, 1617]
|
|
|
|
# 全通滤波器延迟时间（毫秒）
|
|
self.allpass_delays = [556, 441, 341, 225]
|
|
|
|
# 混响衰减系数
|
|
self.comb_decay_factors = [0.8, 0.75, 0.7, 0.65, 0.6, 0.55, 0.5, 0.45]
|
|
|
|
# 全通滤波器系数
|
|
self.allpass_feedback = 0.7
|
|
|
|
def create_effect(self, parameters: Dict[str, Any]) -> str:
|
|
"""
|
|
创建混响效果
|
|
|
|
Args:
|
|
parameters: 混响参数
|
|
|
|
Returns:
|
|
效果ID
|
|
"""
|
|
try:
|
|
# 生成唯一ID
|
|
effect_id = str(uuid.uuid4())
|
|
|
|
# 默认参数
|
|
default_params = {
|
|
'room_size': 0.5, # 房间大小 (0.0-1.0)
|
|
'damping': 0.5, # 阻尼 (0.0-1.0)
|
|
'wet_level': 0.33, # 湿信号电平 (0.0-1.0)
|
|
'dry_level': 0.4, # 干信号电平 (0.0-1.0)
|
|
'width': 1.0, # 宽度 (0.0-1.0)
|
|
'freeze_mode': 0.0, # 冻结模式 (0.0-1.0)
|
|
'early_reflections': 0.5, # 早期反射 (0.0-1.0)
|
|
'late_reverb': 0.5, # 晚期混响 (0.0-1.0)
|
|
'diffusion': 0.7, # 扩散 (0.0-1.0)
|
|
'density': 0.5, # 密度 (0.0-1.0)
|
|
'predelay': 0.0, # 预延迟 (秒)
|
|
'high_freq_damping': 0.5, # 高频阻尼 (0.0-1.0)
|
|
'low_freq_damping': 0.3, # 低频阻尼 (0.0-1.0)
|
|
'stereo_spread': 0.5, # 立体声扩散 (0.0-1.0)
|
|
'reverb_time': 2.0, # 混响时间 (秒)
|
|
'tail_density': 0.8, # 尾部密度 (0.0-1.0)
|
|
'modulation_rate': 0.1, # 调制速率 (Hz)
|
|
'modulation_depth': 0.02 # 调制深度 (0.0-1.0)
|
|
}
|
|
|
|
# 合并参数
|
|
effect_params = default_params.copy()
|
|
effect_params.update(parameters)
|
|
|
|
# 创建效果对象
|
|
effect = {
|
|
'id': effect_id,
|
|
'type': 'reverb',
|
|
'parameters': effect_params,
|
|
'active': True,
|
|
'buffers': {}, # 各种缓冲区
|
|
'comb_filters': [], # 梳状滤波器数组
|
|
'allpass_filters': [], # 全通滤波器数组
|
|
'modulation_phase': 0.0, # 调制相位
|
|
'created_time': self._get_current_time(),
|
|
'process_count': 0
|
|
}
|
|
|
|
# 初始化滤波器
|
|
self._initialize_filters(effect)
|
|
|
|
# 初始化缓冲区
|
|
self._initialize_buffers(effect)
|
|
|
|
# 存储效果
|
|
self.effects[effect_id] = effect
|
|
|
|
# 更新统计信息
|
|
self.stats['total_effects'] += 1
|
|
self.stats['active_effects'] += 1
|
|
|
|
# 在插件中注册效果
|
|
if self.plugin:
|
|
self.plugin.effects[effect_id] = effect.copy()
|
|
|
|
print(f"✓ 混响效果创建成功: {effect_id}")
|
|
return effect_id
|
|
|
|
except Exception as e:
|
|
print(f"✗ 创建混响效果失败: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return ""
|
|
|
|
def _initialize_filters(self, effect: Dict[str, Any]):
|
|
"""
|
|
初始化混响滤波器
|
|
|
|
Args:
|
|
effect: 效果对象
|
|
"""
|
|
parameters = effect['parameters']
|
|
room_size = parameters.get('room_size', 0.5)
|
|
damping = parameters.get('damping', 0.5)
|
|
diffusion = parameters.get('diffusion', 0.7)
|
|
density = parameters.get('density', 0.5)
|
|
|
|
# 创建梳状滤波器
|
|
comb_filters = []
|
|
for i, (delay_ms, decay_factor) in enumerate(zip(self.comb_delays, self.comb_decay_factors)):
|
|
# 根据房间大小调整延迟时间
|
|
adjusted_delay = delay_ms * (0.5 + room_size * 0.5)
|
|
|
|
# 根据密度调整延迟时间
|
|
adjusted_delay *= (0.8 + density * 0.4)
|
|
|
|
# 计算延迟样本数
|
|
delay_samples = int(adjusted_delay * self.sample_rate / 1000)
|
|
|
|
# 根据扩散调整反馈系数
|
|
feedback = decay_factor * (0.7 + diffusion * 0.3)
|
|
|
|
# 根据阻尼调整高频衰减
|
|
damp_factor = 0.3 + damping * 0.5
|
|
|
|
comb_filter = {
|
|
'buffer': np.zeros(max(1, delay_samples)),
|
|
'index': 0,
|
|
'feedback': feedback,
|
|
'damp1': damp_factor,
|
|
'damp2': 0.0,
|
|
'filter_store': 0.0
|
|
}
|
|
comb_filters.append(comb_filter)
|
|
|
|
effect['comb_filters'] = comb_filters
|
|
|
|
# 创建全通滤波器
|
|
allpass_filters = []
|
|
for i, delay_ms in enumerate(self.allpass_delays):
|
|
# 根据房间大小调整延迟时间
|
|
adjusted_delay = delay_ms * (0.5 + room_size * 0.5)
|
|
|
|
# 计算延迟样本数
|
|
delay_samples = int(adjusted_delay * self.sample_rate / 1000)
|
|
|
|
allpass_filter = {
|
|
'buffer': np.zeros(max(1, delay_samples)),
|
|
'index': 0,
|
|
'feedback': self.allpass_feedback
|
|
}
|
|
allpass_filters.append(allpass_filter)
|
|
|
|
effect['allpass_filters'] = allpass_filters
|
|
|
|
def _initialize_buffers(self, effect: Dict[str, Any]):
|
|
"""
|
|
初始化混响缓冲区
|
|
|
|
Args:
|
|
effect: 效果对象
|
|
"""
|
|
effect_id = effect['id']
|
|
buffers = {}
|
|
|
|
# 输入和输出缓冲区
|
|
buffers['input'] = np.zeros(self.buffer_size)
|
|
buffers['output_left'] = np.zeros(self.buffer_size)
|
|
buffers['output_right'] = np.zeros(self.buffer_size)
|
|
buffers['mono_input'] = np.zeros(self.buffer_size)
|
|
|
|
# 预延迟缓冲区
|
|
predelay = effect['parameters'].get('predelay', 0.0)
|
|
predelay_samples = int(predelay * self.sample_rate)
|
|
buffers['predelay_buffer'] = np.zeros(max(1, predelay_samples))
|
|
buffers['predelay_index'] = 0
|
|
|
|
effect['buffers'] = buffers
|
|
|
|
def delete_effect(self, effect_id: str) -> bool:
|
|
"""
|
|
删除混响效果
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
|
|
Returns:
|
|
是否删除成功
|
|
"""
|
|
if effect_id not in self.effects:
|
|
print(f"✗ 混响效果不存在: {effect_id}")
|
|
return False
|
|
|
|
try:
|
|
# 删除效果
|
|
del self.effects[effect_id]
|
|
|
|
# 更新统计信息
|
|
self.stats['active_effects'] -= 1
|
|
|
|
# 从插件中移除效果
|
|
if self.plugin and effect_id in self.plugin.effects:
|
|
del self.plugin.effects[effect_id]
|
|
|
|
print(f"✓ 混响效果已删除: {effect_id}")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"✗ 删除混响效果失败: {e}")
|
|
return False
|
|
|
|
def process(self, audio_data: Any, parameters: Dict[str, Any]) -> Any:
|
|
"""
|
|
处理混响效果
|
|
|
|
Args:
|
|
audio_data: 输入音频数据
|
|
parameters: 效果参数
|
|
|
|
Returns:
|
|
处理后的音频数据
|
|
"""
|
|
try:
|
|
import time
|
|
process_start = time.time()
|
|
|
|
# 如果输入是NumPy数组
|
|
if isinstance(audio_data, np.ndarray):
|
|
processed_data = self._process_numpy_array(audio_data, parameters)
|
|
else:
|
|
# 对于其他类型的数据，返回原始数据
|
|
processed_data = audio_data
|
|
|
|
# 更新统计信息
|
|
self.stats['effects_processed'] += 1
|
|
self.stats['processing_time'] += (time.time() - process_start)
|
|
|
|
return processed_data
|
|
|
|
except Exception as e:
|
|
print(f"✗ 混响效果处理失败: {e}")
|
|
return audio_data
|
|
|
|
def _process_numpy_array(self, audio_data: np.ndarray, parameters: Dict[str, Any]) -> np.ndarray:
|
|
"""
|
|
处理NumPy数组音频数据
|
|
|
|
Args:
|
|
audio_data: 输入音频数据
|
|
parameters: 效果参数
|
|
|
|
Returns:
|
|
处理后的音频数据
|
|
"""
|
|
# 获取参数
|
|
room_size = parameters.get('room_size', 0.5)
|
|
damping = parameters.get('damping', 0.5)
|
|
wet_level = parameters.get('wet_level', 0.33)
|
|
dry_level = parameters.get('dry_level', 0.4)
|
|
width = parameters.get('width', 1.0)
|
|
freeze_mode = parameters.get('freeze_mode', 0.0)
|
|
early_reflections = parameters.get('early_reflections', 0.5)
|
|
late_reverb = parameters.get('late_reverb', 0.5)
|
|
diffusion = parameters.get('diffusion', 0.7)
|
|
density = parameters.get('density', 0.5)
|
|
predelay = parameters.get('predelay', 0.0)
|
|
high_freq_damping = parameters.get('high_freq_damping', 0.5)
|
|
low_freq_damping = parameters.get('low_freq_damping', 0.3)
|
|
stereo_spread = parameters.get('stereo_spread', 0.5)
|
|
reverb_time = parameters.get('reverb_time', 2.0)
|
|
tail_density = parameters.get('tail_density', 0.8)
|
|
modulation_rate = parameters.get('modulation_rate', 0.1)
|
|
modulation_depth = parameters.get('modulation_depth', 0.02)
|
|
|
|
# 如果是冻结模式，增加反馈
|
|
if freeze_mode > 0.5:
|
|
room_size = min(1.0, room_size + 0.2)
|
|
|
|
# 创建输出数组
|
|
if audio_data.ndim == 1:
|
|
# 单声道输入，生成立体声输出
|
|
output_left = np.zeros_like(audio_data)
|
|
output_right = np.zeros_like(audio_data)
|
|
|
|
# 处理每个样本
|
|
for i in range(len(audio_data)):
|
|
input_sample = audio_data[i]
|
|
|
|
# 预延迟处理
|
|
delayed_sample = self._apply_predelay(input_sample, predelay)
|
|
|
|
# 混响处理
|
|
reverb_left, reverb_right = self._apply_reverb(
|
|
delayed_sample, room_size, damping, diffusion, density,
|
|
stereo_spread, modulation_rate, modulation_depth)
|
|
|
|
# 应用早期反射和晚期混响权重
|
|
reverb_left *= (early_reflections * 0.3 + late_reverb * 0.7)
|
|
reverb_right *= (early_reflections * 0.3 + late_reverb * 0.7)
|
|
|
|
# 混合干湿信号
|
|
output_left[i] = input_sample * dry_level + reverb_left * wet_level
|
|
output_right[i] = input_sample * dry_level + reverb_right * wet_level
|
|
|
|
# 合并为立体声数组
|
|
output_data = np.array([output_left, output_right])
|
|
|
|
else:
|
|
# 多声道处理（假设已经是立体声）
|
|
if audio_data.shape[0] >= 2:
|
|
output_left = np.zeros_like(audio_data[0])
|
|
output_right = np.zeros_like(audio_data[1])
|
|
|
|
for i in range(audio_data.shape[1]):
|
|
# 将左右声道混合为单声道输入
|
|
mono_input = (audio_data[0, i] + audio_data[1, i]) * 0.5
|
|
|
|
# 预延迟处理
|
|
delayed_sample = self._apply_predelay(mono_input, predelay)
|
|
|
|
# 混响处理
|
|
reverb_left, reverb_right = self._apply_reverb(
|
|
delayed_sample, room_size, damping, diffusion, density,
|
|
stereo_spread, modulation_rate, modulation_depth)
|
|
|
|
# 应用早期反射和晚期混响权重
|
|
reverb_left *= (early_reflections * 0.3 + late_reverb * 0.7)
|
|
reverb_right *= (early_reflections * 0.3 + late_reverb * 0.7)
|
|
|
|
# 混合干湿信号
|
|
output_left[i] = audio_data[0, i] * dry_level + reverb_left * wet_level
|
|
output_right[i] = audio_data[1, i] * dry_level + reverb_right * wet_level
|
|
|
|
output_data = np.array([output_left, output_right])
|
|
else:
|
|
# 其他多声道情况，返回原始数据
|
|
output_data = audio_data
|
|
|
|
# 确保输出在有效范围内
|
|
processed_data = np.clip(output_data, -1.0, 1.0)
|
|
return processed_data
|
|
|
|
def _apply_predelay(self, sample: float, predelay: float) -> float:
|
|
"""
|
|
应用预延迟
|
|
|
|
Args:
|
|
sample: 输入样本
|
|
predelay: 预延迟时间 (秒)
|
|
|
|
Returns:
|
|
延迟后的样本
|
|
"""
|
|
# 简化的预延迟实现
|
|
# 实际应用中会使用延迟线
|
|
return sample # 简化实现
|
|
|
|
def _apply_reverb(self, sample: float, room_size: float, damping: float,
|
|
diffusion: float, density: float, stereo_spread: float,
|
|
modulation_rate: float, modulation_depth: float) -> tuple:
|
|
"""
|
|
应用混响处理
|
|
|
|
Args:
|
|
sample: 输入样本
|
|
room_size: 房间大小
|
|
damping: 阻尼
|
|
diffusion: 扩散
|
|
density: 密度
|
|
stereo_spread: 立体声扩散
|
|
modulation_rate: 调制速率
|
|
modulation_depth: 调制深度
|
|
|
|
Returns:
|
|
(左声道混响, 右声道混响)
|
|
"""
|
|
# 简化的混响实现
|
|
# 实际应用中会使用梳状滤波器和全通滤波器链
|
|
|
|
# 生成基于参数的混响效果
|
|
reverb_amount = 0.2 + room_size * 0.5
|
|
damp_factor = 0.2 + damping * 0.6
|
|
diffuse_factor = 0.5 + diffusion * 0.3
|
|
|
|
# 左声道混响
|
|
left_reverb = sample * reverb_amount * (1.0 - damp_factor)
|
|
left_reverb *= (0.7 + diffuse_factor * 0.3)
|
|
|
|
# 右声道混响（添加立体声扩散）
|
|
stereo_offset = stereo_spread * 0.3
|
|
right_reverb = sample * (reverb_amount + stereo_offset) * (1.0 - damp_factor * 0.8)
|
|
right_reverb *= (0.7 + diffuse_factor * 0.3)
|
|
|
|
return left_reverb, right_reverb
|
|
|
|
def set_parameter(self, effect_id: str, parameter: str, value: Any) -> bool:
|
|
"""
|
|
设置效果参数
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
parameter: 参数名
|
|
value: 参数值
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
if effect_id not in self.effects:
|
|
print(f"✗ 混响效果不存在: {effect_id}")
|
|
return False
|
|
|
|
try:
|
|
self.effects[effect_id]['parameters'][parameter] = value
|
|
|
|
# 如果是影响滤波器的参数，重新初始化滤波器
|
|
filter_params = ['room_size', 'damping', 'diffusion', 'density']
|
|
if parameter in filter_params:
|
|
self._initialize_filters(self.effects[effect_id])
|
|
|
|
# 如果是插件中的效果，也更新插件中的副本
|
|
if self.plugin and effect_id in self.plugin.effects:
|
|
self.plugin.effects[effect_id]['parameters'][parameter] = value
|
|
if parameter in filter_params:
|
|
self.plugin.effects[effect_id]['comb_filters'] = \
|
|
self.effects[effect_id]['comb_filters'].copy()
|
|
self.plugin.effects[effect_id]['allpass_filters'] = \
|
|
self.effects[effect_id]['allpass_filters'].copy()
|
|
|
|
print(f"✓ 混响效果参数已设置: {effect_id}.{parameter} = {value}")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"✗ 设置混响效果参数失败: {e}")
|
|
return False
|
|
|
|
def get_parameters(self, effect_id: str) -> Dict[str, Any]:
|
|
"""
|
|
获取效果参数
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
|
|
Returns:
|
|
参数字典
|
|
"""
|
|
if effect_id not in self.effects:
|
|
return {}
|
|
|
|
return self.effects[effect_id]['parameters'].copy()
|
|
|
|
def enable_effect(self, effect_id: str) -> bool:
|
|
"""
|
|
启用混响效果
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
|
|
Returns:
|
|
是否启用成功
|
|
"""
|
|
if effect_id not in self.effects:
|
|
print(f"✗ 混响效果不存在: {effect_id}")
|
|
return False
|
|
|
|
try:
|
|
self.effects[effect_id]['active'] = True
|
|
self.stats['active_effects'] += 1
|
|
|
|
# 如果是插件中的效果，也更新插件中的副本
|
|
if self.plugin and effect_id in self.plugin.effects:
|
|
self.plugin.effects[effect_id]['active'] = True
|
|
|
|
print(f"✓ 混响效果已启用: {effect_id}")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"✗ 启用混响效果失败: {e}")
|
|
return False
|
|
|
|
def disable_effect(self, effect_id: str) -> bool:
|
|
"""
|
|
禁用混响效果
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
|
|
Returns:
|
|
是否禁用成功
|
|
"""
|
|
if effect_id not in self.effects:
|
|
print(f"✗ 混响效果不存在: {effect_id}")
|
|
return False
|
|
|
|
try:
|
|
self.effects[effect_id]['active'] = False
|
|
self.stats['active_effects'] -= 1
|
|
|
|
# 如果是插件中的效果，也更新插件中的副本
|
|
if self.plugin and effect_id in self.plugin.effects:
|
|
self.plugin.effects[effect_id]['active'] = False
|
|
|
|
print(f"✓ 混响效果已禁用: {effect_id}")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"✗ 禁用混响效果失败: {e}")
|
|
return False
|
|
|
|
def cleanup(self):
|
|
"""清理所有资源"""
|
|
self.effects.clear()
|
|
self.comb_filters.clear()
|
|
self.allpass_filters.clear()
|
|
self.stats = {
|
|
'total_effects': 0,
|
|
'active_effects': 0,
|
|
'effects_processed': 0,
|
|
'processing_time': 0.0,
|
|
'memory_usage': 0
|
|
}
|
|
print("✓ 混响效果处理器资源已清理")
|
|
|
|
def get_stats(self) -> Dict[str, int]:
|
|
"""
|
|
获取统计信息
|
|
|
|
Returns:
|
|
统计信息字典
|
|
"""
|
|
return self.stats.copy()
|
|
|
|
def _get_current_time(self) -> float:
|
|
"""
|
|
获取当前时间（秒）
|
|
|
|
Returns:
|
|
当前时间
|
|
"""
|
|
if self.plugin and self.plugin.plugin_manager and self.plugin.plugin_manager.world:
|
|
return self.plugin.plugin_manager.world.globalClock.getFrameTime()
|
|
import time
|
|
return time.time()
|
|
|
|
def update(self, dt: float):
|
|
"""
|
|
更新处理器状态
|
|
|
|
Args:
|
|
dt: 时间增量
|
|
"""
|
|
# 更新调制相位
|
|
for effect_id, effect in self.effects.items():
|
|
modulation_rate = effect['parameters'].get('modulation_rate', 0.1)
|
|
effect['modulation_phase'] += 2.0 * math.pi * modulation_rate * dt
|
|
if effect['modulation_phase'] >= 2.0 * math.pi:
|
|
effect['modulation_phase'] -= 2.0 * math.pi
|
|
|
|
def set_sample_rate(self, sample_rate: int):
|
|
"""
|
|
设置采样率
|
|
|
|
Args:
|
|
sample_rate: 采样率 (Hz)
|
|
"""
|
|
old_sample_rate = self.sample_rate
|
|
self.sample_rate = sample_rate
|
|
print(f"✓ 混响处理器采样率已从 {old_sample_rate} 更新为: {sample_rate} Hz")
|
|
|
|
# 重新初始化所有滤波器以适应新的采样率
|
|
for effect_id, effect in self.effects.items():
|
|
self._initialize_filters(effect)
|
|
self._initialize_buffers(effect)
|
|
|
|
def set_room_size(self, effect_id: str, room_size: float) -> bool:
|
|
"""
|
|
设置房间大小
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
room_size: 房间大小 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'room_size', max(0.0, min(1.0, room_size)))
|
|
|
|
def set_damping(self, effect_id: str, damping: float) -> bool:
|
|
"""
|
|
设置阻尼
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
damping: 阻尼 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'damping', max(0.0, min(1.0, damping)))
|
|
|
|
def set_wet_level(self, effect_id: str, wet_level: float) -> bool:
|
|
"""
|
|
设置湿信号电平
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
wet_level: 湿信号电平 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'wet_level', max(0.0, min(1.0, wet_level)))
|
|
|
|
def set_dry_level(self, effect_id: str, dry_level: float) -> bool:
|
|
"""
|
|
设置干信号电平
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
dry_level: 干信号电平 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'dry_level', max(0.0, min(1.0, dry_level)))
|
|
|
|
def set_width(self, effect_id: str, width: float) -> bool:
|
|
"""
|
|
设置宽度
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
width: 宽度 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'width', max(0.0, min(1.0, width)))
|
|
|
|
def set_freeze_mode(self, effect_id: str, freeze_mode: float) -> bool:
|
|
"""
|
|
设置冻结模式
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
freeze_mode: 冻结模式 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'freeze_mode', max(0.0, min(1.0, freeze_mode)))
|
|
|
|
def set_early_reflections(self, effect_id: str, reflections: float) -> bool:
|
|
"""
|
|
设置早期反射
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
reflections: 早期反射 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'early_reflections', max(0.0, min(1.0, reflections)))
|
|
|
|
def set_late_reverb(self, effect_id: str, reverb: float) -> bool:
|
|
"""
|
|
设置晚期混响
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
reverb: 晚期混响 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'late_reverb', max(0.0, min(1.0, reverb)))
|
|
|
|
def set_diffusion(self, effect_id: str, diffusion: float) -> bool:
|
|
"""
|
|
设置扩散参数
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
diffusion: 扩散值 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'diffusion', max(0.0, min(1.0, diffusion)))
|
|
|
|
def set_density(self, effect_id: str, density: float) -> bool:
|
|
"""
|
|
设置密度参数
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
density: 密度值 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'density', max(0.0, min(1.0, density)))
|
|
|
|
def set_predelay(self, effect_id: str, predelay: float) -> bool:
|
|
"""
|
|
设置预延迟
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
predelay: 预延迟 (秒)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'predelay', max(0.0, min(0.5, predelay)))
|
|
|
|
def set_high_freq_damping(self, effect_id: str, damping: float) -> bool:
|
|
"""
|
|
设置高频阻尼
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
damping: 高频阻尼 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'high_freq_damping', max(0.0, min(1.0, damping)))
|
|
|
|
def set_low_freq_damping(self, effect_id: str, damping: float) -> bool:
|
|
"""
|
|
设置低频阻尼
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
damping: 低频阻尼 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'low_freq_damping', max(0.0, min(1.0, damping)))
|
|
|
|
def set_stereo_spread(self, effect_id: str, spread: float) -> bool:
|
|
"""
|
|
设置立体声扩散
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
spread: 立体声扩散 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'stereo_spread', max(0.0, min(1.0, spread)))
|
|
|
|
def set_reverb_time(self, effect_id: str, time: float) -> bool:
|
|
"""
|
|
设置混响时间
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
time: 混响时间 (秒)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'reverb_time', max(0.1, min(30.0, time)))
|
|
|
|
def set_tail_density(self, effect_id: str, density: float) -> bool:
|
|
"""
|
|
设置尾部密度
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
density: 尾部密度 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'tail_density', max(0.0, min(1.0, density)))
|
|
|
|
def set_modulation_rate(self, effect_id: str, rate: float) -> bool:
|
|
"""
|
|
设置调制速率
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
rate: 调制速率 (Hz)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'modulation_rate', max(0.01, min(10.0, rate)))
|
|
|
|
def set_modulation_depth(self, effect_id: str, depth: float) -> bool:
|
|
"""
|
|
设置调制深度
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
depth: 调制深度 (0.0-1.0)
|
|
|
|
Returns:
|
|
是否设置成功
|
|
"""
|
|
return self.set_parameter(effect_id, 'modulation_depth', max(0.0, min(1.0, depth)))
|
|
|
|
def get_reverb_time(self, effect_id: str) -> float:
|
|
"""
|
|
获取混响时间表
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
|
|
Returns:
|
|
当前混响时间 (秒)
|
|
"""
|
|
if effect_id not in self.effects:
|
|
return 0.0
|
|
|
|
return self.effects[effect_id]['parameters'].get('reverb_time', 2.0)
|
|
|
|
def get_room_size_meter(self, effect_id: str) -> float:
|
|
"""
|
|
获取房间大小表
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
|
|
Returns:
|
|
当前房间大小 (0.0-1.0)
|
|
"""
|
|
if effect_id not in self.effects:
|
|
return 0.0
|
|
|
|
return self.effects[effect_id]['parameters'].get('room_size', 0.5)
|
|
|
|
def create_preset(self, preset_name: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
创建混响预设
|
|
|
|
Args:
|
|
preset_name: 预设名称
|
|
parameters: 参数
|
|
|
|
Returns:
|
|
预设参数字典
|
|
"""
|
|
presets = {
|
|
'small_room': {
|
|
'room_size': 0.2,
|
|
'damping': 0.7,
|
|
'wet_level': 0.2,
|
|
'dry_level': 0.8,
|
|
'width': 0.8,
|
|
'early_reflections': 0.6,
|
|
'late_reverb': 0.4,
|
|
'diffusion': 0.6,
|
|
'density': 0.3,
|
|
'reverb_time': 1.0
|
|
},
|
|
'medium_room': {
|
|
'room_size': 0.5,
|
|
'damping': 0.5,
|
|
'wet_level': 0.3,
|
|
'dry_level': 0.7,
|
|
'width': 0.9,
|
|
'early_reflections': 0.7,
|
|
'late_reverb': 0.5,
|
|
'diffusion': 0.7,
|
|
'density': 0.5,
|
|
'reverb_time': 1.5
|
|
},
|
|
'large_room': {
|
|
'room_size': 0.7,
|
|
'damping': 0.4,
|
|
'wet_level': 0.4,
|
|
'dry_level': 0.6,
|
|
'width': 1.0,
|
|
'early_reflections': 0.8,
|
|
'late_reverb': 0.6,
|
|
'diffusion': 0.8,
|
|
'density': 0.7,
|
|
'reverb_time': 2.0
|
|
},
|
|
'large_hall': {
|
|
'room_size': 0.9,
|
|
'damping': 0.3,
|
|
'wet_level': 0.5,
|
|
'dry_level': 0.5,
|
|
'width': 1.0,
|
|
'early_reflections': 0.9,
|
|
'late_reverb': 0.7,
|
|
'diffusion': 0.9,
|
|
'density': 0.8,
|
|
'reverb_time': 3.0
|
|
},
|
|
'cathedral': {
|
|
'room_size': 1.0,
|
|
'damping': 0.2,
|
|
'wet_level': 0.7,
|
|
'dry_level': 0.3,
|
|
'width': 1.0,
|
|
'early_reflections': 1.0,
|
|
'late_reverb': 0.8,
|
|
'diffusion': 1.0,
|
|
'density': 1.0,
|
|
'reverb_time': 5.0
|
|
},
|
|
'bathroom': {
|
|
'room_size': 0.2,
|
|
'damping': 0.1,
|
|
'wet_level': 0.8,
|
|
'dry_level': 0.2,
|
|
'width': 0.9,
|
|
'early_reflections': 0.5,
|
|
'late_reverb': 0.9,
|
|
'diffusion': 0.5,
|
|
'density': 0.2,
|
|
'reverb_time': 0.8
|
|
},
|
|
'tunnel': {
|
|
'room_size': 0.8,
|
|
'damping': 0.6,
|
|
'wet_level': 0.6,
|
|
'dry_level': 0.4,
|
|
'width': 0.7,
|
|
'early_reflections': 0.7,
|
|
'late_reverb': 0.7,
|
|
'diffusion': 0.6,
|
|
'density': 0.6,
|
|
'reverb_time': 2.5
|
|
},
|
|
'arena': {
|
|
'room_size': 0.95,
|
|
'damping': 0.25,
|
|
'wet_level': 0.6,
|
|
'dry_level': 0.4,
|
|
'width': 1.0,
|
|
'early_reflections': 0.95,
|
|
'late_reverb': 0.75,
|
|
'diffusion': 0.95,
|
|
'density': 0.9,
|
|
'reverb_time': 4.0
|
|
}
|
|
}
|
|
|
|
if preset_name in presets:
|
|
preset_params = presets[preset_name].copy()
|
|
preset_params.update(parameters)
|
|
return preset_params
|
|
else:
|
|
return parameters.copy()
|
|
|
|
def get_frequency_response(self, effect_id: str) -> Dict[str, Any]:
|
|
"""
|
|
获取频率响应
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
|
|
Returns:
|
|
频率响应数据
|
|
"""
|
|
if effect_id not in self.effects:
|
|
return {}
|
|
|
|
parameters = self.effects[effect_id]['parameters']
|
|
|
|
# 生成简化的频率响应数据
|
|
frequencies = np.logspace(np.log10(20), np.log10(20000), 100)
|
|
response = []
|
|
|
|
room_size = parameters.get('room_size', 0.5)
|
|
damping = parameters.get('damping', 0.5)
|
|
high_freq_damping = parameters.get('high_freq_damping', 0.5)
|
|
low_freq_damping = parameters.get('low_freq_damping', 0.3)
|
|
|
|
for freq in frequencies:
|
|
# 计算基于参数的频率响应
|
|
if freq < 200: # 低频
|
|
gain = 1.0 - low_freq_damping * 0.3
|
|
elif freq > 5000: # 高频
|
|
gain = 1.0 - high_freq_damping * 0.5
|
|
else: # 中频
|
|
gain = 1.0 - damping * 0.2
|
|
|
|
# 房间大小影响
|
|
gain *= (0.8 + room_size * 0.4)
|
|
|
|
response.append(gain)
|
|
|
|
return {
|
|
'frequencies': frequencies.tolist(),
|
|
'response': response
|
|
}
|
|
|