""" 音频混响和效果插件主文件 提供专业的音频混响和效果处理功能 """ import math import time import uuid from typing import Dict, List, Optional, Any, Callable from plugins.plugin_manager import BasePlugin from panda3d.core import AudioSound, NodePath class Plugin(BasePlugin): """ 音频混响和效果插件 提供专业的音频混响和效果处理功能 """ def __init__(self, plugin_manager, name): super().__init__(plugin_manager, name) self.config = { "version": "1.0.0", "author": "EG Team", "description": "专业的音频混响和效果处理插件，支持多种高级音频效果" } # 核心组件 self.audio_manager = None self.listener = None # 效果处理器 self.reverb_processor = None self.eq_processor = None self.compressor_processor = None self.modulation_processor = None self.distortion_processor = None self.spatial_processor = None # 效果管理 self.effects = {} # 所有效果 self.sound_effects = {} # 音效与效果的关联 self.presets = {} # 效果预设 # GUI元素 self.gui_elements = [] # 事件处理器 self.event_handlers = {} # 插件状态 self.is_initialized = False self.is_enabled = False self.processing_enabled = True # 性能监控 self.performance_stats = { 'initialization_time': 0.0, 'enable_time': 0.0, 'last_update_time': 0.0, 'total_updates': 0, 'total_processing_time': 0.0, 'effects_processed': 0, 'memory_usage': 0 } # 配置参数 self.master_volume = 1.0 self.quality_settings = 'high' # low, medium, high self.max_effects_per_sound = 8 self.buffer_size = 4096 def initialize(self) -> bool: """ 初始化插件 """ try: if self.is_initialized: return True init_start_time = time.time() print(f"初始化音频混响和效果插件: {self.name}") # 初始化音频管理器 self.audio_manager = self.plugin_manager.world.audio_manager # 初始化听者 self.listener = self.plugin_manager.world.camera # 初始化各效果处理器 from .effects.reverb_processor import ReverbProcessor from .effects.eq_processor import EQProcessor from .effects.compressor_processor import CompressorProcessor from .effects.modulation_processor import ModulationProcessor from .effects.distortion_processor import DistortionProcessor from .effects.spatial_processor import SpatialProcessor self.reverb_processor = ReverbProcessor(self) self.eq_processor = EQProcessor(self) self.compressor_processor = CompressorProcessor(self) self.modulation_processor = ModulationProcessor(self) self.distortion_processor = DistortionProcessor(self) self.spatial_processor = SpatialProcessor(self) # 加载预设 self._load_presets() self.is_initialized = True self.performance_stats['initialization_time'] = time.time() - init_start_time print("✓ 音频混响和效果插件初始化完成") return True except Exception as e: print(f"✗ 音频混响和效果插件初始化失败: {e}") import traceback traceback.print_exc() return False def enable(self) -> bool: """ 启用插件 """ if not super().enable(): return False if self.is_enabled: return True try: enable_start_time = time.time() print(f"启用音频混响和效果插件: {self.name}") # 注册事件处理器 self._register_event_handlers() # 创建GUI界面 self._create_gui() self.is_enabled = True self.performance_stats['enable_time'] = time.time() - enable_start_time print("✓ 音频混响和效果插件启用成功") return True except Exception as e: print(f"✗ 音频混响和效果插件启用失败: {e}") import traceback traceback.print_exc() return False def disable(self) -> bool: """ 禁用插件 """ if not super().disable(): return False if not self.is_enabled: return True try: print(f"禁用音频混响和效果插件: {self.name}") # 清理GUI界面 self._cleanup_gui() # 移除事件处理器 self._unregister_event_handlers() # 停止所有效果处理 self._stop_all_processing() self.is_enabled = False print("✓ 音频混响和效果插件禁用成功") return True except Exception as e: print(f"✗ 音频混响和效果插件禁用失败: {e}") import traceback traceback.print_exc() return False def finalize(self): """ 清理插件资源 """ print(f"清理音频混响和效果插件资源: {self.name}") # 停止所有处理 self._stop_all_processing() # 清理所有组件 processors = [ self.reverb_processor, self.eq_processor, self.compressor_processor, self.modulation_processor, self.distortion_processor, self.spatial_processor ] for processor in processors: if processor: processor.cleanup() self.reverb_processor = None self.eq_processor = None self.compressor_processor = None self.modulation_processor = None self.distortion_processor = None self.spatial_processor = None self.audio_manager = None self.listener = None self.effects.clear() self.sound_effects.clear() self.presets.clear() self.is_initialized = False self.is_enabled = False def _register_event_handlers(self): """ 注册事件处理器 """ world = self.plugin_manager.world # 音频效果控制快捷键 self.event_handlers['f1'] = self.toggle_debug_mode self.event_handlers['f2'] = self.toggle_processing self.event_handlers['f3'] = self.apply_test_reverb self.event_handlers['f4'] = self.apply_test_eq self.event_handlers['f5'] = self.show_stats self.event_handlers['f6'] = self.apply_test_compressor self.event_handlers['f7'] = self.apply_test_modulation self.event_handlers['f8'] = self.apply_test_distortion self.event_handlers['f9'] = self.create_test_preset self.event_handlers['f10'] = self.toggle_quality self.event_handlers['f11'] = self.show_detailed_stats self.event_handlers['f12'] = self.reset_all_effects # 注册事件 for event, handler in self.event_handlers.items(): world.accept(event, handler) world.accept(event.upper(), handler) # 同时注册大写事件 def _unregister_event_handlers(self): """ 移除事件处理器 """ world = self.plugin_manager.world for event in self.event_handlers.keys(): world.ignore(event) world.ignore(event.upper()) self.event_handlers.clear() def _create_gui(self): """ 创建GUI界面 """ try: world = self.plugin_manager.world # 检查是否有GUI管理器 if not hasattr(world, 'gui_manager') or not world.gui_manager: print("⚠ GUI管理器不可用，跳过GUI创建") return gui_manager = world.gui_manager # 创建音频效果控制面板 panel_button = gui_manager.createGUIButton( pos=(0.7, 0, 0.35), text="音频效果", size=0.06 ) self.gui_elements.append(panel_button) # 创建功能按钮 functions = [ ("调试模式 [F1]", self.toggle_debug_mode), ("切换处理 [F2]", self.toggle_processing), ("测试混响 [F3]", self.apply_test_reverb), ("测试EQ [F4]", self.apply_test_eq), ("效果统计 [F5]", self.show_stats), ("测试压缩 [F6]", self.apply_test_compressor), ("测试调制 [F7]", self.apply_test_modulation), ("测试失真 [F8]", self.apply_test_distortion), ("测试预设 [F9]", self.create_test_preset), ("切换质量 [F10]", self.toggle_quality), ("详细统计 [F11]", self.show_detailed_stats), ("重置效果 [F12]", self.reset_all_effects) ] for i, (name, callback) in enumerate(functions): button = gui_manager.createGUIButton( pos=(0.7, 0, 0.28 - i * 0.055), text=name, size=0.045 ) self.gui_elements.append(button) world.accept(f"audio_effect_function_{i}", callback) except Exception as e: print(f"⚠ GUI创建失败: {e}") def _cleanup_gui(self): """ 清理GUI界面 """ try: world = self.plugin_manager.world if hasattr(world, 'gui_manager') and world.gui_manager: gui_manager = world.gui_manager # 删除所有GUI元素 for element in self.gui_elements: gui_manager.deleteGUIElement(element) self.gui_elements.clear() except Exception as e: print(f"⚠ GUI清理失败: {e}") # 事件处理方法 def toggle_debug_mode(self): """切换调试模式""" print("✓ 音频效果调试模式切换") def toggle_processing(self): """切换效果处理""" self.processing_enabled = not self.processing_enabled print(f"✓ 音频效果处理已{'启用' if self.processing_enabled else '禁用'}") def apply_test_reverb(self): """应用测试混响效果""" print("✓ 应用测试混响效果") try: # 创建一个测试混响效果 reverb_params = { 'room_size': 0.8, 'damping': 0.5, 'wet_level': 0.3, 'dry_level': 0.7, 'width': 1.0, 'freeze_mode': 0.0 } effect_id = self.create_reverb_effect(reverb_params) if effect_id: print(f"✓ 测试混响效果创建成功: {effect_id}") else: print("✗ 测试混响效果创建失败") except Exception as e: print(f"✗ 应用测试混响效果失败: {e}") def apply_test_eq(self): """应用测试均衡器效果""" print("✓ 应用测试均衡器效果") try: # 创建一个测试均衡器效果 eq_params = { 'bands': { 60: 2.0, # 60Hz 提升2dB 200: -1.0, # 200Hz 降低1dB 1000: 3.0, # 1kHz 提升3dB 5000: -2.0, # 5kHz 降低2dB 10000: 1.0 # 10kHz 提升1dB } } effect_id = self.create_eq_effect(eq_params) if effect_id: print(f"✓ 测试均衡器效果创建成功: {effect_id}") else: print("✗ 测试均衡器效果创建失败") except Exception as e: print(f"✗ 应用测试均衡器效果失败: {e}") def show_stats(self): """显示效果统计信息""" stats = self.get_stats() print("=== 音频效果统计信息 ===") for key, value in stats.items(): print(f" {key}: {value}") def apply_test_compressor(self): """应用测试压缩器效果""" print("✓ 应用测试压缩器效果") try: # 创建一个测试压缩器效果 compressor_params = { 'threshold': -20.0, 'ratio': 4.0, 'attack': 0.01, 'release': 0.1, 'gain': 2.0, 'knee': 5.0 } effect_id = self.create_compressor_effect(compressor_params) if effect_id: print(f"✓ 测试压缩器效果创建成功: {effect_id}") else: print("✗ 测试压缩器效果创建失败") except Exception as e: print(f"✗ 应用测试压缩器效果失败: {e}") def apply_test_modulation(self): """应用测试调制效果""" print("✓ 应用测试调制效果") try: # 创建一个测试合唱效果 modulation_params = { 'type': 'chorus', 'rate': 1.0, 'depth': 0.5, 'feedback': 0.3, 'mix': 0.5, 'delay': 0.01 } effect_id = self.create_modulation_effect(modulation_params) if effect_id: print(f"✓ 测试调制效果创建成功: {effect_id}") else: print("✗ 测试调制效果创建失败") except Exception as e: print(f"✗ 应用测试调制效果失败: {e}") def apply_test_distortion(self): """应用测试失真效果""" print("✓ 应用测试失真效果") try: # 创建一个测试失真效果 distortion_params = { 'drive': 0.5, 'tone': 0.8, 'level': 0.7, 'bias': 0.0 } effect_id = self.create_distortion_effect(distortion_params) if effect_id: print(f"✓ 测试失真效果创建成功: {effect_id}") else: print("✗ 测试失真效果创建失败") except Exception as e: print(f"✗ 应用测试失真效果失败: {e}") def create_test_preset(self): """创建测试预设""" print("✓ 创建测试预设") try: preset_name = f"test_preset_{int(time.time())}" preset_data = { 'reverb': { 'room_size': 0.7, 'damping': 0.6, 'wet_level': 0.4, 'dry_level': 0.6 }, 'eq': { 'bands': { 100: 2.0, 1000: -1.0, 8000: 1.5 } }, 'compressor': { 'threshold': -15.0, 'ratio': 3.0 } } success = self.create_preset(preset_name, preset_data) if success: print(f"✓ 测试预设创建成功: {preset_name}") else: print("✗ 测试预设创建失败") except Exception as e: print(f"✗ 创建测试预设失败: {e}") def toggle_quality(self): """切换音质设置""" quality_levels = ['low', 'medium', 'high'] current_index = quality_levels.index(self.quality_settings) next_index = (current_index + 1) % len(quality_levels) self.quality_settings = quality_levels[next_index] print(f"✓ 音质设置已切换到: {self.quality_settings}") def show_detailed_stats(self): """显示详细统计信息""" print("=== 音频效果详细统计信息 ===") # 显示各处理器统计 processors = [ ('混响处理器', self.reverb_processor), ('均衡器处理器', self.eq_processor), ('压缩器处理器', self.compressor_processor), ('调制处理器', self.modulation_processor), ('失真处理器', self.distortion_processor), ('空间处理器', self.spatial_processor) ] for name, processor in processors: if processor: processor_stats = processor.get_stats() print(f"{name}统计:") for key, value in processor_stats.items(): print(f" {key}: {value}") # 显示性能统计 perf_stats = self.performance_stats print("性能统计:") for key, value in perf_stats.items(): print(f" {key}: {value}") def reset_all_effects(self): """重置所有效果""" print("✓ 重置所有音频效果") self.effects.clear() self.sound_effects.clear() print("✓ 所有音频效果已重置") def _stop_all_processing(self): """停止所有效果处理""" print("✓ 停止所有音频效果处理") def _load_presets(self): """加载预设效果""" # 默认预设 self.presets['small_room'] = { 'reverb': { 'room_size': 0.3, 'damping': 0.7, 'wet_level': 0.2, 'dry_level': 0.8, 'width': 0.8 } } self.presets['large_hall'] = { 'reverb': { 'room_size': 0.9, 'damping': 0.4, 'wet_level': 0.5, 'dry_level': 0.5, 'width': 1.0 } } self.presets['cathedral'] = { 'reverb': { 'room_size': 1.0, 'damping': 0.2, 'wet_level': 0.7, 'dry_level': 0.3, 'width': 1.0 } } self.presets['bathroom'] = { 'reverb': { 'room_size': 0.2, 'damping': 0.1, 'wet_level': 0.8, 'dry_level': 0.2, 'width': 0.9 } } print("✓ 预设效果加载完成") def get_stats(self) -> Dict[str, Any]: """ 获取插件统计信息 Returns: 统计信息字典 """ stats = self.performance_stats.copy() # 收集各处理器统计 processors = [ self.reverb_processor, self.eq_processor, self.compressor_processor, self.modulation_processor, self.distortion_processor, self.spatial_processor ] processor_names = [ 'reverb', 'eq', 'compressor', 'modulation', 'distortion', 'spatial' ] for i, processor in enumerate(processors): if processor: processor_stats = processor.get_stats() for key, value in processor_stats.items(): stats[f"{processor_names[i]}_{key}"] = value # 添加效果统计 stats['total_effects'] = len(self.effects) stats['active_effects'] = sum(1 for effect in self.effects.values() if effect.get('active', True)) stats['effect_assignments'] = sum(len(effect_list) for effect_list in self.sound_effects.values()) return stats # 公共接口方法 def create_reverb_effect(self, parameters: Dict[str, Any]) -> str: """ 创建混响效果 Args: parameters: 混响参数 Returns: 效果ID """ if self.reverb_processor: return self.reverb_processor.create_effect(parameters) return "" def create_eq_effect(self, parameters: Dict[str, Any]) -> str: """ 创建均衡器效果 Args: parameters: 均衡器参数 Returns: 效果ID """ if self.eq_processor: return self.eq_processor.create_effect(parameters) return "" def create_compressor_effect(self, parameters: Dict[str, Any]) -> str: """ 创建压缩器效果 Args: parameters: 压缩器参数 Returns: 效果ID """ if self.compressor_processor: return self.compressor_processor.create_effect(parameters) return "" def create_modulation_effect(self, parameters: Dict[str, Any]) -> str: """ 创建调制效果 Args: parameters: 调制参数 Returns: 效果ID """ if self.modulation_processor: return self.modulation_processor.create_effect(parameters) return "" def create_distortion_effect(self, parameters: Dict[str, Any]) -> str: """ 创建失真效果 Args: parameters: 失真参数 Returns: 效果ID """ if self.distortion_processor: return self.distortion_processor.create_effect(parameters) return "" def create_spatial_effect(self, parameters: Dict[str, Any]) -> str: """ 创建空间效果 Args: parameters: 空间效果参数 Returns: 效果ID """ if self.spatial_processor: return self.spatial_processor.create_effect(parameters) return "" 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: # 从所有音效中移除该效果 for sound_id, effect_list in self.sound_effects.items(): if effect_id in effect_list: effect_list.remove(effect_id) # 删除效果 del self.effects[effect_id] print(f"✓ 音频效果已删除: {effect_id}") return True except Exception as e: print(f"✗ 删除音频效果失败: {e}") return False def apply_effect_to_sound(self, sound_id: str, effect_id: str) -> bool: """ 应用效果到音效 Args: sound_id: 音源ID effect_id: 效果ID Returns: 是否应用成功 """ # 检查音源和效果是否存在 # 注意：这里需要与主音频系统集成 if effect_id not in self.effects: print(f"✗ 效果不存在: {effect_id}") return False try: # 初始化音效的效果列表 if sound_id not in self.sound_effects: self.sound_effects[sound_id] = [] # 检查是否超过最大效果数 if len(self.sound_effects[sound_id]) >= self.max_effects_per_sound: print(f"✗ 音效已达到最大效果数限制: {self.max_effects_per_sound}") return False # 添加效果到音效 if effect_id not in self.sound_effects[sound_id]: self.sound_effects[sound_id].append(effect_id) effect_type = self.effects[effect_id]['type'] print(f"✓ 效果已应用到音效: {effect_id} ({effect_type}) -> {sound_id}") return True else: print(f"⚠ 效果已应用于该音效: {effect_id} -> {sound_id}") return True except Exception as e: print(f"✗ 应用效果到音效失败: {e}") return False def remove_effect_from_sound(self, sound_id: str, effect_id: str) -> bool: """ 从音效移除效果 Args: sound_id: 音源ID effect_id: 效果ID Returns: 是否移除成功 """ # 检查音源和效果是否存在 if effect_id not in self.effects: print(f"✗ 效果不存在: {effect_id}") return False try: # 检查效果是否已应用于该音效 if sound_id in self.sound_effects and effect_id in self.sound_effects[sound_id]: self.sound_effects[sound_id].remove(effect_id) effect_type = self.effects[effect_id]['type'] print(f"✓ 效果已从音效移除: {effect_id} ({effect_type}) -> {sound_id}") return True else: print(f"⚠ 效果未应用于该音效: {effect_id} -> {sound_id}") return True except Exception as e: print(f"✗ 从音效移除效果失败: {e}") return False def set_effect_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 print(f"✓ 效果参数已设置: {effect_id}.{parameter} = {value}") return True except Exception as e: print(f"✗ 设置效果参数失败: {e}") return False def get_effect_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 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 print(f"✓ 效果已禁用: {effect_id}") return True except Exception as e: print(f"✗ 禁用效果失败: {e}") return False def get_effect_type(self, effect_id: str) -> str: """ 获取效果类型 Args: effect_id: 效果ID Returns: 效果类型 """ if effect_id not in self.effects: return "" return self.effects[effect_id]['type'] def get_sound_effects(self, sound_id: str) -> List[str]: """ 获取音效应用的效果列表 Args: sound_id: 音源ID Returns: 效果ID列表 """ return self.sound_effects.get(sound_id, []).copy() def create_preset(self, preset_name: str, preset_data: Dict[str, Any]) -> bool: """ 创建效果预设 Args: preset_name: 预设名称 preset_data: 预设数据 Returns: 是否创建成功 """ try: self.presets[preset_name] = preset_data.copy() print(f"✓ 效果预设创建成功: {preset_name}") return True except Exception as e: print(f"✗ 创建效果预设失败: {e}") return False def apply_preset_to_sound(self, sound_id: str, preset_name: str) -> bool: """ 应用预设到音效 Args: sound_id: 音源ID preset_name: 预设名称 Returns: 是否应用成功 """ if preset_name not in self.presets: print(f"✗ 预设不存在: {preset_name}") return False try: preset_data = self.presets[preset_name] created_effects = [] # 应用混响预设 if 'reverb' in preset_data: effect_id = self.create_reverb_effect(preset_data['reverb']) if effect_id: created_effects.append(('reverb', effect_id)) # 应用均衡器预设 if 'eq' in preset_data: effect_id = self.create_eq_effect(preset_data['eq']) if effect_id: created_effects.append(('eq', effect_id)) # 应用压缩器预设 if 'compressor' in preset_data: effect_id = self.create_compressor_effect(preset_data['compressor']) if effect_id: created_effects.append(('compressor', effect_id)) # 将所有创建的效果应用到音效 success_count = 0 for effect_type, effect_id in created_effects: if self.apply_effect_to_sound(sound_id, effect_id): success_count += 1 print(f"✓ 预设 {preset_name} 已应用到音效 {sound_id} ({success_count}/{len(created_effects)} 效果)") return success_count > 0 except Exception as e: print(f"✗ 应用预设到音效失败: {e}") return False def get_preset_names(self) -> List[str]: """ 获取所有预设名称 Returns: 预设名称列表 """ return list(self.presets.keys()) def delete_preset(self, preset_name: str) -> bool: """ 删除预设 Args: preset_name: 预设名称 Returns: 是否删除成功 """ if preset_name not in self.presets: print(f"✗ 预设不存在: {preset_name}") return False try: del self.presets[preset_name] print(f"✓ 预设已删除: {preset_name}") return True except Exception as e: print(f"✗ 删除预设失败: {e}") return False def set_master_volume(self, volume: float): """ 设置主音量 Args: volume: 主音量 (0.0-1.0) """ self.master_volume = max(0.0, min(1.0, volume)) print(f"✓ 主音量已设置: {self.master_volume}") def get_master_volume(self) -> float: """ 获取主音量 Returns: 主音量 (0.0-1.0) """ return self.master_volume def set_quality_settings(self, quality: str): """ 设置音质设置 Args: quality: 音质等级 ('low', 'medium', 'high') """ if quality in ['low', 'medium', 'high']: self.quality_settings = quality print(f"✓ 音质设置已更新: {quality}") else: print(f"✗ 无效的音质设置: {quality}") def get_quality_settings(self) -> str: """ 获取音质设置 Returns: 音质等级 """ return self.quality_settings def update(self, dt: float): """ 更新插件状态 Args: dt: 时间增量 """ update_start_time = time.time() # 更新各效果处理器 processors = [ self.reverb_processor, self.eq_processor, self.compressor_processor, self.modulation_processor, self.distortion_processor, self.spatial_processor ] for processor in processors: if processor: processor.update(dt) # 更新性能统计 self.performance_stats['total_updates'] += 1 self.performance_stats['last_update_time'] = time.time() self.performance_stats['total_processing_time'] += (time.time() - update_start_time) def process_audio_with_effects(self, sound_id: str, audio_data: Any) -> Any: """ 使用效果处理音频数据 Args: sound_id: 音源ID audio_data: 音频数据 Returns: 处理后的音频数据 """ if not self.processing_enabled: return audio_data # 获取应用到该音效的所有效果 effect_ids = self.sound_effects.get(sound_id, []) if not effect_ids: return audio_data # 按顺序应用效果 processed_data = audio_data effects_processed = 0 for effect_id in effect_ids: if effect_id in self.effects and self.effects[effect_id].get('active', True): effect = self.effects[effect_id] effect_type = effect['type'] # 根据效果类型调用相应的处理器 if effect_type == 'reverb' and self.reverb_processor: processed_data = self.reverb_processor.process(processed_data, effect['parameters']) effects_processed += 1 elif effect_type == 'eq' and self.eq_processor: processed_data = self.eq_processor.process(processed_data, effect['parameters']) effects_processed += 1 elif effect_type == 'compressor' and self.compressor_processor: processed_data = self.compressor_processor.process(processed_data, effect['parameters']) effects_processed += 1 elif effect_type == 'modulation' and self.modulation_processor: processed_data = self.modulation_processor.process(processed_data, effect['parameters']) effects_processed += 1 elif effect_type == 'distortion' and self.distortion_processor: processed_data = self.distortion_processor.process(processed_data, effect['parameters']) effects_processed += 1 elif effect_type == 'spatial' and self.spatial_processor: processed_data = self.spatial_processor.process(processed_data, effect['parameters']) effects_processed += 1 # 更新统计 self.performance_stats['effects_processed'] += effects_processed return processed_data