from pydub import AudioSegment
import os

def convert_audio_format(input_path, output_format):
    """
    將音頻文件轉(zhuǎn)換為指定格式
    
    Args:
        input_path: 輸入音頻文件路徑
        output_format: 目標(biāo)格式（如'mp3', 'wav', 'ogg', 'flac'等）
    
    Returns:
        輸出文件路徑
    """
    try:
        # 獲取文件名和擴(kuò)展名
        file_name, file_extension = os.path.splitext(input_path)
        file_extension = file_extension.lower().replace('.', '')
        
        # 構(gòu)建輸出路徑
        output_path = f"{file_name}.{output_format}"
        
        # 加載音頻文件
        audio = AudioSegment.from_file(input_path, format=file_extension)
        
        # 導(dǎo)出為目標(biāo)格式
        audio.export(output_path, format=output_format)
        
        print(f"已將 {input_path} 轉(zhuǎn)換為 {output_path}")
        return output_path
    except Exception as e:
        print(f"轉(zhuǎn)換音頻格式時(shí)出錯(cuò): {e}")
        return None

# 使用示例
# convert_audio_format("meeting.mp3", "wav")

import os
from pydub import AudioSegment

def batch_convert_audio(input_folder, output_folder, target_format):
    """
    批量轉(zhuǎn)換文件夾中的音頻文件格式
    
    Args:
        input_folder: 輸入文件夾路徑
        output_folder: 輸出文件夾路徑
        target_format: 目標(biāo)格式（如'mp3', 'wav', 'ogg', 'flac'等）
    """
    # 確保輸出文件夾存在
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # 支持的音頻格式
    supported_formats = ['.mp3', '.wav', '.ogg', '.flac', '.aac', '.m4a', '.wma']
    
    # 遍歷輸入文件夾中的所有文件
    converted_count = 0
    for filename in os.listdir(input_folder):
        input_path = os.path.join(input_folder, filename)
        
        # 檢查是否為文件且擴(kuò)展名在支持列表中
        if os.path.isfile(input_path):
            file_ext = os.path.splitext(filename)[1].lower()
            if file_ext in supported_formats:
                # 構(gòu)建輸出路徑
                output_filename = os.path.splitext(filename)[0] + '.' + target_format
                output_path = os.path.join(output_folder, output_filename)
                
                try:
                    # 加載音頻文件
                    audio = AudioSegment.from_file(input_path, format=file_ext[1:])
                    
                    # 導(dǎo)出為目標(biāo)格式
                    audio.export(output_path, format=target_format)
                    
                    print(f"已轉(zhuǎn)換: {filename} -> {output_filename}")
                    converted_count += 1
                except Exception as e:
                    print(f"轉(zhuǎn)換 {filename} 時(shí)出錯(cuò): {e}")
    
    print(f"批量轉(zhuǎn)換完成，共轉(zhuǎn)換 {converted_count} 個(gè)文件")

# 使用示例
# batch_convert_audio("audio_files", "converted_files", "mp3")

from pydub import AudioSegment

def concatenate_audio_files(audio_paths, output_path):
    """
    將多個(gè)音頻文件拼接成一個(gè)
    
    Args:
        audio_paths: 音頻文件路徑列表
        output_path: 輸出文件路徑
    """
    try:
        # 檢查輸入列表是否為空
        if not audio_paths:
            print("輸入文件列表為空")
            return False
        
        # 加載第一個(gè)音頻文件
        combined = AudioSegment.from_file(audio_paths[0])
        
        # 依次拼接其他文件
        for audio_path in audio_paths[1:]:
            next_segment = AudioSegment.from_file(audio_path)
            combined += next_segment
        
        # 導(dǎo)出拼接后的文件
        combined.export(output_path, format=output_path.split('.')[-1])
        
        print(f"已將 {len(audio_paths)} 個(gè)音頻文件拼接為 {output_path}")
        return True
    except Exception as e:
        print(f"拼接音頻文件時(shí)出錯(cuò): {e}")
        return False

# 使用示例
# concatenate_audio_files(["intro.mp3", "main_content.mp3", "outro.mp3"], "full_episode.mp3")

from pydub import AudioSegment

def trim_audio(input_path, output_path, start_ms, end_ms):
    """
    剪切音頻文件的指定片段
    
    Args:
        input_path: 輸入音頻文件路徑
        output_path: 輸出文件路徑
        start_ms: 開始時(shí)間（毫秒）
        end_ms: 結(jié)束時(shí)間（毫秒）
    """
    try:
        # 加載音頻文件
        audio = AudioSegment.from_file(input_path)
        
        # 檢查時(shí)間范圍是否有效
        if start_ms < 0:
            start_ms = 0
        if end_ms > len(audio):
            end_ms = len(audio)
        if start_ms >= end_ms:
            print("無效的時(shí)間范圍")
            return False
        
        # 剪切指定片段
        trimmed_audio = audio[start_ms:end_ms]
        
        # 導(dǎo)出剪切后的文件
        trimmed_audio.export(output_path, format=output_path.split('.')[-1])
        
        print(f"已剪切 {input_path} 從 {start_ms}ms 到 {end_ms}ms 的片段")
        return True
    except Exception as e:
        print(f"剪切音頻時(shí)出錯(cuò): {e}")
        return False

# 使用示例
# trim_audio("long_recording.mp3", "important_segment.mp3", 60000, 120000)  # 剪切1分鐘到2分鐘的片段

from pydub import AudioSegment

def add_fade_effects(input_path, output_path, fade_in_ms=1000, fade_out_ms=1000):
    """
    為音頻添加淡入淡出效果
    
    Args:
        input_path: 輸入音頻文件路徑
        output_path: 輸出文件路徑
        fade_in_ms: 淡入時(shí)長（毫秒）
        fade_out_ms: 淡出時(shí)長（毫秒）
    """
    try:
        # 加載音頻文件
        audio = AudioSegment.from_file(input_path)
        
        # 應(yīng)用淡入淡出效果
        audio = audio.fade_in(fade_in_ms).fade_out(fade_out_ms)
        
        # 導(dǎo)出處理后的文件
        audio.export(output_path, format=output_path.split('.')[-1])
        
        print(f"已為 {input_path} 添加淡入淡出效果")
        return True
    except Exception as e:
        print(f"添加淡入淡出效果時(shí)出錯(cuò): {e}")
        return False

# 使用示例
# add_fade_effects("music.mp3", "music_with_fade.mp3", 2000, 3000)  # 2秒淡入，3秒淡出

from pydub import AudioSegment

def adjust_volume(input_path, output_path, volume_change_db):
    """
    調(diào)整音頻文件的音量
    
    Args:
        input_path: 輸入音頻文件路徑
        output_path: 輸出文件路徑
        volume_change_db: 音量變化（分貝），正值增加音量，負(fù)值降低音量
    """
    try:
        # 加載音頻文件
        audio = AudioSegment.from_file(input_path)
        
        # 調(diào)整音量
        adjusted_audio = audio + volume_change_db  # 簡單的加減操作即可調(diào)整分貝
        
        # 導(dǎo)出處理后的文件
        adjusted_audio.export(output_path, format=output_path.split('.')[-1])
        
        print(f"已調(diào)整 {input_path} 的音量 {volume_change_db}dB")
        return True
    except Exception as e:
        print(f"調(diào)整音量時(shí)出錯(cuò): {e}")
        return False

# 使用示例
# adjust_volume("quiet_audio.mp3", "louder_audio.mp3", 6)  # 增加6dB音量
# adjust_volume("loud_audio.mp3", "quieter_audio.mp3", -6)  # 降低6dB音量

from pydub import AudioSegment
import numpy as np

def normalize_audio(input_path, output_path, target_dBFS=-20):
    """
    將音頻標(biāo)準(zhǔn)化到指定的分貝全刻度值
    
    Args:
        input_path: 輸入音頻文件路徑
        output_path: 輸出文件路徑
        target_dBFS: 目標(biāo)分貝全刻度值，通常為負(fù)值，如-20dBFS
    """
    try:
        # 加載音頻文件
        audio = AudioSegment.from_file(input_path)
        
        # 計(jì)算當(dāng)前音頻與目標(biāo)音量的差值
        change_in_dBFS = target_dBFS - audio.dBFS
        
        # 應(yīng)用音量變化
        normalized_audio = audio.apply_gain(change_in_dBFS)
        
        # 導(dǎo)出處理后的文件
        normalized_audio.export(output_path, format=output_path.split('.')[-1])
        
        print(f"已將 {input_path} 標(biāo)準(zhǔn)化到 {target_dBFS}dBFS")
        return True
    except Exception as e:
        print(f"標(biāo)準(zhǔn)化音頻時(shí)出錯(cuò): {e}")
        return False

# 使用示例
# normalize_audio("varying_volume.mp3", "normalized_audio.mp3")

import speech_recognition as sr

def speech_to_text(audio_path, language='zh-CN'):
    """
    將語音文件轉(zhuǎn)換為文本
    
    Args:
        audio_path: 音頻文件路徑（最好是WAV格式）
        language: 語言代碼，默認(rèn)為中文
    
    Returns:
        識別出的文本，失敗則返回None
    """
    try:
        # 初始化識別器
        recognizer = sr.Recognizer()
        
        # 加載音頻文件
        with sr.AudioFile(audio_path) as source:
            # 讀取音頻數(shù)據(jù)
            audio_data = recognizer.record(source)
            
            # 使用Google語音識別API
            text = recognizer.recognize_google(audio_data, language=language)
            
            print(f"識別結(jié)果: {text}")
            return text
    except sr.UnknownValueError:
        print("無法識別語音")
        return None
    except sr.RequestError as e:
        print(f"無法請求Google語音識別服務(wù); {e}")
        return None
    except Exception as e:
        print(f"語音識別時(shí)出錯(cuò): {e}")
        return None

# 使用示例
# text = speech_to_text("recording.wav", "zh-CN")
# if text:
#     with open("transcript.txt", "w", encoding="utf-8") as f:
#         f.write(text)

import os
import speech_recognition as sr

def batch_speech_to_text(input_folder, output_folder, language='zh-CN'):
    """
    批量處理文件夾中的音頻文件，將語音轉(zhuǎn)換為文本
    
    Args:
        input_folder: 輸入文件夾路徑
        output_folder: 輸出文件夾路徑（存放文本文件）
        language: 語言代碼，默認(rèn)為中文
    """
    # 確保輸出文件夾存在
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # 支持的音頻格式
    supported_formats = ['.wav']  # SpeechRecognition主要支持WAV格式
    
    # 初始化識別器
    recognizer = sr.Recognizer()
    
    # 遍歷輸入文件夾中的所有文件
    processed_count = 0
    for filename in os.listdir(input_folder):
        input_path = os.path.join(input_folder, filename)
        
        # 檢查是否為文件且擴(kuò)展名在支持列表中
        if os.path.isfile(input_path):
            file_ext = os.path.splitext(filename)[1].lower()
            if file_ext in supported_formats:
                # 構(gòu)建輸出路徑
                output_filename = os.path.splitext(filename)[0] + '.txt'
                output_path = os.path.join(output_folder, output_filename)
                
                try:
                    # 加載音頻文件
                    with sr.AudioFile(input_path) as source:
                        audio_data = recognizer.record(source)
                    
                    # 使用Google語音識別API
                    text = recognizer.recognize_google(audio_data, language=language)
                    
                    # 將識別結(jié)果寫入文本文件
                    with open(output_path, 'w', encoding='utf-8') as f:
                        f.write(text)
                    
                    print(f"已處理: {filename} -> {output_filename}")
                    processed_count += 1
                except Exception as e:
                    print(f"處理 {filename} 時(shí)出錯(cuò): {e}")
    
    print(f"批量處理完成，共處理 {processed_count} 個(gè)文件")

# 使用示例
# batch_speech_to_text("recordings", "transcripts", "zh-CN")

from pydub import AudioSegment
import speech_recognition as sr
import os

def process_meeting_recording(audio_path, output_folder):
    """
    處理會(huì)議錄音：轉(zhuǎn)換格式、分割長錄音、生成文字記錄
    
    Args:
        audio_path: 會(huì)議錄音文件路徑
        output_folder: 輸出文件夾路徑
    """
    # 確保輸出文件夾存在
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # 獲取文件名（不含擴(kuò)展名）
    base_name = os.path.splitext(os.path.basename(audio_path))[0]
    
    try:
        # 1. 加載音頻文件
        print("正在加載音頻文件...")
        meeting_audio = AudioSegment.from_file(audio_path)
        
        # 2. 標(biāo)準(zhǔn)化音量
        print("正在標(biāo)準(zhǔn)化音量...")
        normalized_audio = meeting_audio.apply_gain((-20) - meeting_audio.dBFS)
        
        # 3. 轉(zhuǎn)換為WAV格式（便于語音識別）
        wav_path = os.path.join(output_folder, f"{base_name}.wav")
        print(f"正在轉(zhuǎn)換為WAV格式: {wav_path}")
        normalized_audio.export(wav_path, format="wav")
        
        # 4. 將長錄音分割成10分鐘的片段（便于處理）
        segment_length_ms = 10 * 60 * 1000  # 10分鐘
        segments_folder = os.path.join(output_folder, "segments")
        if not os.path.exists(segments_folder):
            os.makedirs(segments_folder)
        
        print("正在分割錄音...")
        for i, start_ms in enumerate(range(0, len(normalized_audio), segment_length_ms)):
            # 計(jì)算結(jié)束時(shí)間
            end_ms = min(start_ms + segment_length_ms, len(normalized_audio))
            
            # 提取片段
            segment = normalized_audio[start_ms:end_ms]
            
            # 保存片段
            segment_path = os.path.join(segments_folder, f"{base_name}_segment_{i+1}.wav")
            segment.export(segment_path, format="wav")
            print(f"已保存片段 {i+1}: {segment_path}")
        
        # 5. 對每個(gè)片段進(jìn)行語音識別
        transcripts_folder = os.path.join(output_folder, "transcripts")
        if not os.path.exists(transcripts_folder):
            os.makedirs(transcripts_folder)
        
        print("正在進(jìn)行語音識別...")
        recognizer = sr.Recognizer()
        
        full_transcript = ""
        for i, segment_file in enumerate(sorted(os.listdir(segments_folder))):
            if segment_file.endswith(".wav"):
                segment_path = os.path.join(segments_folder, segment_file)
                
                try:
                    # 加載音頻片段
                    with sr.AudioFile(segment_path) as source:
                        audio_data = recognizer.record(source)
                    
                    # 識別語音
                    text = recognizer.recognize_google(audio_data, language="zh-CN")
                    
                    # 添加到完整記錄
                    segment_header = f"\n--- 片段 {i+1} ---\n"
                    full_transcript += segment_header + text + "\n"
                    
                    print(f"已完成片段 {i+1} 的語音識別")
                except Exception as e:
                    print(f"處理片段 {segment_file} 時(shí)出錯(cuò): {e}")
                    full_transcript += f"\n--- 片段 {i+1} (識別失敗) ---\n"
        
        # 6. 保存完整文字記錄
        transcript_path = os.path.join(output_folder, f"{base_name}_transcript.txt")
        with open(transcript_path, "w", encoding="utf-8") as f:
            f.write(full_transcript)
        
        print(f"會(huì)議錄音處理完成，文字記錄已保存至: {transcript_path}")
        return True
    except Exception as e:
        print(f"處理會(huì)議錄音時(shí)出錯(cuò): {e}")
        return False

# 使用示例
# process_meeting_recording("weekly_meeting.mp3", "meeting_output")

from pydub import AudioSegment
from pydub.effects import normalize
import os

def podcast_production_assistant(intro_path, main_content_path, outro_path, background_music_path, output_path):
    """
    播客制作助手：合并片段、添加背景音樂、標(biāo)準(zhǔn)化音量
    
    Args:
        intro_path: 片頭音頻路徑
        main_content_path: 主要內(nèi)容音頻路徑
        outro_path: 片尾音頻路徑
        background_music_path: 背景音樂路徑
        output_path: 輸出文件路徑
    """
    try:
        print("正在加載音頻文件...")
        # 加載所有音頻片段
        intro = AudioSegment.from_file(intro_path)
        main_content = AudioSegment.from_file(main_content_path)
        outro = AudioSegment.from_file(outro_path)
        background_music = AudioSegment.from_file(background_music_path)
        
        # 計(jì)算總時(shí)長
        total_length_ms = len(intro) + len(main_content) + len(outro)
        
        # 如果背景音樂不夠長，則循環(huán)播放
        if len(background_music) < total_length_ms:
            repeats = int(total_length_ms / len(background_music)) + 1
            background_music = background_music * repeats
        
        # 截取所需長度的背景音樂
        background_music = background_music[:total_length_ms]
        
        # 降低背景音樂音量（-20dB）
        background_music = background_music - 20
        
        print("正在處理音頻...")
        # 為片頭添加淡入效果
        intro = intro.fade_in(2000)
        
        # 為片尾添加淡出效果
        outro = outro.fade_out(3000)
        
        # 合并所有片段
        podcast = intro + main_content + outro
        
        # 混合背景音樂
        podcast = podcast.overlay(background_music)
        
        # 標(biāo)準(zhǔn)化音量
        podcast = normalize(podcast)
        
        # 導(dǎo)出最終播客
        print(f"正在導(dǎo)出播客: {output_path}")
        podcast.export(output_path, format=output_path.split('.')[-1])
        
        print("播客制作完成！")
        return True
    except Exception as e:
        print(f"制作播客時(shí)出錯(cuò): {e}")
        return False

# 使用示例
# podcast_production_assistant(
#     "podcast_intro.mp3", 
#     "podcast_content.mp3", 
#     "podcast_outro.mp3", 
#     "background_music.mp3", 
#     "final_podcast.mp3"
# )

import os
import argparse
from pydub import AudioSegment

def batch_audio_processor():
    """
    命令行音頻批量處理工具
    """
    # 創(chuàng)建命令行參數(shù)解析器
    parser = argparse.ArgumentParser(description='音頻批量處理工具')
    parser.add_argument('--input', '-i', required=True, help='輸入文件夾路徑')
    parser.add_argument('--output', '-o', required=True, help='輸出文件夾路徑')
    parser.add_argument('--format', '-f', default='mp3', help='目標(biāo)格式 (mp3, wav, ogg, etc.)')
    parser.add_argument('--normalize', '-n', action='store_true', help='是否標(biāo)準(zhǔn)化音量')
    parser.add_argument('--volume', '-v', type=float, default=0, help='音量調(diào)整（dB）')
    parser.add_argument('--fade-in', type=int, default=0, help='淡入時(shí)長（毫秒）')
    parser.add_argument('--fade-out', type=int, default=0, help='淡出時(shí)長（毫秒）')
    
    # 解析命令行參數(shù)
    args = parser.parse_args()
    
    # 確保輸出文件夾存在
    if not os.path.exists(args.output):
        os.makedirs(args.output)
    
    # 支持的音頻格式
    supported_formats = ['.mp3', '.wav', '.ogg', '.flac', '.aac', '.m4a', '.wma']
    
    # 遍歷輸入文件夾中的所有文件
    processed_count = 0
    for filename in os.listdir(args.input):
        input_path = os.path.join(args.input, filename)
        
        # 檢查是否為文件且擴(kuò)展名在支持列表中
        if os.path.isfile(input_path):
            file_ext = os.path.splitext(filename)[1].lower()
            if file_ext in supported_formats:
                # 構(gòu)建輸出路徑
                output_filename = os.path.splitext(filename)[0] + '.' + args.format
                output_path = os.path.join(args.output, output_filename)
                
                try:
                    print(f"處理: {filename}")
                    # 加載音頻文件
                    audio = AudioSegment.from_file(input_path)
                    
                    # 應(yīng)用處理
                    if args.normalize:
                        # 標(biāo)準(zhǔn)化音量到-20dBFS
                        change_in_dBFS = -20 - audio.dBFS
                        audio = audio.apply_gain(change_in_dBFS)
                        print("  - 已標(biāo)準(zhǔn)化音量")
                    
                    if args.volume != 0:
                        # 調(diào)整音量
                        audio = audio + args.volume
                        print(f"  - 已調(diào)整音量: {args.volume}dB")
                    
                    if args.fade_in > 0:
                        # 添加淡入效果
                        audio = audio.fade_in(args.fade_in)
                        print(f"  - 已添加淡入效果: {args.fade_in}ms")
                    
                    if args.fade_out > 0:
                        # 添加淡出效果
                        audio = audio.fade_out(args.fade_out)
                        print(f"  - 已添加淡出效果: {args.fade_out}ms")
                    
                    # 導(dǎo)出處理后的文件
                    audio.export(output_path, format=args.format)
                    print(f"  - 已保存為: {output_filename}")
                    
                    processed_count += 1
                except Exception as e:
                    print(f"處理 {filename} 時(shí)出錯(cuò): {e}")
    
    print(f"批量處理完成，共處理 {processed_count} 個(gè)文件")

# 如果作為主程序運(yùn)行
if __name__ == "__main__":
    batch_audio_processor()

pip install pydub librosa SpeechRecognition PyAudio ffmpeg-python