├── helper_srt_spacerm.py ├── video-resize.py ├── general_shorts_cut.py ├── CN_mp3_audio2text.py ├── zimu.py ├── zimu_jianti.py ├── cut_900seconds.py └── README.md /helper_srt_spacerm.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | def remove_spaces_newlines(input_file, output_file): 4 | """ 5 | 读取字幕文件，删除所有的空格和换行符，并将结果写为单行输出。 6 | 7 | 功能: 8 | - 删除全角和半角空格 9 | - 删除所有换行符(\n)和回车符(\r) 10 | - 删除空白行 11 | - 将处理后的内容写入单行 12 | 13 | 参数: 14 | input_file (str): 输入字幕文件的路径 15 | output_file (str): 输出字幕文件的路径 16 | 17 | 注意: 18 | - 文件使用UTF-8编码读写 19 | - 建议在处理前备份原始文件 20 | - 处理后的文件将失去原有的格式 21 | """ 22 | 23 | # 以UTF-8编码打开输入文件 24 | with open(input_file, 'r', encoding='utf-8') as f_in: 25 | # 读取整个文件内容到内存 26 | content = f_in.read() 27 | 28 | # 移除半角空格和全角空格 29 | content = content.replace(' ', '') # 移除半角空格 30 | content = content.replace('　', '') # 移除全角空格 31 | 32 | # 移除所有换行符和回车符 33 | content = content.replace('\n', '') # 移除换行符 34 | content = content.replace('\r', '') # 移除回车符 35 | 36 | # 以UTF-8编码写入输出文件 37 | with open(output_file, 'w', encoding='utf-8') as f_out: 38 | # 将处理后的内容写入单行 39 | f_out.write(content) 40 | 41 | if __name__ == '__main__': 42 | # 定义输入和输出文件路径 43 | input_srt = '音频字幕.srt' # 原始字幕文件 44 | output_srt = '音频字幕_nos.srt' # 处理后的文件 45 | 46 | # 调用函数处理文件 47 | remove_spaces_newlines(input_srt, output_srt) 48 | 49 | # 打印完成提示 50 | print("已删除所有空格和回车换行，生成文件：", output_srt) 51 | -------------------------------------------------------------------------------- /video-resize.py: -------------------------------------------------------------------------------- 1 | # 导入所需的库 2 | import subprocess # 用于执行外部命令 3 | import os # 用于文件和目录操作 4 | 5 | def resize_video_for_youtube_shorts(input_file, output_file): 6 | """ 7 | 将视频转换为YouTube Shorts格式(1080x1920)的竖屏视频 8 | 9 | 参数: 10 | input_file (str): 输入视频文件的路径 11 | output_file (str): 输出视频文件的路径 12 | 13 | 处理流程: 14 | 1. 将视频缩放到1080x1920的尺寸 15 | 2. 保持原始视频的宽高比 16 | 3. 在视频周围添加黑边使其居中 17 | 4. 保持原始音频不变 18 | """ 19 | 20 | # 确保输出文件的目录存在,如果不存在则创建 21 | os.makedirs(os.path.dirname(output_file), exist_ok=True) 22 | 23 | # 构建 FFmpeg 命令参数列表 24 | command = [ 25 | 'ffmpeg', # FFmpeg 程序 26 | '-i', input_file, # 输入文件参数 27 | # 视频滤镜参数: 28 | '-vf', 'scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2', 29 | # scale=1080:1920 - 设置目标分辨率 30 | # force_original_aspect_ratio=decrease - 保持原始宽高比,确保视频不会被拉伸 31 | # pad=1080:1920:(ow-iw)/2:(oh-ih)/2 - 添加黑边使视频居中 32 | # (ow-iw)/2:(oh-ih)/2 计算填充边距,使视频在画面中居中 33 | 34 | '-c:a', 'copy', # 复制音频流,不进行重新编码 35 | output_file # 输出文件路径 36 | ] 37 | 38 | # 执行 FFmpeg 命令 39 | try: 40 | # check=True 表示在命令执行失败时抛出异常 41 | subprocess.run(command, check=True) 42 | print(f"视频已成功调整大小并保存为 {output_file}") 43 | except subprocess.CalledProcessError as e: 44 | # 捕获并打印 FFmpeg 执行过程中的错误 45 | print(f"调整视频大小时出错: {e}") 46 | 47 | # 使用示例 48 | input_video = "input.mp4" # 输入视频文件路径 49 | output_video = "output.mp4" # 输出视频文件路径 50 | resize_video_for_youtube_shorts(input_video, output_video) 51 | -------------------------------------------------------------------------------- /general_shorts_cut.py: -------------------------------------------------------------------------------- 1 | # 导入所需的库 2 | from moviepy.editor import VideoFileClip # 导入视频处理库 3 | import os # 导入操作系统接口库 4 | 5 | def split_video(input_video_path, output_folder): 6 | """ 7 | 将输入视频按照59秒为间隔分割成多个片段 8 | 9 | 参数: 10 | input_video_path: 输入视频的路径 11 | output_folder: 分割后视频片段的保存目录 12 | """ 13 | 14 | # 确保输出文件夹存在，如果不存在则创建 15 | if not os.path.exists(output_folder): 16 | os.makedirs(output_folder) 17 | 18 | # 使用VideoFileClip加载视频文件 19 | video = VideoFileClip(input_video_path) 20 | 21 | # 获取视频总时长并计算需要分割的片段数 22 | # 如果视频长度不能被59整除，则多加一个片段 23 | duration = video.duration # 获取视频总时长(秒) 24 | num_clips = int(duration // 59) + (1 if duration % 59 > 0 else 0) 25 | 26 | # 循环处理每个视频片段 27 | for i in range(num_clips): 28 | # 计算当前片段的起始和结束时间 29 | start_time = i * 59 # 每段起始时间 30 | end_time = min((i + 1) * 59, duration) # 每段结束时间，不超过视频总长度 31 | 32 | # 从原视频中提取指定时间段的片段 33 | clip = video.subclip(start_time, end_time) 34 | 35 | # 生成输出文件名，格式为"clip_001.mp4"这样的形式 36 | output_filename = f"clip_{i+1:03d}.mp4" # 使用3位数字进行编号 37 | output_path = os.path.join(output_folder, output_filename) 38 | 39 | # 将视频片段保存到文件 40 | # codec指定视频编码格式为H.264 41 | # audio_codec指定音频编码格式为AAC 42 | clip.write_videofile(output_path, codec="libx264", audio_codec="aac") 43 | 44 | # 打印进度信息 45 | print(f"已生成片段 {i+1}/{num_clips}: {output_filename}") 46 | 47 | # 处理完成后关闭视频文件，释放资源 48 | video.close() 49 | 50 | # 打印完成信息 51 | print(f"视频分割完成。共生成 {num_clips} 个片段。") 52 | 53 | # 使用示例 54 | input_video = "sample_video.mp4" # 输入视频文件路径 55 | output_folder = "video_shorts_clips" # 输出文件夹路径 56 | 57 | # 调用函数进行视频分割 58 | split_video(input_video, output_folder) 59 | -------------------------------------------------------------------------------- /CN_mp3_audio2text.py: -------------------------------------------------------------------------------- 1 | from faster_whisper import WhisperModel 2 | from pydub import AudioSegment 3 | import numpy as np 4 | import time 5 | import os 6 | 7 | def transcribe_audio(audio_file_path, output_file_path, language="zh"): 8 | print(f"开始处理音频文件: {audio_file_path}") 9 | start_time = time.time() 10 | 11 | # 假设输入文件为 MP3 格式 12 | print("正在加载Whisper模型...") 13 | model = WhisperModel("large-v2", device="cpu", compute_type="int8") 14 | print(f"模型加载完成，用时 {time.time() - start_time:.2f} 秒") 15 | 16 | print("正在加载音频文件...") 17 | audio = AudioSegment.from_file(audio_file_path, format="mp3") 18 | audio = audio.set_channels(1).set_frame_rate(16000) 19 | print(f"音频加载完成，音频长度: {len(audio) / 1000:.2f} 秒") 20 | 21 | print("正在将音频转换为numpy数组...") 22 | audio_numpy = np.array(audio.get_array_of_samples()).astype(np.float32) / 32768.0 23 | print("转换完成") 24 | 25 | print("开始转录音频...") 26 | transcribe_start = time.time() 27 | segments, info = model.transcribe(audio_numpy, language=language) 28 | 29 | print("正在收集转录结果...") 30 | transcription = "" 31 | for segment in segments: 32 | transcription += segment.text + " " 33 | print(f"已处理 {segment.end:.2f} 秒 / {len(audio) / 1000:.2f} 秒") 34 | 35 | print(f"转录完成，用时 {time.time() - transcribe_start:.2f} 秒") 36 | 37 | print(f"正在保存转录结果到文件: {output_file_path}") 38 | with open(output_file_path, 'w', encoding='utf-8') as f: 39 | f.write(transcription) 40 | print("保存完成") 41 | 42 | total_time = time.time() - start_time 43 | print(f"全部处理完成，总用时 {total_time:.2f} 秒") 44 | 45 | return transcription 46 | 47 | # 使用示例 48 | audio_file = "文件地址.mp3" # 替换为你的 mp3 文件路径 49 | output_file = "文件地址.txt" # 替换为你的输出文本文件路径 50 | 51 | result = transcribe_audio(audio_file, output_file, language="zh") 52 | print(f"转录结果已保存到: {output_file}") 53 | print("转录结果的前500个字符:", result[:500]) 54 | -------------------------------------------------------------------------------- /zimu.py: -------------------------------------------------------------------------------- 1 | from faster_whisper import WhisperModel 2 | from pydub import AudioSegment 3 | import numpy as np 4 | import time 5 | 6 | def seconds_to_srt_timestamp(seconds: float) -> str: 7 | """ 8 | 将秒数转换为 SRT 时间戳格式（HH:MM:SS,mmm） 9 | 例如：3.456秒 -> "00:00:03,456" 10 | """ 11 | hours = int(seconds // 3600) 12 | minutes = int((seconds % 3600) // 60) 13 | secs = int(seconds % 60) 14 | millis = int((seconds - int(seconds)) * 1000) 15 | return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}" 16 | 17 | def transcribe_audio_to_srt(audio_file_path: str, output_srt_path: str, language="zh"): 18 | """ 19 | 将音频文件转录为带有时间戳的 SRT 字幕文件。 20 | 输出格式示例： 21 | 1 22 | 00:00:24,400 --> 00:00:25,200 23 | 烟雨 24 | 25 | :param audio_file_path: 音频文件路径（如 mp3） 26 | :param output_srt_path: 输出字幕文件路径（.srt） 27 | :param language: 语言代码（默认为中文 "zh"） 28 | """ 29 | print(f"开始处理音频文件: {audio_file_path}") 30 | start_time = time.time() 31 | 32 | # 1) 加载 WhisperModel 33 | print("正在加载Whisper模型...") 34 | model = WhisperModel("large-v2", device="cpu", compute_type="int8") 35 | print(f"模型加载完成，用时 {time.time() - start_time:.2f} 秒") 36 | 37 | # 2) 加载并预处理音频 38 | print("正在加载音频文件...") 39 | audio = AudioSegment.from_file(audio_file_path, format="mp3") 40 | audio = audio.set_channels(1).set_frame_rate(16000) 41 | print(f"音频加载完成，音频长度: {len(audio) / 1000:.2f} 秒") 42 | 43 | # 3) 转为 NumPy 数组 44 | print("正在将音频转换为 numpy 数组...") 45 | audio_numpy = np.array(audio.get_array_of_samples()).astype(np.float32) / 32768.0 46 | print("转换完成") 47 | 48 | # 4) 开始转录 49 | print("开始转录音频...") 50 | transcribe_start = time.time() 51 | segments, info = model.transcribe(audio_numpy, language=language) 52 | print(f"转录完成，用时 {time.time() - transcribe_start:.2f} 秒") 53 | 54 | # 5) 生成 SRT 内容 55 | print("正在生成字幕文件...") 56 | srt_lines = [] 57 | for idx, segment in enumerate(segments, start=1): 58 | # 生成 SRT 时间戳 59 | start_srt_time = seconds_to_srt_timestamp(segment.start) 60 | end_srt_time = seconds_to_srt_timestamp(segment.end) 61 | 62 | # 序号 63 | srt_lines.append(str(idx)) 64 | # 时间轴 65 | srt_lines.append(f"{start_srt_time} --> {end_srt_time}") 66 | # 文本内容（去除首尾空格） 67 | srt_lines.append(segment.text.strip()) 68 | # 空行分隔 69 | srt_lines.append("") 70 | 71 | # 打印进度 72 | print(f"片段 {idx}: {segment.start:.2f}s --> {segment.end:.2f}s") 73 | 74 | # 6) 写入 .srt 文件 75 | with open(output_srt_path, "w", encoding="utf-8") as f: 76 | f.write("\n".join(srt_lines)) 77 | 78 | total_time = time.time() - start_time 79 | print(f"字幕文件已生成: {output_srt_path}") 80 | print(f"全部处理完成，总用时 {total_time:.2f} 秒") 81 | 82 | return output_srt_path 83 | 84 | # 使用示例 85 | if __name__ == "__main__": 86 | audio_file = "文档.mp3" # 替换为你的音频文件路径 87 | output_srt = "文档.srt" # 替换为你要输出的字幕文件名称 88 | result_srt_path = transcribe_audio_to_srt(audio_file, output_srt, language="zh") 89 | print(f"转录字幕文件已保存到: {result_srt_path}") 90 | -------------------------------------------------------------------------------- /zimu_jianti.py: -------------------------------------------------------------------------------- 1 | from faster_whisper import WhisperModel 2 | from pydub import AudioSegment 3 | import numpy as np 4 | import time 5 | import opencc 6 | 7 | def seconds_to_srt_timestamp(seconds: float) -> str: 8 | """ 9 | 将秒数转换为 SRT 时间戳格式（HH:MM:SS,mmm） 10 | 例如：3.456秒 -> "00:00:03,456" 11 | """ 12 | hours = int(seconds // 3600) 13 | minutes = int((seconds % 3600) // 60) 14 | secs = int(seconds % 60) 15 | millis = int((seconds - int(seconds)) * 1000) 16 | return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}" 17 | 18 | def transcribe_audio_to_srt(audio_file_path: str, output_srt_path: str, language="zh", to_simplified=True): 19 | """ 20 | 将音频文件转录为带有时间戳的简体中文 SRT 字幕文件。 21 | 22 | :param audio_file_path: 音频文件路径（如 mp3） 23 | :param output_srt_path: 输出字幕文件路径（.srt） 24 | :param language: 语言代码（默认为中文 "zh"） 25 | :param to_simplified: 是否转换为简体中文（默认为 True） 26 | """ 27 | print(f"开始处理音频文件: {audio_file_path}") 28 | start_time = time.time() 29 | 30 | # 1) 初始化繁简转换器 31 | if to_simplified: 32 | converter = opencc.OpenCC('t2s') # 繁体转简体 33 | 34 | # 2) 加载 WhisperModel 35 | print("正在加载Whisper模型...") 36 | # 使用 large-v3 模型以获得更好的中文识别效果 37 | model = WhisperModel("large-v3", device="cpu", compute_type="int8") 38 | print(f"模型加载完成，用时 {time.time() - start_time:.2f} 秒") 39 | 40 | # 3) 加载并预处理音频 41 | print("正在加载音频文件...") 42 | audio = AudioSegment.from_file(audio_file_path) 43 | audio = audio.set_channels(1).set_frame_rate(16000) 44 | print(f"音频加载完成，音频长度: {len(audio) / 1000:.2f} 秒") 45 | 46 | # 4) 转为 NumPy 数组 47 | print("正在将音频转换为 numpy 数组...") 48 | audio_numpy = np.array(audio.get_array_of_samples()).astype(np.float32) / 32768.0 49 | print("转换完成") 50 | 51 | # 5) 开始转录 52 | print("开始转录音频...") 53 | transcribe_start = time.time() 54 | # 增加中文相关参数配置 55 | segments, info = model.transcribe( 56 | audio_numpy, 57 | language=language, 58 | task="transcribe", 59 | beam_size=5, 60 | best_of=5, 61 | temperature=0.0, # 降低随机性 62 | condition_on_previous_text=True, # 考虑上下文 63 | vad_filter=True, # 使用语音活动检测 64 | vad_parameters=dict(min_silence_duration_ms=500) # 调整静音检测参数 65 | ) 66 | print(f"转录完成，用时 {time.time() - transcribe_start:.2f} 秒") 67 | 68 | # 6) 生成 SRT 内容 69 | print("正在生成字幕文件...") 70 | srt_lines = [] 71 | for idx, segment in enumerate(segments, start=1): 72 | # 生成 SRT 时间戳 73 | start_srt_time = seconds_to_srt_timestamp(segment.start) 74 | end_srt_time = seconds_to_srt_timestamp(segment.end) 75 | 76 | # 获取文本并转换为简体中文（如果需要） 77 | text = segment.text.strip() 78 | if to_simplified: 79 | text = converter.convert(text) 80 | 81 | # 序号 82 | srt_lines.append(str(idx)) 83 | # 时间轴 84 | srt_lines.append(f"{start_srt_time} --> {end_srt_time}") 85 | # 文本内容 86 | srt_lines.append(text) 87 | # 空行分隔 88 | srt_lines.append("") 89 | # 打印进度 90 | print(f"片段 {idx}: {segment.start:.2f}s --> {segment.end:.2f}s") 91 | 92 | # 7) 写入 .srt 文件 93 | with open(output_srt_path, "w", encoding="utf-8") as f: 94 | f.write("\n".join(srt_lines)) 95 | 96 | total_time = time.time() - start_time 97 | print(f"字幕文件已生成: {output_srt_path}") 98 | print(f"全部处理完成，总用时 {total_time:.2f} 秒") 99 | return output_srt_path 100 | 101 | # 使用示例 102 | if __name__ == "__main__": 103 | audio_file = "简体.mp3" # 替换为你的音频文件路径 104 | output_srt = "简体.srt" # 替换为你要输出的字幕文件名称 105 | result_srt_path = transcribe_audio_to_srt( 106 | audio_file, 107 | output_srt, 108 | language="zh", 109 | to_simplified=True # 设置为 True 输出简体中文，False 则保持原始输出 110 | ) 111 | print(f"转录字幕文件已保存到: {result_srt_path}") 112 | -------------------------------------------------------------------------------- /cut_900seconds.py: -------------------------------------------------------------------------------- 1 | from moviepy.editor import VideoFileClip 2 | import os 3 | import sys 4 | from moviepy.config import get_setting 5 | import subprocess 6 | 7 | def get_ffmpeg_path(): 8 | """获取 ffmpeg 路径""" 9 | return get_setting("FFMPEG_BINARY") 10 | 11 | def check_ffmpeg(): 12 | """检查 ffmpeg 是否正确安装""" 13 | try: 14 | subprocess.run([get_ffmpeg_path(), "-version"], 15 | stdout=subprocess.PIPE, 16 | stderr=subprocess.PIPE) 17 | return True 18 | except Exception as e: 19 | print(f"FFMPEG 检查失败: {str(e)}") 20 | return False 21 | 22 | def split_video(input_video_path, output_folder): 23 | # 检查输入文件是否存在 24 | if not os.path.exists(input_video_path): 25 | raise FileNotFoundError(f"找不到输入视频文件: {input_video_path}") 26 | 27 | # 确保输出文件夹存在 28 | if not os.path.exists(output_folder): 29 | os.makedirs(output_folder) 30 | 31 | # 检查 ffmpeg 32 | if not check_ffmpeg(): 33 | print("请确保已正确安装 ffmpeg") 34 | return 35 | 36 | video = None 37 | try: 38 | # 加载视频 39 | print("正在加载视频文件...") 40 | video = VideoFileClip(input_video_path) 41 | 42 | # 检查视频是否正确加载 43 | if video.reader is None: 44 | raise ValueError("视频文件无法正确加载") 45 | 46 | # 计算需要分割的片段数 (15分钟 = 900秒) 47 | duration = video.duration 48 | segment_duration = 900 # 15分钟 49 | num_clips = int(duration // segment_duration) + (1 if duration % segment_duration > 0 else 0) 50 | 51 | print(f"视频总时长: {duration:.2f} 秒") 52 | print(f"将分割成 {num_clips} 个片段") 53 | 54 | for i in range(num_clips): 55 | start_time = i * segment_duration 56 | end_time = min((i + 1) * segment_duration, duration) 57 | 58 | # 提取片段 59 | print(f"\n开始处理片段 {i+1}/{num_clips}") 60 | print(f"时间范围: {start_time:.2f}s - {end_time:.2f}s") 61 | 62 | # 生成输出文件名 63 | start_minutes = int(start_time // 60) 64 | end_minutes = int(end_time // 60) 65 | output_filename = f"clip_{i+1:03d}_{start_minutes:02d}min-{end_minutes:02d}min.mp4" 66 | output_path = os.path.join(output_folder, output_filename) 67 | 68 | print(f"正在导出: {output_filename}") 69 | 70 | try: 71 | # 使用 ffmpeg 直接切割视频 72 | ffmpeg_cmd = [ 73 | get_ffmpeg_path(), 74 | "-i", input_video_path, 75 | "-ss", str(start_time), 76 | "-t", str(end_time - start_time), 77 | "-c:v", "libx264", 78 | "-c:a", "aac", 79 | "-avoid_negative_ts", "1", 80 | output_path, 81 | "-y" # 覆盖现有文件 82 | ] 83 | 84 | # 执行 ffmpeg 命令 85 | process = subprocess.run( 86 | ffmpeg_cmd, 87 | stdout=subprocess.PIPE, 88 | stderr=subprocess.PIPE, 89 | text=True 90 | ) 91 | 92 | if process.returncode != 0: 93 | print(f"片段导出失败，错误信息：{process.stderr}") 94 | continue 95 | 96 | print(f"片段 {i+1}/{num_clips} 导出完成") 97 | 98 | except Exception as e: 99 | print(f"导出片段时出错: {str(e)}") 100 | continue 101 | 102 | print("\n所有片段处理完成！") 103 | 104 | except Exception as e: 105 | print(f"处理过程中出现错误: {str(e)}") 106 | print("错误详情:", sys.exc_info()[2]) 107 | 108 | finally: 109 | # 确保视频文件被正确关闭 110 | if video is not None: 111 | video.close() 112 | 113 | if __name__ == "__main__": 114 | # 使用示例 115 | input_video = "input.mp4" # 替换为你的视频文件路径 116 | output_folder = "output_clips" # 替换为你想要保存片段的文件夹路径 117 | 118 | split_video(input_video, output_folder) 119 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # youtube 2 | YouTube video processing scripts 3 | 4 | 脚本 1: CN_mp3_audio2text.py 5 | 这段代码的功能和安装步骤。 6 | 7 | **代码功能概述：** 8 | 这是一个音频转文字的程序，主要功能是将 MP3 音频文件转换为文本。具体来说： 9 | 1. 加载 Whisper 大型语音识别模型 10 | 2. 读取并预处理 MP3 音频文件（转换为单声道、16kHz采样率） 11 | 3. 将音频数据转换为模型可处理的格式 12 | 4. 执行语音识别，生成文本 13 | 5. 将转录结果保存到文件 14 | 6. 提供详细的处理进度和时间统计 15 | 16 | **安装步骤：** 17 | 1. 首先确保安装了 Python（推荐 3.8 或更高版本） 18 | 19 | 2. 创建并激活虚拟环境（推荐）： 20 | ```bash 21 | # 创建虚拟环境 22 | python -m venv venv 23 | 24 | # 激活虚拟环境 25 | # Windows: 26 | venv\Scripts\activate 27 | # Linux/Mac: 28 | source venv/bin/activate 29 | ``` 30 | 3. 安装所需依赖： 31 | ```bash 32 | # 安装基础依赖 33 | pip install faster-whisper 34 | pip install pydub 35 | pip install numpy 36 | 37 | # 如果处理 MP3 文件，还需要安装 ffmpeg 38 | # Windows: 39 | # 下载 ffmpeg: https://www.gyan.dev/ffmpeg/builds/ 40 | # 添加到系统环境变量 41 | 42 | # Linux: 43 | sudo apt-get install ffmpeg 44 | 45 | # Mac: 46 | brew install ffmpeg 47 | ``` 48 | **使用示例：** 49 | ```python 50 | # 导入函数 51 | from your_script import transcribe_audio 52 | 53 | # 调用函数进行转录 54 | result = transcribe_audio( 55 | audio_file_path="你的音频文件.mp3", 56 | output_file_path="输出文本.txt", 57 | language="zh" # 支持的语言代码，如 zh=中文, en=英文 58 | ) 59 | ``` 60 | **注意事项：** 61 | 1. 代码使用 CPU 进行计算（`device="cpu"`），如果有 GPU 可以修改为 `device="cuda"` 62 | 2. 使用了 `large-v2` 模型，需要较大内存，如果内存不足可以换用较小的模型 63 | 3. 使用了 `int8` 量化（`compute_type="int8"`）来减少内存占用 64 | 4. 程序会显示详细的处理进度，方便监控长音频的转录进度 65 | 66 | 脚本 2： zimu.py 67 | 我来帮你总结这段代码的功能和安装步骤。 68 | 69 | **代码功能概述：** 70 | 这是一个音频转字幕的程序，它可以将音频文件转换为标准的 SRT 格式字幕文件。主要功能包括： 71 | 1. 将音频时间点转换为 SRT 时间戳格式（如：00:00:03,456） 72 | 2. 加载 Whisper 语音识别模型 73 | 3. 处理和转换音频文件（转单声道、16kHz采样率） 74 | 4. 执行语音识别，获取带时间戳的文本片段 75 | 5. 生成标准 SRT 格式字幕文件（包含序号、时间轴、文本内容） 76 | 6. 提供详细的处理进度和时间统计 77 | 78 | **安装步骤：** 79 | 80 | 1. 确保安装了 Python（推荐 3.8 或更高版本） 81 | 82 | 2. 创建并激活虚拟环境（推荐）： 83 | ```bash 84 | # 创建虚拟环境 85 | python -m venv venv 86 | 87 | # 激活虚拟环境 88 | # Windows: 89 | venv\Scripts\activate 90 | # Linux/Mac: 91 | source venv/bin/activate 92 | ``` 93 | 94 | 3. 安装所需依赖： 95 | ```bash 96 | # 安装基础依赖 97 | pip install faster-whisper 98 | pip install pydub 99 | pip install numpy 100 | 101 | # 安装 ffmpeg（处理音频文件必需） 102 | # Windows: 103 | # 1. 下载 ffmpeg: https://www.gyan.dev/ffmpeg/builds/ 104 | # 2. 解压并添加到系统环境变量 105 | 106 | # Linux: 107 | sudo apt-get install ffmpeg 108 | 109 | # Mac: 110 | brew install ffmpeg 111 | ``` 112 | 113 | **使用示例：** 114 | ```python 115 | # 导入函数 116 | from your_script import transcribe_audio_to_srt 117 | 118 | # 调用函数生成字幕 119 | result = transcribe_audio_to_srt( 120 | audio_file_path="你的音频.mp3", 121 | output_srt_path="输出字幕.srt", 122 | language="zh" # 支持的语言代码，如 zh=中文, en=英文 123 | ) 124 | ``` 125 | 126 | **生成的 SRT 格式示例：** 127 | ``` 128 | 1 129 | 00:00:00,000 --> 00:00:02,500 130 | 第一段文字 131 | 132 | 2 133 | 00:00:02,500 --> 00:00:05,000 134 | 第二段文字 135 | ``` 136 | 137 | **注意事项：** 138 | 1. 代码使用 CPU 进行计算，可通过修改 `device="cuda"` 启用 GPU 加速 139 | 2. 使用了 `large-v2` 模型，需要较大内存，可以根据需要选择较小的模型 140 | 3. 使用了 `int8` 量化以减少内存占用 141 | 4. 输出的 SRT 文件采用 UTF-8 编码，兼容大多数播放器 142 | 5. 程序会显示详细的处理进度，方便监控长音频的转录进度 143 | 144 | 脚本 3： video-resize.py 145 | 146 | **代码功能概述：** 147 | 这是一个视频分辨率转换工具，专门用于将普通视频转换为适合 YouTube Shorts 的垂直视频格式（1080x1920）。主要功能： 148 | 1. 自动创建输出目录（如果不存在） 149 | 2. 调整视频分辨率到 1080x1920 150 | 3. 保持原始视频的宽高比 151 | 4. 用黑边填充空白区域（居中处理） 152 | 5. 保持原始音频质量不变 153 | 154 | **安装步骤：** 155 | 156 | 1. 确保安装了 Python（推荐 3.6 或更高版本） 157 | 158 | 2. 安装 FFmpeg 159 | ```bash 160 | # Windows: 161 | # 1. 下载 FFmpeg: https://www.gyan.dev/ffmpeg/builds/ 162 | # 2. 解压并将 bin 目录添加到系统环境变量 163 | 164 | # Linux: 165 | sudo apt update 166 | sudo apt install ffmpeg 167 | 168 | # Mac: 169 | brew install ffmpeg 170 | ``` 171 | 172 | 3. 验证安装 173 | ```bash 174 | # 在终端/命令行中验证 FFmpeg 是否安装成功 175 | ffmpeg -version 176 | ``` 177 | 178 | **使用示例：** 179 | ```python 180 | # 导入函数 181 | from video_converter import resize_video_for_youtube_shorts 182 | 183 | # 转换视频 184 | resize_video_for_youtube_shorts( 185 | input_file="原始视频.mp4", 186 | output_file="shorts版本.mp4" 187 | ) 188 | ``` 189 | 190 | **参数说明：** 191 | - `input_file`: 输入视频文件路径 192 | - `output_file`: 输出视频文件路径 193 | - 输出视频尺寸: 1080x1920 像素（适合 YouTube Shorts） 194 | - 处理方式： 195 | - 保持原始视频比例 196 | - 自动添加黑边填充 197 | - 视频居中显示 198 | - 保持原始音频质量 199 | 200 | **注意事项：** 201 | 1. 确保系统已正确安装 FFmpeg 并添加到环境变量 202 | 2. 输入视频可以是任何 FFmpeg 支持的格式 203 | 3. 如果输出目录不存在，程序会自动创建 204 | 4. 代码会保持原始音频流（`-c:a copy`），这样可以加快处理速度 205 | 5. 如果转换过程出错，会打印详细的错误信息 206 | 207 | **可能的报错处理：** 208 | - 如果遇到 "FFmpeg not found" 错误，请检查 FFmpeg 是否正确安装并添加到环境变量 209 | - 如果遇到权限错误，请确保对输出目录有写入权限 210 | - 如果输入文件不存在，会提示相应的错误信息 211 | 212 | 脚本 4： helper_srt_spacerm.py 213 | 让我来总结这个字幕处理工具的功能和使用方法。 214 | 215 | **功能概述：** 216 | 这是一个字幕文本处理工具，主要用于： 217 | 1. 删除字幕文件中的所有空格（包括半角和全角空格） 218 | 2. 删除所有换行符和回车符 219 | 3. 将所有文本内容合并为单行输出 220 | 4. 删除所有空白行 221 | 5. 保持 UTF-8 编码 222 | 223 | **使用方法：** 224 | 225 | 1. 安装要求： 226 | ```bash 227 | # 只需要 Python 3.x 版本，不需要额外安装任何库 228 | python --version # 检查 Python 版本 229 | ``` 230 | 231 | 2. 代码使用： 232 | ```python 233 | # 方法一：直接运行脚本 234 | python script.py # 脚本会处理默认的 '音频字幕.srt' 文件 235 | 236 | # 方法二：在其他代码中导入使用 237 | from script import remove_spaces_newlines 238 | 239 | # 处理自定义文件 240 | remove_spaces_newlines( 241 | input_file='你的字幕文件.srt', 242 | output_file='输出文件.srt' 243 | ) 244 | ``` 245 | 246 | **注意事项：** 247 | 1. 处理前建议备份原始文件，因为处理后将丢失原有格式 248 | 2. 确保输入文件为 UTF-8 编码 249 | 3. 输出文件会自动以 UTF-8 编码保存 250 | 4. 处理后的文件会失去原有的换行和格式，全部内容将在一行显示 251 | 5. 如果输出文件已存在，会被覆盖 252 | 253 | **适用场景：** 254 | - 需要对字幕文本进行文本分析时 255 | - 需要提取纯文本内容时 256 | - 需要合并多行文本为单行时 257 | - 处理含有多余空格的字幕文件时 258 | 259 | **输入输出示例：** 260 | ``` 261 | 输入文件内容： 262 | 这是第一行 内容 263 | 这是第二行 内容 264 | 这是第三行 265 | 266 | 输出文件内容： 267 | 这是第一行内容这是第二行内容这是第三行 268 | ``` 269 | 270 | 脚本5：general_shorts_cut.py 271 | # Video Splitter 272 | 273 | 一个简单但功能强大的视频分割工具，可以将长视频自动分割成59秒的短片段。这个工具特别适合需要将视频内容切分成短视频的场景，比如准备短视频平台的内容。 274 | 275 | ## 功能特点 276 | 277 | - 自动将视频分割成59秒的片段 278 | - 保持原视频的质量 279 | - 自动创建输出目录 280 | - 使用H.264视频编码和AAC音频编码 281 | - 显示处理进度 282 | - 自动对输出文件进行编号 283 | 284 | ## 环境要求 285 | 286 | - Python 3.6+ 287 | - moviepy 288 | - ffmpeg 289 | 290 | ## 安装步骤 291 | 292 | 1. 首先确保您的系统已安装Python 3.6或更高版本。 293 | 294 | 2. 安装必要的Python包： 295 | ```bash 296 | pip install moviepy 297 | ``` 298 | 299 | 3. 安装ffmpeg（moviepy的依赖）： 300 | 301 | - Windows用户： 302 | ```bash 303 | # 使用Chocolatey包管理器 304 | choco install ffmpeg 305 | ``` 306 | 307 | - Mac用户： 308 | ```bash 309 | # 使用Homebrew包管理器 310 | brew install ffmpeg 311 | ``` 312 | 313 | - Linux用户： 314 | ```bash 315 | # Ubuntu/Debian 316 | sudo apt-get install ffmpeg 317 | 318 | # CentOS 319 | sudo yum install ffmpeg 320 | ``` 321 | 322 | 4. 下载项目文件： 323 | ```bash 324 | git clone [你的项目地址] 325 | cd video-splitter 326 | ``` 327 | 328 | ## 使用方法 329 | 330 | 1. 打开`split_video.py`文件，修改以下参数： 331 | ```python 332 | input_video = "你的视频文件路径.mp4" # 修改为您的输入视频路径 333 | output_folder = "输出文件夹路径" # 修改为您想要保存分割视频的文件夹路径 334 | ``` 335 | 336 | 2. 运行脚本： 337 | ```bash 338 | python split_video.py 339 | ``` 340 | 341 | 3. 等待处理完成，分割后的视频片段将保存在指定的输出文件夹中。 342 | 343 | ## 输出格式 344 | 345 | - 输出的视频文件将按照 `clip_001.mp4`, `clip_002.mp4`, ... 的格式命名 346 | - 每个片段最长59秒 347 | - 视频编码：H.264 348 | - 音频编码：AAC 349 | 350 | ## 注意事项 351 | 352 | - 确保有足够的磁盘空间存储分割后的视频片段 353 | - 处理大型视频文件时可能需要较长时间 354 | - 建议在处理重要视频前先备份原始文件 355 | - 确保对输入视频文件和输出目录有正确的读写权限 356 | 357 | ## 常见问题解决 358 | 359 | 1. 如果遇到ffmpeg相关错误，请确保： 360 | - ffmpeg已正确安装 361 | - ffmpeg可以在命令行中访问（已添加到系统PATH） 362 | 363 | 2. 如果出现内存错误，可以尝试： 364 | - 关闭其他占用内存的程序 365 | - 处理较小的视频文件 366 | - 增加系统的虚拟内存 367 | 368 | 脚本 6：zimu_jianti.py 生成简体字的字幕 369 | 370 | # 音频转字幕工具说明文档 371 | 372 | ## 功能简介 373 | 374 | 这是一个基于 Faster Whisper 的音频转写工具，可以将音频文件转换为带时间戳的 SRT 格式字幕文件。主要特点： 375 | 376 | - 支持多种音频格式转换为 SRT 字幕 377 | - 支持中文语音识别 378 | - 支持繁体转简体中文 379 | - 提供详细的转换进度提示 380 | - 使用 Whisper large-v3 模型保证准确率 381 | 382 | ## 环境要求 383 | 384 | 使用前需要安装以下 Python 包： 385 | 386 | ```bash 387 | pip install faster-whisper 388 | pip install pydub 389 | pip install numpy 390 | pip install opencc-python-reimplemented 391 | ``` 392 | 393 | ## 使用方法 394 | 395 | ### 基础用法 396 | 397 | ```python 398 | from audio_transcribe import transcribe_audio_to_srt 399 | 400 | # 基本调用方式 401 | transcribe_audio_to_srt( 402 | audio_file_path="input.mp3", # 输入音频文件路径 403 | output_srt_path="output.srt", # 输出字幕文件路径 404 | language="zh", # 音频语言（默认中文） 405 | to_simplified=True # 是否转换为简体中文 406 | ) 407 | ``` 408 | 409 | ### 参数说明 410 | 411 | - `audio_file_path`：输入音频文件路径，支持多种格式（mp3、wav 等） 412 | - `output_srt_path`：输出 SRT 字幕文件的保存路径 413 | - `language`：音频语言代码，默认为 "zh"（中文） 414 | - `to_simplified`：是否将输出转换为简体中文，默认为 True 415 | 416 | ## 功能详解 417 | 418 | 1. **音频预处理** 419 | - 自动将音频转换为单声道 420 | - 采样率设置为 16kHz 421 | - 支持多种音频格式输入 422 | 423 | 2. **语音识别优化** 424 | - 使用 large-v3 模型提高识别准确率 425 | - 启用语音活动检测（VAD） 426 | - 配置上下文关联以提高准确性 427 | - 通过参数配置减少随机性 428 | 429 | 3. **字幕生成** 430 | - 自动生成序号编号 431 | - 精确的时间戳标记 432 | - 支持繁简中文转换 433 | - 标准 SRT 格式输出 434 | 435 | ## 输出示例 436 | 437 | ``` 438 | 1 439 | 00:00:00,000 --> 00:00:02,500 440 | 这是第一句话的内容 441 | 442 | 2 443 | 00:00:02,500 --> 00:00:05,000 444 | 这是第二句话的内容 445 | ``` 446 | 447 | ## 进度显示 448 | 449 | 脚本执行过程中会显示详细的进度信息： 450 | 451 | - 音频文件加载进度 452 | - 模型加载状态 453 | - 转录进度和时间戳 454 | - 总体处理时间统计 455 | 456 | ## 注意事项 457 | 458 | 1. 首次运行时会自动下载 Whisper 模型，需要稳定的网络连接 459 | 2. 处理长音频文件时可能需要较长时间 460 | 3. 建议使用高质量的音频输入以获得更好的识别效果 461 | 4. 确保系统有足够的存储空间和内存 462 | 463 | ## 错误处理 464 | 465 | 如果遇到问题，请检查： 466 | 467 | - 所有依赖包是否正确安装 468 | - 输入音频文件是否存在且格式正确 469 | - 系统是否有足够的存储空间 470 | - 网络连接是否正常（首次运行需要下载模型） 471 | 472 | --------------------------------------------------------------------------------