基于Python编写一个智能音频降噪神器

class audiodropwidget(qwidget):
    def dragenterevent(self, event):
        if event.mimedata().hasurls():
            event.acceptproposedaction()
    
    def dropevent(self, event):
        urls = event.mimedata().urls()
        # 支持多文件和文件夹拖放

def enhanced_reduce_noise(y, sr, strength=0.5, stationary=true):
    # 第一级：谱减法降噪
    y_denoised = nr.reduce_noise(
        y=y,
        sr=sr,
        stationary=stationary,
        prop_decrease=min(0.95, strength),
        n_fft=2048
    )
    
    # 第二级：butterworth高通滤波
    sos = signal.butter(10, 0.05, 'highpass', fs=sr, output='sos')
    return signal.sosfilt(sos, y_denoised)

class batchprocessor(qthread):
    progress_updated = pyqtsignal(int, str)
    
    def run(self):
        for i, filepath in enumerate(self.files):
            # ...处理逻辑...
            self.progress_updated.emit(progress, f"处理中: {filename}")

import os
import numpy as np
import matplotlib.pyplot as plt
import librosa
import librosa.display
import noisereduce as nr
import soundfile as sf
from scipy import signal
from pyqt5.qtwidgets import (qapplication, qmainwindow, qwidget, qvboxlayout, qhboxlayout, 
                             qlabel, qpushbutton, qlineedit, qfiledialog, qmessagebox, 
                             qprogressbar, qstatusbar, qslider, qcombobox, qcheckbox)
from pyqt5.qtcore import qt, qmimedata, qurl, qthread, pyqtsignal
from pyqt5.qtgui import qfont, qdragenterevent, qdropevent

class audiodropwidget(qwidget):
    def __init__(self, parent=none):
        super().__init__(parent)
        self.setacceptdrops(true)
        self.setfixedheight(100)
        
    def dragenterevent(self, event: qdragenterevent):
        if event.mimedata().hasurls():
            event.acceptproposedaction()
    
    def dropevent(self, event: qdropevent):
        urls = event.mimedata().urls()
        if urls:
            main_window = self.window()
            if hasattr(main_window, 'handle_dropped_files'):
                main_window.handle_dropped_files(urls)
            else:
                qmessagebox.warning(self, "⚠️ 错误", "无法处理拖放的文件")

class batchprocessor(qthread):
    progress_updated = pyqtsignal(int, str)
    finished = pyqtsignal()
    
    def __init__(self, files, output_dir, strength, stationary, voice_gain, parent=none):
        super().__init__(parent)
        self.files = files
        self.output_dir = output_dir
        self.strength = strength
        self.stationary = stationary
        self.voice_gain = voice_gain
        self.canceled = false
    
    def run(self):
        total_files = len(self.files)
        for i, filepath in enumerate(self.files):
            if self.canceled:
                break
                
            try:
                self.progress_updated.emit(int((i+1)/total_files*100), f"正在处理: {os.path.basename(filepath)}")
                
                # 加载音频
                y, sr = librosa.load(filepath, sr=none)
                
                # 降噪处理
                processed_audio = self.enhanced_reduce_noise(
                    y=y,
                    sr=sr,
                    strength=self.strength,
                    stationary=self.stationary
                )
                
                # 人声音量增强
                if self.voice_gain > 0:
                    processed_audio = self.enhance_voice_volume(
                        y=processed_audio,
                        gain=self.voice_gain
                    )
                
                # 音量归一化
                processed_audio = librosa.util.normalize(processed_audio)
                
                # 保存文件
                output_path = os.path.join(self.output_dir, f"processed_{os.path.basename(filepath)}")
                sf.write(output_path, processed_audio, sr)
                
            except exception as e:
                self.progress_updated.emit(int((i+1)/total_files*100), f"处理失败: {os.path.basename(filepath)} ({str(e)})")
                continue
                
        self.finished.emit()
    
    def enhanced_reduce_noise(self, y, sr, strength=0.5, stationary=true):
        """增强的降噪算法"""
        try:
            # 第一级：谱减法降噪
            y_denoised = nr.reduce_noise(
                y=y,
                sr=sr,
                stationary=stationary,
                prop_decrease=min(0.95, strength),
                n_fft=2048,
                win_length=2048,
                hop_length=512
            )
            
            # 第二级：butterworth滤波器去除高频噪声
            sos = signal.butter(10, 0.05, 'highpass', fs=sr, output='sos')
            y_filtered = signal.sosfilt(sos, y_denoised)
            
            return y_filtered
        except exception as e:
            print(f"降噪过程中出错: {str(e)}")
            return y
    
    def enhance_voice_volume(self, y, gain=0.0):
        """简单的人声音量增强 (0.0-1.0对应0%-100%增益)"""
        try:
            if gain == 0.0:  # 0%增益时不处理
                return y
            # 增益公式：output = input * (1 + gain)
            return y * (1.0 + gain)
        except exception as e:
            print(f"人声增强过程中出错: {str(e)}")
            return y

class audiodenoiserui(qmainwindow):
    def __init__(self):
        super().__init__()
        
        # 初始化ui
        self.setwindowtitle("🎧 python音频降噪软件")
        self.setgeometry(100, 100, 600, 600)
        
        # 主窗口部件
        self.central_widget = qwidget()
        self.setcentralwidget(self.central_widget)
        self.main_layout = qvboxlayout(self.central_widget)
        
        # 标题
        self.title_label = qlabel("🎵 音频降噪与人声增强工具")
        self.title_label.setfont(qfont('microsoft yahei', 16, qfont.bold))
        self.title_label.setalignment(qt.aligncenter)
        self.main_layout.addwidget(self.title_label)
        
        # 拖放区域
        self.drop_area = audiodropwidget(self)
        self.drop_layout = qvboxlayout(self.drop_area)
        self.drop_label = qlabel("📁 拖放音频文件或文件夹到这里\n或点击下方按钮选择文件")
        self.drop_label.setfont(qfont('microsoft yahei'))
        self.drop_label.setalignment(qt.aligncenter)
        self.drop_label.setstylesheet("border: 2px dashed #aaa; padding: 20px;")
        self.drop_layout.addwidget(self.drop_label)
        self.main_layout.addwidget(self.drop_area)
        
        # 文件选择按钮
        self.file_button_layout = qhboxlayout()
        self.load_button = qpushbutton("📂 选择音频文件")
        self.load_button.setfont(qfont('microsoft yahei'))
        self.load_button.clicked.connect(self.open_file_dialog)
        self.file_button_layout.addwidget(self.load_button)
        
        self.load_folder_button = qpushbutton("📁 选择文件夹")
        self.load_folder_button.setfont(qfont('microsoft yahei'))
        self.load_folder_button.clicked.connect(self.open_folder_dialog)
        self.file_button_layout.addwidget(self.load_folder_button)
        
        self.main_layout.addlayout(self.file_button_layout)
        
        # 文件信息
        self.file_label = qlabel("❌ 未选择文件")
        self.file_label.setfont(qfont('microsoft yahei'))
        self.file_label.setalignment(qt.aligncenter)
        self.main_layout.addwidget(self.file_label)
        
        # 批量处理选项
        self.batch_checkbox = qcheckbox("启用批量处理模式")
        self.batch_checkbox.setfont(qfont('microsoft yahei'))
        self.batch_checkbox.statechanged.connect(self.toggle_batch_mode)
        self.main_layout.addwidget(self.batch_checkbox)
        
        # 批量文件列表
        self.batch_list_label = qlabel("待处理文件列表 (0):")
        self.batch_list_label.setfont(qfont('microsoft yahei'))
        self.batch_list_label.setvisible(false)
        self.main_layout.addwidget(self.batch_list_label)
        
        self.batch_files_text = qlabel("")
        self.batch_files_text.setfont(qfont('microsoft yahei', 8))
        self.batch_files_text.setwordwrap(true)
        self.batch_files_text.setvisible(false)
        self.main_layout.addwidget(self.batch_files_text)
        
        # 降噪设置
        self.denoise_layout = qvboxlayout()
        
        # 降噪强度滑块
        self.strength_layout = qhboxlayout()
        self.strength_label = qlabel("🔊 降噪强度 (0.1-1.0):")
        self.strength_label.setfont(qfont('microsoft yahei'))
        self.strength_slider = qslider(qt.horizontal)
        self.strength_slider.setrange(1, 10)
        self.strength_slider.setvalue(5)
        self.strength_value_label = qlabel("5")
        self.strength_value_label.setfont(qfont('microsoft yahei'))
        self.strength_slider.valuechanged.connect(self.update_strength_value)
        self.strength_layout.addwidget(self.strength_label)
        self.strength_layout.addwidget(self.strength_slider)
        self.strength_layout.addwidget(self.strength_value_label)
        self.denoise_layout.addlayout(self.strength_layout)
        
        # 降噪模式
        self.mode_layout = qhboxlayout()
        self.mode_label = qlabel("降噪模式:")
        self.mode_label.setfont(qfont('microsoft yahei'))
        self.mode_combo = qcombobox()
        self.mode_combo.setfont(qfont('microsoft yahei'))
        self.mode_combo.additems(["稳态噪声", "非稳态噪声"])
        self.mode_layout.addwidget(self.mode_label)
        self.mode_layout.addwidget(self.mode_combo)
        self.denoise_layout.addlayout(self.mode_layout)
        
        self.main_layout.addlayout(self.denoise_layout)
        
        # 人声音量增益滑块
        self.voice_layout = qhboxlayout()
        self.voice_label = qlabel("🔈 人声音量增益 (0-100%):")
        self.voice_label.setfont(qfont('microsoft yahei'))
        self.voice_slider = qslider(qt.horizontal)
        self.voice_slider.setrange(0, 100)  # 0%到100%
        self.voice_slider.setvalue(0)       # 默认0%(无增益)
        self.voice_value_label = qlabel("0%")
        self.voice_value_label.setfont(qfont('microsoft yahei'))
        self.voice_slider.valuechanged.connect(self.update_voice_value)
        self.voice_layout.addwidget(self.voice_label)
        self.voice_layout.addwidget(self.voice_slider)
        self.voice_layout.addwidget(self.voice_value_label)
        self.main_layout.addlayout(self.voice_layout)
        
        # 处理按钮
        self.process_button = qpushbutton("⚡ 处理音频")
        self.process_button.setfont(qfont('microsoft yahei', 12))
        self.process_button.clicked.connect(self.process_audio)
        self.main_layout.addwidget(self.process_button)
        
        # 保存按钮
        self.save_button = qpushbutton("💾 保存处理结果")
        self.save_button.setfont(qfont('microsoft yahei', 12))
        self.save_button.clicked.connect(self.save_audio)
        self.save_button.setenabled(false)
        self.main_layout.addwidget(self.save_button)
        
        # 批量处理按钮
        self.batch_process_button = qpushbutton("⚡ 批量处理所有文件")
        self.batch_process_button.setfont(qfont('microsoft yahei', 12))
        self.batch_process_button.clicked.connect(self.process_batch)
        self.batch_process_button.setvisible(false)
        self.main_layout.addwidget(self.batch_process_button)
        
        # 进度条
        self.progress_bar = qprogressbar()
        self.progress_bar.setvisible(false)
        self.main_layout.addwidget(self.progress_bar)
        
        # 状态栏
        self.status_bar = qstatusbar()
        self.status_bar.setfont(qfont('microsoft yahei'))
        self.setstatusbar(self.status_bar)
        self.status_bar.showmessage("🟢 准备就绪")
        
        # 音频数据
        self.audio_data = none
        self.sample_rate = none
        self.processed_audio = none
        self.filename = none
        self.batch_mode = false
        self.batch_files = []
        
        # 样式
        self.setstylesheet("""
            qpushbutton {
                padding: 8px;
                font-size: 14px;
            }
            qlabel {
                font-size: 14px;
            }
            qlineedit {
                font-size: 14px;
            }
            qcombobox {
                font-size: 14px;
            }
        """)
    
    def update_strength_value(self, value):
        self.strength_value_label.settext(str(value))
    
    def update_voice_value(self, value):
        self.voice_value_label.settext(f"{value}%")
    
    def toggle_batch_mode(self, state):
        self.batch_mode = state == qt.checked
        self.batch_list_label.setvisible(self.batch_mode)
        self.batch_files_text.setvisible(self.batch_mode)
        self.batch_process_button.setvisible(self.batch_mode)
        
        if not self.batch_mode:
            self.batch_files = []
            self.update_batch_list()
    
    def open_file_dialog(self):
        if self.batch_mode:
            filepaths, _ = qfiledialog.getopenfilenames(
                self, "选择音频文件", "", 
                "音频文件 (*.wav *.mp3 *.ogg *.flac);;所有文件 (*.*)"
            )
            if filepaths:
                self.add_batch_files(filepaths)
        else:
            filepath, _ = qfiledialog.getopenfilename(
                self, "选择音频文件", "", 
                "音频文件 (*.wav *.mp3 *.ogg *.flac);;所有文件 (*.*)"
            )
            if filepath:
                self.load_audio(filepath)
    
    def open_folder_dialog(self):
        folder = qfiledialog.getexistingdirectory(self, "选择包含音频文件的文件夹")
        if folder:
            if self.batch_mode:
                self.scan_folder_for_audio(folder)
            else:
                # 在非批量模式下，只加载文件夹中的第一个音频文件
                audio_files = self.find_audio_files(folder)
                if audio_files:
                    self.load_audio(audio_files[0])
                else:
                    qmessagebox.warning(self, "⚠️ 警告", "文件夹中没有找到支持的音频文件")
    
    def scan_folder_for_audio(self, folder):
        audio_files = self.find_audio_files(folder)
        if audio_files:
            self.add_batch_files(audio_files)
        else:
            qmessagebox.warning(self, "⚠️ 警告", "文件夹中没有找到支持的音频文件")
    
    def find_audio_files(self, folder):
        supported_formats = ('.wav', '.mp3', '.ogg', '.flac')
        audio_files = []
        for root, _, files in os.walk(folder):
            for file in files:
                if file.lower().endswith(supported_formats):
                    audio_files.append(os.path.join(root, file))
        return audio_files
    
    def handle_dropped_files(self, urls):
        filepaths = [url.tolocalfile() for url in urls if url.islocalfile()]
        
        if not filepaths:
            return
            
        if self.batch_mode:
            # 在批量模式下，处理所有拖放的文件和文件夹
            all_files = []
            for path in filepaths:
                if os.path.isfile(path):
                    if path.lower().endswith(('.wav', '.mp3', '.ogg', '.flac')):
                        all_files.append(path)
                elif os.path.isdir(path):
                    all_files.extend(self.find_audio_files(path))
            
            if all_files:
                self.add_batch_files(all_files)
            else:
                qmessagebox.warning(self, "⚠️ 警告", "没有找到支持的音频文件")
        else:
            # 在非批量模式下，只处理第一个音频文件
            for path in filepaths:
                if os.path.isfile(path) and path.lower().endswith(('.wav', '.mp3', '.ogg', '.flac')):
                    self.load_audio(path)
                    break
                elif os.path.isdir(path):
                    audio_files = self.find_audio_files(path)
                    if audio_files:
                        self.load_audio(audio_files[0])
                        break
            else:
                qmessagebox.warning(self, "⚠️ 警告", "请拖放音频文件 (.wav, .mp3, .ogg, .flac)")
    
    def add_batch_files(self, files):
        new_files = [f for f in files if f not in self.batch_files]
        if new_files:
            self.batch_files.extend(new_files)
            self.update_batch_list()
        else:
            qmessagebox.information(self, "提示", "所有文件已在处理列表中")
    
    def update_batch_list(self):
        count = len(self.batch_files)
        self.batch_list_label.settext(f"待处理文件列表 ({count}):")
        
        if count <= 5:
            file_list = "\n".join(os.path.basename(f) for f in self.batch_files)
        else:
            file_list = "\n".join(os.path.basename(f) for f in self.batch_files[:5]) + f"\n...和其他 {count-5} 个文件"
        
        self.batch_files_text.settext(file_list)
    
    def load_audio(self, filepath):
        try:
            self.progress_bar.setvisible(true)
            self.progress_bar.setrange(0, 0)
            self.status_bar.showmessage("🔄 正在加载音频...")
            qapplication.processevents()
            
            self.audio_data, self.sample_rate = librosa.load(filepath, sr=none)
            self.filename = os.path.basename(filepath)
            self.file_label.settext(f"✅ 已选择: {self.filename}")
            self.save_button.setenabled(false)
            
            self.status_bar.showmessage("🟢 音频加载完成")
        except exception as e:
            qmessagebox.critical(self, "❌ 错误", f"加载音频文件失败: {str(e)}")
            self.status_bar.showmessage("🔴 加载失败")
        finally:
            self.progress_bar.setvisible(false)
    
    def enhanced_reduce_noise(self, y, sr, strength=0.5, stationary=true):
        """增强的降噪算法"""
        try:
            # 第一级：谱减法降噪
            y_denoised = nr.reduce_noise(
                y=y,
                sr=sr,
                stationary=stationary,
                prop_decrease=min(0.95, strength),  # 限制最大降噪强度
                n_fft=2048,
                win_length=2048,
                hop_length=512
            )
            
            # 第二级：butterworth滤波器去除高频噪声
            sos = signal.butter(10, 0.05, 'highpass', fs=sr, output='sos')
            y_filtered = signal.sosfilt(sos, y_denoised)
            
            return y_filtered
        except exception as e:
            print(f"降噪过程中出错: {str(e)}")
            return y
    
    def enhance_voice_volume(self, y, gain=0.0):
        """简单的人声音量增强 (0.0-1.0对应0%-100%增益)"""
        try:
            if gain == 0.0:  # 0%增益时不处理
                return y
            # 增益公式：output = input * (1 + gain)
            return y * (1.0 + gain)
        except exception as e:
            print(f"人声增强过程中出错: {str(e)}")
            return y
    
    def process_audio(self):
        if self.batch_mode:
            self.process_batch()
            return
            
        if self.audio_data is none:
            qmessagebox.warning(self, "⚠️ 警告", "请先选择音频文件")
            return
        
        try:
            # 获取参数
            strength = self.strength_slider.value() / 10.0  # 转换为0.1-1.0范围
            stationary = self.mode_combo.currentindex() == 0
            voice_gain = self.voice_slider.value() / 100.0  # 转换为0.0-1.0范围
            
            self.progress_bar.setvisible(true)
            self.status_bar.showmessage("🔄 正在处理音频...")
            qapplication.processevents()
            
            # 1. 降噪处理
            self.processed_audio = self.enhanced_reduce_noise(
                y=self.audio_data,
                sr=self.sample_rate,
                strength=strength,
                stationary=stationary
            )
            
            # 2. 人声音量增强 (只有gain>0时才处理)
            if voice_gain > 0:
                self.processed_audio = self.enhance_voice_volume(
                    y=self.processed_audio,
                    gain=voice_gain
                )
            
            # 3. 音量归一化
            self.processed_audio = librosa.util.normalize(self.processed_audio)
            
            # 显示波形对比
            self.show_waveform_comparison()
            
            self.save_button.setenabled(true)
            self.status_bar.showmessage("🟢 音频处理完成")
            qmessagebox.information(self, "✅ 完成", "音频处理完成！")
        except exception as e:
            qmessagebox.critical(self, "❌ 错误", f"处理音频时出错: {str(e)}")
            self.status_bar.showmessage("🔴 处理失败")
        finally:
            self.progress_bar.setvisible(false)
    
    def process_batch(self):
        if not self.batch_files:
            qmessagebox.warning(self, "⚠️ 警告", "没有可处理的文件")
            return
            
        # 选择输出目录
        output_dir = qfiledialog.getexistingdirectory(self, "选择输出文件夹")
        if not output_dir:
            return
            
        # 获取参数
        strength = self.strength_slider.value() / 10.0
        stationary = self.mode_combo.currentindex() == 0
        voice_gain = self.voice_slider.value() / 100.0
        
        # 创建批处理器
        self.batch_processor = batchprocessor(
            files=self.batch_files,
            output_dir=output_dir,
            strength=strength,
            stationary=stationary,
            voice_gain=voice_gain
        )
        
        # 连接信号
        self.batch_processor.progress_updated.connect(self.update_batch_progress)
        self.batch_processor.finished.connect(self.batch_complete)
        
        # 禁用ui控件
        self.set_ui_enabled(false)
        self.progress_bar.setvisible(true)
        self.progress_bar.setvalue(0)
        self.status_bar.showmessage("🔄 开始批量处理...")
        
        # 启动处理线程
        self.batch_processor.start()
    
    def update_batch_progress(self, progress, message):
        self.progress_bar.setvalue(progress)
        self.status_bar.showmessage(message)
    
    def batch_complete(self):
        self.set_ui_enabled(true)
        self.progress_bar.setvisible(false)
        self.status_bar.showmessage("🟢 批量处理完成")
        qmessagebox.information(self, "✅ 完成", "批量处理完成！")
    
    def set_ui_enabled(self, enabled):
        self.load_button.setenabled(enabled)
        self.load_folder_button.setenabled(enabled)
        self.process_button.setenabled(enabled)
        self.save_button.setenabled(enabled)
        self.batch_process_button.setenabled(enabled)
        self.strength_slider.setenabled(enabled)
        self.voice_slider.setenabled(enabled)
        self.mode_combo.setenabled(enabled)
        self.batch_checkbox.setenabled(enabled)

    def show_waveform_comparison(self):
        """显示处理前后的波形对比图"""
        plt.rcparams['font.sans-serif'] = ['microsoft yahei']
        plt.rcparams['axes.unicode_minus'] = false
        
        plt.figure(figsize=(12, 6))
        
        # 原始音频波形
        plt.subplot(2, 1, 1)
        librosa.display.waveshow(self.audio_data, sr=self.sample_rate, color='b')
        plt.title("原始音频波形")
        plt.xlabel("时间 (秒)")
        plt.ylabel("振幅")
        
        # 处理后音频波形
        plt.subplot(2, 1, 2)
        librosa.display.waveshow(self.processed_audio, sr=self.sample_rate, color='g')
        plt.title("处理后音频波形 (降噪+人声增强)")
        plt.xlabel("时间 (秒)")
        plt.ylabel("振幅")
        
        plt.tight_layout()
        plt.show()
    
    def save_audio(self):
        if self.processed_audio is none:
            qmessagebox.warning(self, "⚠️ 警告", "没有可保存的处理结果")
            return
        
        save_path, _ = qfiledialog.getsavefilename(
            self, "保存处理后的音频", 
            f"processed_{self.filename}", 
            "wav文件 (*.wav);;所有文件 (*.*)"
        )
        
        if save_path:
            try:
                self.progress_bar.setvisible(true)
                self.status_bar.showmessage("🔄 正在保存音频...")
                qapplication.processevents()
                
                sf.write(save_path, self.processed_audio, self.sample_rate)
                
                self.status_bar.showmessage("🟢 音频保存成功")
                qmessagebox.information(self, "✅ 成功", f"音频已保存到: {save_path}")
            except exception as e:
                qmessagebox.critical(self, "❌ 错误", f"保存音频失败: {str(e)}")
                self.status_bar.showmessage("🔴 保存失败")
            finally:
                self.progress_bar.setvisible(false)

if __name__ == "__main__":
    app = qapplication([])
    # 设置全局字体
    app.setfont(qfont('microsoft yahei'))
    window = audiodenoiserui()
    window.show()
    app.exec_()