Upload 15 files

audio2video.py

@@ -0,0 +1,58 @@
+import os
+from moviepy.editor import *
+from glob import glob
+import re
+def merge_audio_and_add_to_video(video_path, audio_base_dir, output_path):
+    """
+    合并多个音频文件并添加到视频中。
+
+    :param video_path: 视频文件的路径。
+    :param audio_base_dir: 包含音频文件夹的基目录。
+    :param output_path: 输出视频的路径。
+    """
+    # 加载视频文件
+    video_clip = VideoFileClip(video_path)
+    
+    # 初始化音频列表
+    audio_clips = []
+
+    silent_audio_start = AudioClip(lambda t: [0,0], duration=2)
+    audio_clips.append(silent_audio_start)
+    
+    # 遍历所有子目录，按数字大小排序
+    audio_dirs = glob(os.path.join(audio_base_dir, "audio_for_paragraph_*"))
+    audio_dirs.sort(key=lambda x: int(re.search(r'\d+', os.path.basename(x)).group()))
+
+    # 遍历所有子目录
+    for audio_dir in audio_dirs:
+        # 获取当前目录的index
+        index = int(os.path.basename(audio_dir).split("_")[-1])
+        
+        # 遍历目录中的所有mp3文件
+        mp3_files = glob(os.path.join(audio_dir, f"paragraph_{index}_sentence_*.mp3"))
+        mp3_files.sort(key=lambda x: int(re.search(r'_sentence_(\d+)', os.path.basename(x)).group(1)))
+
+        # 遍历排序后的mp3文件列表
+        for mp3_file in mp3_files:
+            # 加载音频文件
+            audio_clip = AudioFileClip(mp3_file)
+            
+            # 添加到音频列表
+            if audio_clips:
+                # 如果不是第一个音频，则在前一个音频之后添加0.5秒的静音
+                # 替换原有的 AudioNullClip 代码
+                silent_audio = AudioClip(lambda t: [0,0], duration=0.3)
+                audio_clips.append(silent_audio)
+            audio_clips.append(audio_clip)
+    
+    # 合并所有音频片段
+    final_audio = concatenate_audioclips(audio_clips)
+    
+    # 将音频添加到视频中
+    video_with_audio = video_clip.set_audio(final_audio)
+    
+    # 输出带有新音频的视频文件
+    video_with_audio.write_videofile(output_path, codec='libx264', audio_codec='aac')
+    
+    # 关闭剪辑对象，释放资源
+    video_clip.close()

audio_generate_each_sentence.py

@@ -0,0 +1,133 @@
+import json
+import os
+import re
+import time
+import dashscope
+from dashscope.audio.tts_v2 import SpeechSynthesizer
+
+import traceback
+
+def read_json_file(file_path):
+    with open(file_path, 'r', encoding='utf-8') as file:
+        data = json.load(file)
+    return data
+
+
+def split_into_sentences(text):
+    # 中文标点符号列表
+    punctuation = ['，', '。', '；', '？', '！']
+    brackets = {'(': ')', '[': ']', '{': '}', '（': '）', '【': '】', '《': '》'}
+    
+    # 初始化结果列表和临时句子存储
+    sentences = []
+    temp_sentence = ''
+    bracket_stack = []
+    
+    # 遍历文本中的每一个字符
+    for char in text:
+        # 如果是左括号，压入栈
+        if char in brackets:
+            bracket_stack.append(char)
+        # 如果是右括号且与栈顶匹配，弹出栈
+        elif char in brackets.values() and bracket_stack and brackets[bracket_stack[-1]] == char:
+            bracket_stack.pop()
+        
+        # 如果字符是中文标点之一且括号栈为空，表示句子结束
+        if char in punctuation and not bracket_stack:
+            # 添加临时句子到结果列表，并清空临时句子
+            sentences.append(temp_sentence.strip())
+            temp_sentence = ''
+        else:
+            # 否则，将字符添加到临时句子中
+            temp_sentence += char
+    
+    # 处理最后一个可能没有标点结尾的句子
+    if temp_sentence:
+        sentences.append(temp_sentence.strip())
+    
+    return sentences
+
+
+def save_sentences_to_markdown(sentences, base_dir, index1):
+    for index2, sentence in enumerate(sentences, start=1):
+        # 创建目录
+        dir_name = f'audio_for_paragraph_{index1}'
+        dir_path = os.path.join(base_dir, dir_name)
+        os.makedirs(dir_path, exist_ok=True)
+        
+        # 构建文件名
+        file_name = f'paragraph_{index1}_sentence_{index2}.md'
+        file_path = os.path.join(dir_path, file_name)
+        
+        # 写入Markdown文件
+        with open(file_path, 'w', encoding='utf-8') as file:
+            file.write(sentence + '\n')
+
+
+def process_json_file(json_file_path, base_dir):
+    
+    if not os.path.exists(base_dir):
+        os.makedirs(base_dir)
+
+    file_prefix = os.path.splitext(os.path.basename(json_file_path))[0]
+    
+    base_dir = os.path.join(base_dir, file_prefix)
+
+    # 读取JSON文件
+    json_data = read_json_file(json_file_path)
+    
+    # 处理JSON数据中的每个条目
+    for index1, item in enumerate(json_data):
+        if 'content' in item:
+            content = item['content']
+            # 检查content是否为链接
+            if not is_url(content):
+                sentences = split_into_sentences(content)
+                save_sentences_to_markdown(sentences, base_dir, index1+1)
+
+def is_url(s):
+    url_pattern = re.compile(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+')
+    return bool(url_pattern.match(s))
+
+
+def synthesize_md_to_speech(base_directory):
+    """
+    识别指定目录下的所有.md文件，读取其内容并使用DashScope API将其转换为语音，
+    保存为同名.mp3文件在同一目录下。
+
+    参数:
+    base_directory (str): 包含.md文件的顶层目录路径。
+    """
+    # 确保环境变量中存在DashScope API密钥
+    if 'DASHSCOPE_API_KEY' not in os.environ:
+        raise ValueError("DashScope API key must be set in the environment variables.")
+    
+    # 遍历指定目录及其子目录
+    for root, dirs, files in os.walk(base_directory):
+        for file in files:
+            if file.endswith('.md'):
+                # 构建完整文件路径
+                md_file_path = os.path.join(root, file)
+                
+                # 读取.md文件内容
+                with open(md_file_path, 'r', encoding='utf-8') as f:
+                    text = f.read()
+                
+                # 初始化语音合成器
+                speech_synthesizer = SpeechSynthesizer(model='cosyvoice-v1', voice='longxiaochun')
+
+                
+                # 合成语音
+                audio_data = speech_synthesizer.call(text)
+                
+                # 构建输出.mp3文件路径
+                mp3_file_path = os.path.splitext(md_file_path)[0] + '.mp3'
+                
+                # 保存音频到文件
+                with open(mp3_file_path, 'wb') as f:
+                    f.write(audio_data)
+                
+                print(f'Synthesized text from file "{md_file_path}" to file: {mp3_file_path}')
+
+
+

calculate_durations_for_each_image.py

@@ -0,0 +1,49 @@
+import os
+from pydub import AudioSegment
+
+def calculate_audio_durations(directory):
+    """
+    计算指定目录下所有以 audio_for_paragraph_{index} 命名的文件夹中 mp3 文件的总持续时间（以秒为单位）。
+    
+    参数:
+        directory (str): 需要扫描的根目录路径。
+
+    返回:
+        list: 每个 audio_for_paragraph_{index} 文件夹中 mp3 文件总持续时间（秒）的列表。
+    """
+    # 初始化结果列表
+    durations = []
+    
+    # 遍历目录下的所有子目录
+    for entry in os.scandir(directory):
+        if entry.is_dir() and entry.name.startswith("audio_for_paragraph_"):
+            # 提取 index
+            index = int(entry.name.split("_")[-1])
+            
+            # 初始化当前文件夹的总持续时间为0
+            total_duration_ms = 0
+            
+            # 遍历子目录中的所有文件
+            for file_entry in os.scandir(entry.path):
+                if file_entry.name.endswith(".mp3"):
+                    # 加载 mp3 文件并计算持续时间
+                    audio = AudioSegment.from_mp3(file_entry.path)
+                    delay = 300
+                    total_duration_ms += len(audio) + delay
+            
+            # 将当前文件夹的总持续时间转换为秒，并添加到结果列表中
+            total_duration_seconds = total_duration_ms / 1000.0
+            durations.append((index, total_duration_seconds))
+    
+    # 按照 index 排序结果列表
+    durations.sort(key=lambda x: x[0])
+
+
+    
+    # 只保留持续时间（秒）
+    durations = [duration for _, duration in durations]
+
+    durations.insert(0, 2)
+    
+    return durations
+

doc_split.py

@@ -0,0 +1,73 @@
+from http import HTTPStatus
+import dashscope
+import json
+import os
+def doc_split_with_qwen_plus(input_filepath, output_filepath):
+
+    if not os.path.exists(output_filepath):
+        os.makedirs(output_filepath)
+
+    with open(input_filepath, 'r', encoding='utf-8') as file:
+        content = file.read()
+
+    prompt = """
+                    执行文档处理任务，包括分段与自动生成段落标题，需遵循以下具体细则：
+
+                    1. **分段逻辑**：仔细分析文档内容，根据其内在语义逻辑合理划分段落。
+
+                    2. **标题创作**：为每一独立段落设计一个精炼标题，确保该标题简洁明了（不超过10个字），并能有效准确地概括该段落核心信息。
+
+                    3. **输出规格**：完成处理后，生成的文档结构需符合JSON格式标准，每段落及对应的标题组成一个条目，具体格式示例如下：
+                    
+
+                    [ 
+                        {"title": " ", "content": " "},
+                        {"title": " ", "content": " "},
+                        ...
+                    ]
+              
+                    输出内容是以"["开头，并以"]"收尾的JSON数据，请不要输出其他内容。
+
+                    4. **原文忠实性**：在输出的JSON数据中，各段落的“content”字段必须精确匹配原始文档的文字内容，不得有增删改动。必须完整地处理原始文档的全部内容，不能有遗漏。请严格保证文字和链接在原文档中的相对位置保持不变。
+
+                    5. **格式化链接**：对于文档中的markdown格式的图片链接，将他们单独保存到JSON条目中。其"title"为"链接{index}"，"content"为链接地址，其中index为索引顺序。
+
+                    6. **内容限制**：输出内容中不得包含任何多余的空格、换行符、制表符等空白字符，也不得包含任何HTML、XML、Markdown等格式的符号。始终保持中文。
+    
+                    请严格依据上述要求执行文档处理任务。
+
+                    文档内容如下：
+              """
+
+    messages = [{
+        'role': 'user',
+        'content': f"""
+                    "{prompt}"
+                    "{content}"
+                   """
+    }]
+
+    response_content = ''
+    responses = dashscope.Generation.call("qwen-plus",
+                                          messages=messages,
+                                          result_format='message',
+                                          stream=True,
+                                          incremental_output=True)
+
+    for response in responses:
+        if response.status_code == HTTPStatus.OK:
+            response_content += response.output.choices[0]['message']['content']
+        else:
+            print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (
+                response.request_id, response.status_code,
+                response.code, response.message
+            ))
+    if response_content.startswith("```") and response_content.endswith("```"):
+        response_content = response_content[8:-3].strip()
+
+    input_base_name = os.path.splitext(os.path.basename(input_filepath))[0]
+    output_file_path = os.path.join(output_filepath, f'{input_base_name}.json')
+    with open(output_file_path, 'w', encoding='utf-8') as json_file:
+        json.dump(json.loads(response_content), json_file, ensure_ascii=False, indent=4)
+
+    return response_content

json2md.py

@@ -0,0 +1,125 @@
+import json
+import os
+import re
+from qwen_plus_marp import call_with_stream
+from pathlib import Path
+
+def is_link(text):
+    """检查给定的文本是否为链接。"""
+    return text.startswith("http://") or text.startswith("https://")
+
+def parse_json_list_to_markdown(json_list, theme_url):
+    """
+    将 JSON 对象列表转换为 Markdown 格式，并通过 call_with_stream 处理 'content'。
+    
+    参数:
+    - json_list (list): 字典列表，每个字典都包含 'title' 和 'content' 键。
+    
+    返回:
+    - str: Markdown 格式的字符串。
+    """
+    theme = "![bg 110% opacity:.80](./{theme_filename})\n\n"
+    theme_filename = Path(theme_url).name
+    markdown_content = ""
+    for item in json_list:
+        title = item.get('title', '未命名')
+        processed_content = call_with_stream(item.get('content', ''))
+        
+        if is_link(processed_content):
+            markdown_content += f"---\n\n![bg right 70%]({processed_content})\n\n---"
+        else:
+            markdown_content += f"\n\n# {title}\n\n{processed_content}\n\n---"
+    return markdown_content
+
+
+def parse_json_list_to_markdown_new(json_list, theme_url):
+    """
+    将 JSON 对象列表转换为 Markdown 格式，并通过 call_with_stream 处理 'content'。
+    
+    参数:
+    - json_list (list): 字典列表，每个字典都包含 'title' 和 'content' 键。
+    
+    返回:
+    - str: Markdown 格式的字符串。
+    """
+    theme_filename = Path(theme_url).name
+    theme = f"![bg 110% opacity:.80](./{theme_filename})\n\n"
+
+    markdown_content = ""
+
+    for i, item in enumerate(json_list):
+        title = item.get('title', '未命名')
+        processed_content = call_with_stream(item.get('content', ''))
+        if processed_content.startswith("```") and processed_content.endswith("```"):
+            processed_content = processed_content[11:-3].strip()
+
+        if not is_link(json_list[i].get('content')):
+            # 如果是列表中的最后一个元素
+            if i == len(json_list) - 1:
+                markdown_content += f"\n\n## {title}\n\n{processed_content}\n\n{theme}\n\n---"
+            else:
+                if not is_link(json_list[i + 1].get('content')):
+                    # 当前不是链接且下一个也不是链接
+                    markdown_content += f"\n\n## {title}\n\n{processed_content}\n\n{theme}\n\n---"
+                else:
+                    # 当前不是链接但下一个是链接
+                    markdown_content += f"\n\n## {title}\n\n{processed_content}\n\n---"
+        else:
+            # 当前是链接
+            markdown_content += f"---\n\n![bg right 70%]({json_list[i].get('content')})\n\n---"
+
+    return markdown_content
+
+
+def convert_json_file_to_md(json_file_path, output_dir, theme_url):
+    """
+    读取 JSON 文件，通过 call_with_stream 转换其内容，然后保存为 Markdown 文件。
+    
+    参数:
+    - json_file_path (str): JSON 文件的路径。
+    - output_dir (str): Markdown 文件将被保存的目录。
+    """
+    
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    with open(json_file_path, 'r', encoding='utf-8') as file:
+        json_data = json.load(file)
+    
+    markdown_content = parse_json_list_to_markdown_new(json_data, theme_url)
+    
+    base_name = os.path.splitext(os.path.basename(json_file_path))[0]
+    md_file_name = f"{base_name}.md"
+    output_path = os.path.join(output_dir, md_file_name)
+    
+    with open(output_path, 'w', encoding='utf-8') as file:
+        file.write(markdown_content)
+
+def save_markdown_to_file(content, filename):
+    """ 保存Markdown内容到文件 """
+    with open(filename, 'w', encoding='utf-8') as file:
+        file.write(content)
+
+def process_markdown(input_file):
+    """ 处理Markdown文本，按要求分割并保存 """
+    with open(input_file, 'r', encoding='utf-8') as file:
+        input_text = file.read()
+
+    # 使用正则表达式确保每个部分都包含 "---"
+    parts = re.split(r'(?<=---\n)', input_text)
+
+    # 移除空字符串部分
+    parts = [part.strip() for part in parts if part.strip()]
+
+    filenames = []
+    base_path = os.path.dirname(input_file)  # 获取基础文件的路径
+    
+    for i, part in enumerate(parts):
+        # 生成文件名
+        filename = f'{os.path.splitext(os.path.basename(input_file))[0]}_{i}.md'
+        # 构建完整路径
+        full_filename = os.path.join(base_path, filename)
+        save_markdown_to_file(f'{part}', full_filename)
+        filenames.append(full_filename)
+
+

main.py

@@ -0,0 +1,208 @@
+import argparse
+import datetime
+import os
+import shutil
+import gradio as gr
+from threading import Thread
+
+# 导入你的模块
+from doc_split import doc_split_with_qwen_plus
+from json2md import convert_json_file_to_md, process_markdown
+from markdown_gather import merge_style_with_md_files, remove_trailing_dashes, insert_logo, remove_empty_lines, title_to_md
+from marp2image import convert_md_files_to_png
+from audio_generate_each_sentence import process_json_file, synthesize_md_to_speech
+from srt_generate_for_each_sentence import generate_srt_from_audio
+from calculate_durations_for_each_image import calculate_audio_durations
+from movie_editor import images_to_video_with_durations
+from audio2video import merge_audio_and_add_to_video
+from srt2video import merge_video_and_subtitle
+from theme_generate import theme_generate_with_qwen_plus
+
+def main(args, progress_callback, log_callback):
+    try:
+        # 记录开始时间
+        start_time = datetime.datetime.now()
+        progress_callback(f"开始时间: {start_time.strftime('%Y年%m月%d日 %H时%M分%S秒')}")
+        log_callback(f"开始时间: {start_time.strftime('%Y年%m月%d日 %H时%M分%S秒')}")
+
+        # 生成带有时间戳的文件夹名
+        timestamp = start_time.strftime("%Y%m%d_%H%M%S")
+        material_folder = f"material_{timestamp}"
+
+        # 创建输出保存路径，将渲染素材复制到指定路径下
+        input_base_name = os.path.splitext(os.path.basename(args.input_txt_path))[0]
+
+        # 更新各个路径，使用新的文件夹名
+        args.json_path = os.path.join(material_folder, "json")
+        args.image_path = os.path.join(material_folder, "image")
+        args.audio_path = os.path.join(material_folder, "audio")
+        args.markdown_path = os.path.join(material_folder, "markdown")
+        args.srt_and_video_path = os.path.join(material_folder, "video")
+
+        # 创建必要的文件夹
+        folders_to_create = [
+            material_folder, args.markdown_path, args.json_path,
+            args.image_path, args.audio_path, args.srt_and_video_path
+        ]
+        for folder in folders_to_create:
+            if not os.path.exists(folder):
+                os.makedirs(folder)
+                log_callback(f"创建文件夹: {folder}")
+
+        # 复制样式文件
+        if os.path.exists(args.input_style_path):
+            for filename in os.listdir(args.input_style_path):
+                full_path = os.path.join(args.input_style_path, filename)
+                if os.path.isfile(full_path):
+                    shutil.copy2(full_path, args.markdown_path)
+            log_callback(f"样式文件已复制到: {args.markdown_path}")
+        else:
+            log_callback(f"警告: 输入样式文件夹路径 {args.input_style_path} 不存在，跳过复制操作。", is_warning=True)
+
+        # 通过API调用通义千问-Plus为输入文档生成文档标题
+        theme = theme_generate_with_qwen_plus(args.input_txt_path, args.title)
+        progress_callback(f"生成的文档标题: {theme}")
+        log_callback(f"生成的文档标题: {theme}")
+
+        # 通过API调用通义千问-Plus为输入文档划分段落，并为每一个段落生成一个段落标题
+        doc_split_with_qwen_plus(args.input_txt_path, args.json_path)
+        progress_callback(f"文档已分割并保存到: {args.json_path}")
+        log_callback(f"文档已分割并保存到: {args.json_path}")
+
+        # 总结各段落内容，保存为Markdown格式，并设置背景图片，可自行将style文件夹下的theme.png替换为自定义背景
+        for filename in os.listdir(args.json_path):
+            if filename.endswith('.json'):
+                json_file_path = os.path.join(args.json_path, filename)
+                convert_json_file_to_md(json_file_path, args.markdown_path, args.theme_path)
+                log_callback(f"转换 {json_file_path} 到 Markdown 格式并保存到: {args.markdown_path}")
+
+        # 将文档标题添加到Markdown文件开头作为标题页，并设置标题页背景，可自行将style文件夹下的title.png替换为自定义标题页背景
+        title_to_md(os.path.join(args.markdown_path, f'{input_base_name}.md'), theme, args.title_path)
+        log_callback(f"文档标题已添加到 Markdown 文件: {os.path.join(args.markdown_path, f'{input_base_name}.md')}")
+
+        # 删除空行，符合Marp格式
+        remove_empty_lines(os.path.join(args.markdown_path, f'{input_base_name}.md'))
+        log_callback(f"删除空行: {os.path.join(args.markdown_path, f'{input_base_name}.md')}")
+
+        # 添加阿里云logo。可自行替换为其他logo：将logo图片命名为logo.png，放到style文件夹下
+        insert_logo(os.path.join(args.markdown_path, f'{input_base_name}.md'), os.path.join(args.logo_path))
+        log_callback(f"插入logo到 Markdown 文件: {os.path.join(args.markdown_path, f'{input_base_name}.md')}")
+
+        process_markdown(os.path.join(args.markdown_path, f'{input_base_name}.md'))
+        log_callback(f"处理 Markdown 文件: {os.path.join(args.markdown_path, f'{input_base_name}.md')}")
+
+        # 定义并添加Marp样式文件。可查阅Marp官方文档自定义样式：将样式文件命名为style.md，放到style文件夹下
+        merge_style_with_md_files(args.markdown_path, args.markdown_style_path)
+        log_callback(f"合并样式文件到 Markdown 文件: {args.markdown_path}")
+
+        # 删除Markdown文件末尾的“---”，避免生成空白图片
+        remove_trailing_dashes(args.markdown_path)
+        log_callback(f"删除 Markdown 文件末尾的 '---': {args.markdown_path}")
+
+        # 使用Marp生成演示文稿图片
+        convert_md_files_to_png(os.path.join(args.markdown_path, f'{input_base_name}.md'), args.image_path)
+        log_callback(f"生成图片: {args.image_path}")
+
+        # 将各段落文档划分为若干句子，并通过API调用CosyVoice合成语音
+        process_json_file(os.path.join(args.json_path, f'{input_base_name}.json'), args.audio_path)
+        synthesize_md_to_speech(os.path.join(args.audio_path, input_base_name))
+        log_callback(f"合成语音: {args.audio_path}")
+
+        # 生成srt字幕文件
+        generate_srt_from_audio(os.path.join(args.audio_path, input_base_name), args.srt_and_video_path,
+                                os.path.join(args.srt_and_video_path, input_base_name))
+        log_callback(f"生成SRT字幕文件: {args.srt_and_video_path}")
+
+        # 计算各段落的所有音频时长
+        durations = calculate_audio_durations(os.path.join(args.audio_path, input_base_name))
+        log_callback(f"计算音频时长: {durations}")
+
+        # 将所有图片剪辑为视频
+        images_to_video_with_durations(os.path.join(args.image_path, f'{input_base_name}'), args.srt_and_video_path,
+                                       durations, args.fps, input_base_name)
+        log_callback(f"生成视频: {args.srt_and_video_path}")
+
+        # 将音频文件嵌入视频
+        merge_audio_and_add_to_video(os.path.join(args.srt_and_video_path, f'{input_base_name}.mp4'),
+                                     os.path.join(args.audio_path, f'{input_base_name}'),
+                                     os.path.join(args.srt_and_video_path, f'{input_base_name}_with_audio.mp4'))
+        log_callback(f"合并音频到视频: {args.srt_and_video_path}")
+
+        # 将字幕文件嵌入视频
+        merge_video_and_subtitle(args.srt_and_video_path, input_base_name)
+        log_callback(f"合并字幕到视频: {args.srt_and_video_path}")
+
+        # 记录结束时间
+        end_time = datetime.datetime.now()
+        progress_callback(f"结束时间: {end_time.strftime('%Y年%m月%d日 %H时%M分%S秒')}")
+        log_callback(f"结束时间: {end_time.strftime('%Y年%m月%d日 %H时%M分%S秒')}")
+
+        # 计算总时间
+        elapsed_time = end_time - start_time
+        elapsed_hours, remainder = divmod(elapsed_time.total_seconds(), 3600)
+        elapsed_minutes, elapsed_seconds = divmod(remainder, 60)
+
+        elapsed_time_str = f"{int(elapsed_hours)}时{int(elapsed_minutes)}分{int(elapsed_seconds)}秒"
+        progress_callback(f"总时间: {elapsed_time_str}")
+        log_callback(f"总时间: {elapsed_time_str}")
+
+    except Exception as e:
+        log_callback(f"发生错误: {str(e)}", is_error=True)
+        progress_callback(f"发生错误: {str(e)}", is_error=True)
+        raise e
+
+def run_conversion(input_txt_path, fps, title):
+    args = argparse.Namespace(
+        input_txt_path=input_txt_path,
+        input_style_path='./style',
+        markdown_style_path='./style/style.md',
+        logo_path='./style/logo.png',
+        theme_path='./style/theme.png',
+        title_path='./style/title.png',
+        json_path='./material/json',
+        image_path='./material/image',
+        audio_path='./material/audio',
+        markdown_path='./material/markdown',
+        srt_and_video_path='./material/video',
+        fps=int(fps),
+        title=title
+    )
+
+    log_text = []
+
+    def progress_callback(message, is_error=False):
+        log_text.append(message)
+        if is_error:
+            log_text.append(f"错误: {message}")
+
+    def log_callback(message, is_warning=False, is_error=False):
+        log_text.append(message)
+        if is_warning:
+            log_text.append(f"警告: {message}")
+        elif is_error:
+            log_text.append(f"错误: {message}")
+
+    def video_generation_done():
+        log_text.append("视频生成成功！")
+
+    main(args, progress_callback, log_callback)
+    video_generation_done()
+    return "\n".join(log_text)
+
+def gradio_interface():
+    iface = gr.Interface(
+        fn=run_conversion,
+        inputs=[
+            gr.Textbox(lines=1, placeholder="输入文本路径", label="输入文本路径"),
+            gr.Number(value=30, label="帧率"),
+            gr.Textbox(lines=1, placeholder="视频标题", label="视频标题")
+        ],
+        outputs=gr.Textbox(label="日志输出"),
+        title="文档生成视频",
+        description="将文档转换为带有音频和字幕的视频。",
+        live=False
+    )
+    iface.launch(share=True)  # 添加 share=True
+
+if __name__ == "__main__":
+    gradio_interface()

markdown_gather.py

@@ -0,0 +1,152 @@
+import os
+import re
+from pathlib import Path
+import os
+
+
+def merge_style_with_md_files(md_file_path, style_file_path):
+    # 检查样式文件是否存在
+    if not os.path.isfile(style_file_path):
+        raise FileNotFoundError(f"样式文件 {style_file_path} 不存在。")
+    
+    # 读取样式文件内容
+    with open(style_file_path, 'r', encoding='utf-8') as f:
+        style_content = f.read()
+    
+    # 遍历指定目录下的所有文件
+    for filename in os.listdir(md_file_path):
+        if filename.startswith('section') and filename.endswith('.md'):
+            file_path = os.path.join(md_file_path, filename)
+            # 合并样式内容与 .md 文件内容
+            if os.path.exists(file_path):
+                with open(file_path, 'r+', encoding='utf-8') as f:
+                    original_content = f.read()
+                    # 将指针移动到文件开头以覆盖原有内容
+                    f.seek(0)
+                    f.write(style_content + '\n\n' + original_content)
+                    # 清除输出缓冲区以确保所有数据都已写入文件
+                    f.truncate()
+
+
+def remove_trailing_dashes(directory):
+    """
+    从 Markdown 文件中移除位于文件末尾且后面没有其他内容（除了可能的换行符）的连续破折号（---）。
+    """
+    for filename in os.listdir(directory):
+        # 检查文件是否以 section 开头且为 .md 文件
+        if filename.startswith('section') and filename.endswith('.md'):
+            filepath = os.path.join(directory, filename)
+
+            # 读取文件内容
+            with open(filepath, 'r', encoding='utf-8') as file:
+                content = file.read()
+
+            # 检查文件末尾是否有连续的破折号（---），并且之后没有其他内容（除了可能的换行符）
+            if content.rstrip().endswith('---') and content.rstrip('---').endswith('\n'):
+                # 移除末尾的连续破折号（---）及其后面的换行符
+                content = content.rstrip('---\n')
+
+            # 替换文件中的所有 "------" 为空字符串
+            content = content.replace("------", "")
+            content = re.sub(r'\n{3,}', '\n\n', content)
+
+            # 写入更新后的内容
+            with open(filepath, 'w', encoding='utf-8') as file:
+                file.write(content)
+
+
+def remove_empty_lines(filename):
+    # 读取文件内容
+    with open(filename, 'r', encoding='utf-8') as file:
+        content = file.read()
+    # 替换文件中的所有 "------" 为空字符串
+    content = content.replace("------", "")
+    with open(filename, 'w', encoding='utf-8') as file:
+        file.write(content)
+
+
+def append_string_to_file(file_path):
+    # 读取文件内容
+    with open(file_path, 'r', encoding='utf-8') as file:
+        content = file.read()
+
+    # 在文件末尾追加字符串 '---'
+    new_content = content + '---'
+
+    # 写入新内容
+    with open(file_path, 'w', encoding='utf-8') as file:
+        file.write(new_content)
+
+
+def insert_logo(file_path, logo_path):
+    # 读取文件内容
+    with open(file_path, 'r', encoding='utf-8') as file:
+        content = file.read()
+
+    # 获取 Logo 文件名
+    logo_filename = Path(logo_path).name
+
+    # 定义要插入的字符串
+    insert_str = f"""<!--\nbackgroundImage: url("./{logo_filename}");\nbackgroundSize: 10% ;\nbackgroundPosition: 98% 3% ;\n-->
+                    """
+
+    # 使用正则表达式替换
+    # 只替换独立出现的 "---"，不包括被其他破折号包围的情况
+    new_content = re.sub(r'(?<!-)---(?!-)', f'\n{insert_str}\n---', content, flags=re.DOTALL)
+
+    # 写入新内容
+    with open(file_path, 'w', encoding='utf-8') as file:
+        file.write(new_content)
+
+
+def insert_bg_if_no_link(filename, theme_url):
+    # 用于存储最终结果的列表
+    result = []
+
+    # 读取文件内容
+    with open(filename, 'r', encoding='utf-8') as file:
+        content = file.read()
+
+    # 获取 Logo 文件名
+    theme_filename = Path(theme_url).name
+
+    # 使用正则表达式分割文本
+    sections = re.split(r'---+', content)
+
+    # 遍历每个部分
+    for i, section in enumerate(sections):
+        # 查找 "# {字符串内容}" 的模式
+        header_match = re.search(r'# \{(.+?)\}', section)
+        if header_match:
+            # 提取 "# {字符串内容}" 后面的内容
+            header_content = section[header_match.end():].strip()
+
+            # 检查这部分内容是否包含 ![parameter](url) 格式的链接
+            if not re.search(r'!\[[^\]]*\]\([^\)]*\)', header_content):
+                # 如果没有链接也没有背景图片，在 "# {字符串内容}" 之后添加指定文本
+                section = f'{section[:header_match.end()]}![bg 110% opacity:.80](./{theme_filename})\n{section[header_match.end():]}\n---'
+
+        # 将处理后的部分添加到结果列表中
+        result.append(section)
+
+        # 如果不是最后一个部分，保留原始的分隔符
+        if i < len(sections) - 1:
+            result.append('---')
+
+    # 将结果写回文件
+    with open(filename, 'w', encoding='utf-8') as file:
+        file.write(''.join(result))
+
+
+def title_to_md(file_path, content, title_url):
+    # 读取原文件内容
+    title_filename = Path(title_url).name
+    with open(file_path, 'r', encoding='utf-8') as file:
+        original_content = file.read()
+    content = f"![bg right:60% ](./{title_filename})\n# {content}\n---"
+    # 在开头添加新内容
+    new_content = content + '\n' + original_content
+
+    # 写入新内容
+    with open(file_path, 'w', encoding='utf-8') as file:
+        file.write(new_content)

marp2image.py

@@ -0,0 +1,47 @@
+import os
+import re
+import subprocess
+
+def convert_md_files_to_png(md_file_path, output_base_dir="./Marp/"):
+    """
+    顺序读取和输入与 md_file_path 文件相同路径中的所有命名格式为 {base_name}_{index}.md 的文件，
+    并按 index 的数字大小顺序遍历所有文件，使用 Marp 直接生成 PNG 格式的图片。
+
+    :param md_file_path: MD 文件的完整路径。
+    :param output_base_dir: 输出目录的基路径，将在此目录下创建子目录以保存输出文件。
+    """
+
+    if not os.path.exists(output_base_dir):
+        os.makedirs(output_base_dir)
+
+    # 获取MD文件名（去掉.md后缀）
+    base_name = os.path.splitext(os.path.basename(md_file_path))[0]
+    directory = os.path.dirname(md_file_path)
+
+    # 获取所有符合条件的文件名
+    md_files = [f for f in os.listdir(directory) if f.startswith(base_name + '_') and f.endswith('.md')]
+    md_files.sort()  # 按文件名排序
+
+    # 创建输出目录，目录名与MD文件名相同
+    output_dir = os.path.join(output_base_dir, base_name)
+    os.makedirs(output_dir, exist_ok=True)  # 如果目录已存在，则不会抛出异常
+
+    for md_file in md_files:
+        md_file_path = os.path.join(directory, md_file)
+        base = os.path.splitext(os.path.basename(md_file_path))[0]
+        match = re.match(rf"{re.escape(base_name)}_(\d+)", base)
+        if match:
+            index = int(match.group(1))  # 提取索引
+            
+            # 构建Marp CLI命令
+            command = ["marp", "--html", "--allow-local-files",
+                       "--output", os.path.join(output_dir, f"{base_name}_{index}.png"),
+                       "--format", "png",
+                       md_file_path]
+
+            try:
+                # 执行命令，将MD文件转换为PNG
+                subprocess.run(command, check=True)
+                print(f"成功将 '{md_file_path}' 转换为PNG并保存至 '{output_dir}'。")
+            except subprocess.CalledProcessError as e:
+                print(f"转换 '{md_file_path}' 时发生错误: {e}")

merge_all_videos.py

@@ -0,0 +1,25 @@
+import os
+import re
+from moviepy.editor import VideoFileClip, concatenate_videoclips
+
+def merge_videos(input_directory):
+    # 定义视频文件的模式
+    video_pattern = r"section_(\d+)_with_audio_with_subs\.mp4"
+    
+    # 查找并排序符合模式的文件
+    files = sorted(
+        (fn for fn in os.listdir(input_directory) if re.match(video_pattern, fn)),
+        key=lambda x: int(re.match(video_pattern, x).group(1))
+    )
+    
+    # 读取所有视频片段
+    clips = [VideoFileClip(os.path.join(input_directory, file)) for file in files]
+    
+    # 合并所有视频片段
+    final_clip = concatenate_videoclips(clips)
+    
+    # 输出合并后的视频
+    output_path = os.path.join(input_directory, 'output_merge_all_video.mp4')
+    final_clip.write_videofile(output_path, audio_codec='aac')
+
+merge_videos("./material/video")

movie_editor.py

@@ -0,0 +1,56 @@
+from moviepy.editor import ImageClip, ColorClip, concatenate_videoclips, CompositeVideoClip
+import os
+import re
+import natsort
+from PIL import Image
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor
+
+def process_image(file, duration, target_size):
+    with Image.open(file) as img:
+        width, height = img.size
+        ratio = width / height
+        new_width, new_height = target_size
+
+        if width > target_size[0] or height > target_size[1]:
+            if ratio > target_size[0] / target_size[1]:
+                new_width = target_size[0]
+                new_height = int(new_width / ratio)
+            else:
+                new_height = target_size[1]
+                new_width = int(new_height * ratio)
+
+        resized_img = img.resize((new_width, new_height), resample=Image.Resampling.LANCZOS)
+        img_clip = ImageClip(np.array(resized_img)).set_duration(duration).set_position('center')
+        return img_clip
+
+def images_to_video_with_durations(input_image_path, output_video_path, durations, fps, base_name):
+    # 获取所有符合条件的图片，并按文件名中的数字排序
+    pattern = re.compile(rf'^{re.escape(base_name)}_(\d+)\.png$')
+    image_files = [
+        os.path.join(input_image_path, file)
+        for file in os.listdir(input_image_path)
+        if pattern.match(file)
+    ]
+    image_files = natsort.natsorted(image_files, key=lambda x: int(pattern.match(os.path.basename(x)).group(1)))
+
+    # 确定视频的背景尺寸
+    target_size = (1280, 720)
+
+    # 创建背景剪辑
+    bg_clip = ColorClip(size=target_size, color=(255, 255, 255), duration=sum(durations))
+
+    # 使用多线程处理图像文件
+    with ThreadPoolExecutor() as executor:
+        clips = list(executor.map(process_image, image_files, durations, [target_size] * len(image_files)))
+
+    # 将所有剪辑叠加到背景上
+    composite_clips = [CompositeVideoClip([bg_clip.subclip(sum(durations[:i]), sum(durations[:i+1])), clip]) 
+                       for i, clip in enumerate(clips)]
+
+    # 使用concatenate_videoclips函数将所有剪辑串联起来
+    final_clip = concatenate_videoclips(composite_clips, method="compose")
+
+    # 写入视频文件
+    output_filename = f"{base_name}.mp4"
+    final_clip.write_videofile(os.path.join(output_video_path, output_filename), fps=fps)

qwen_plus_marp.py

@@ -0,0 +1,52 @@
+import asyncio
+
+import os
+from http import HTTPStatus
+import dashscope
+
+def call_with_stream(content):
+    prompt2 = """
+                    请提取下列文字的主要要点，并将这些要点以Markdown格式输出，请输出中文。
+                    如果文字内容为链接，请直接以Markdown格式输出该链接。
+                    请严格按照Markdown格式输出代码段，避免输出其他内容，避免出现'''之类的符号。
+                    但是Markdown文字内容简洁。
+                    Markdown代码段中，每一个小标题下的的内容行数禁止超过3行。
+                    “- 内容”之后不要再分段落描述。
+
+                    示例输入：你有过使用搜索引擎搜索问题却怎么也找不到有效信息的时候吗？
+                    示例输出：- 使用搜索引擎遇到的问题：难以找到有效信息
+
+                    示例输入：https://alidocs.oss-cn-zhangjiakou.aliyuncs.com/res/54Lq3RNeD78gn7Ed/img/6f9f3049-78a2-46b3-a052-88792052890d.png
+                    示例输出：https://alidocs.oss-cn-zhangjiakou.aliyuncs.com/res/54Lq3RNeD78gn7Ed/img/6f9f3049-78a2-46b3-a052-88792052890d.png
+
+                    以下是待提炼的文字内容：
+                    
+
+              """
+
+
+    messages = [{
+        'role': 'user',
+        'content': f"""
+                    "{prompt2}"
+                    "{content}"
+                   """
+    }]
+
+    response_content = ''
+    responses = dashscope.Generation.call("qwen-plus",
+                                          messages=messages,
+                                          result_format='message',
+                                          stream=True,
+                                          incremental_output=True)
+
+    for response in responses:
+        if response.status_code == HTTPStatus.OK:
+            response_content += response.output.choices[0]['message']['content']
+        else:
+            print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (
+                response.request_id, response.status_code,
+                response.code, response.message
+            ))
+
+    return response_content

srt2video.py

@@ -0,0 +1,22 @@
+import subprocess
+import os
+def merge_video_and_subtitle(video_and_srt_path, base_name):
+    video_ext = ".mp4"
+    srt_ext = ".srt"
+
+    video_path = os.path.join(video_and_srt_path, f"{base_name}_with_audio" + video_ext).replace("\\", "/")
+    srt_path = os.path.join(video_and_srt_path, base_name + srt_ext).replace("\\", "/")
+    output_path = os.path.join(video_and_srt_path, f"{base_name}_with_audio_with_subs" + video_ext).replace("\\", "/")
+
+    command = [
+        'ffmpeg',
+        '-i', video_path,
+        '-vf', f'subtitles={srt_path}',
+        '-c:a', 'copy',
+        output_path
+    ]
+
+    try:
+        subprocess.run(command, check=True)
+    except subprocess.CalledProcessError as e:
+        print(f"An error occurred while merging video and subtitles: {e}")

srt_generate_for_each_sentence.py

@@ -0,0 +1,93 @@
+import os
+import re
+from moviepy.editor import AudioFileClip
+from typing import List
+
+def format_time(seconds):
+    hours, remainder = divmod(seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    milliseconds = int((seconds - int(seconds)) * 1000)
+    seconds = int(seconds)
+    return f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d},{milliseconds:03d}"
+
+# 定义一个函数来获取音频文件的时长
+def get_audio_duration(file_path):
+    audio = AudioFileClip(file_path)
+    duration = audio.duration
+    audio.close()
+    return duration
+
+# 定义一个函数来生成SRT格式的字幕行
+def create_srt_line(index, start_time, end_time, text):
+    return f"{index}\n{start_time} --> {end_time}\n{text}\n\n"
+
+def generate_srt_from_audio(base_dir: str, output_dir: str, output_srt_file: str) -> None:
+    """
+    从指定目录下的音频文件夹生成SRT字幕文件。
+
+    :param base_dir: 包含音频文件夹的根目录。
+    :param output_dir: 输出SRT文件的目录。
+    :param output_srt_file: 输出SRT文件的完整路径。
+    """
+
+    # 创建输出目录，如果它不存在
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # 确保输出文件名有.srt后缀
+    if not output_srt_file.endswith('.srt'):
+        output_srt_file += '.srt'
+    
+
+    # 初始化当前时间
+    current_time = 2.000  # 初始时间
+
+    # 打开SRT文件进行写入
+    with open(output_srt_file, 'w', encoding='utf-8') as srt_file:
+        srt_index = 1
+
+        # 获取所有符合条件的子目录，并按索引排序
+        sub_dirs = [d for d in os.listdir(base_dir) if d.startswith('audio_for_paragraph_')]
+        sub_dirs.sort(key=lambda x: int(re.search(r'\d+', x).group()))
+
+        # 遍历所有子目录
+        for sub_dir in sub_dirs:
+            sub_dir_path = os.path.join(base_dir, sub_dir)
+
+            # 查找所有的.md和.mp3文件
+            files = [f for f in os.listdir(sub_dir_path) if f.endswith('.md') or f.endswith('.mp3')]
+            md_files = [f for f in files if f.endswith('.md')]
+
+            # 按照index1和index2排序.md文件
+            md_files.sort(key=lambda x: (int(x.split('_')[1]), int(x.split('_')[3].split('.')[0])))
+
+            # 处理每个.md文件
+            for md_file in md_files:
+                md_file_path = os.path.join(sub_dir_path, md_file)
+                mp3_file_path = os.path.splitext(md_file_path)[0] + '.mp3'
+
+                # 确保对应的.mp3文件存在
+                if os.path.exists(mp3_file_path):
+                    # 读取.md文件内容
+                    with open(md_file_path, 'r', encoding='utf-8') as f:
+                        text = f.read().strip()
+
+                    # 获取.mp3文件时长
+                    duration = get_audio_duration(mp3_file_path)
+
+                    # 生成SRT格式的字幕行
+                    start_time_str = format_time(current_time)
+                    end_time_str = format_time(current_time + duration)
+                    srt_line = create_srt_line(srt_index, start_time_str, end_time_str, text)
+
+                    # 写入SRT文件
+                    srt_file.write(srt_line)
+
+                    # 更新当前时间
+                    current_time += duration + 0.3  # 加上0.5秒以避免时间重叠
+
+                    srt_index += 1
+                else:
+                    print(f"No corresponding MP3 file found for {md_file}")
+
+    print("SRT file generated successfully.")

theme_generate.py

@@ -0,0 +1,68 @@
+from http import HTTPStatus
+import dashscope
+import re
+
+def theme_generate_with_qwen_plus(input_filepath, title):
+    """
+    使用通义千问-Plus生成摘要标题。
+
+    本函数读取指定文件的内容，并基于该内容和给定的主题生成一个精确、概括性的摘要标题。
+    
+    参数:
+    - input_filepath: 输入文件的路径。该文件的内容将用于生成摘要标题。
+    - title: 生成摘要标题需围绕的主题。确保生成的标题与该主题紧密相关。
+
+    返回:
+    - response_content: 生成的摘要标题。
+
+    注意:
+    - 该函数以流式传输的方式请求生成标题，仅当响应状态码为HTTPStatus.OK时，累加响应内容。
+    - 如果发生错误，函数会打印请求的相关错误信息。
+    """
+    # 读取输入文件内容
+    with open(input_filepath, 'r', encoding='utf-8') as file:
+        content = file.read()
+
+    # 构建提示信息，指导模型生成与主题紧密相关的标题
+    prompt = f"""
+                请为以下输入文档创建一个精确的、具备概括性的摘要标题，能够反映文档核心内容，忽略所有链接，仅聚焦文字信息。
+                需要紧紧地围绕主题“{title}”。
+                直接呈现标题成果，勿附加其他文本，不超过10个汉字，用中文回答。
+                以下是输入文档的内容：
+              """
+
+    # 构建消息格式
+    messages = [{
+        'role': 'user',
+        'content': f"""
+                    "{prompt}"
+                    "{content}"
+                   """
+    }]
+
+    # 初始化响应内容
+    response_content = ''
+
+    # 以流式传输的方式获取生成的结果
+    responses = dashscope.Generation.call("qwen-plus",
+                                          messages=messages,
+                                          result_format='message',
+                                          stream=True,
+                                          incremental_output=True)
+
+    # 遍历响应，累加生成的标题内容
+    for response in responses:
+        if response.status_code == HTTPStatus.OK:
+            response_content += response.output.choices[0]['message']['content']
+        else:
+            # 打印错误信息
+            print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (
+                response.request_id, response.status_code,
+                response.code, response.message
+            ))
+
+    # 移除标题中的双引号（如果存在）
+    response_content = re.sub(r'^"|"$', '', response_content)
+
+    # 返回生成的标题内容
+    return response_content

txt2srt.py

@@ -0,0 +1,95 @@
+import re
+from datetime import timedelta
+import math
+import os
+
+def split_text_into_sentences(text):
+    # 使用正则表达式匹配句末的标点符号或换行符来分割文本
+    sentences = re.split(r'[\。\？\！\，\n]', text)
+    # 过滤掉空字符串
+    sentences = [s.strip() for s in sentences if s.strip()]
+    return sentences
+
+
+def generate_srt_content(sentences, start_time=0):
+    srt_content = []
+    duration_per_four_chinese_chars = 0.7   # 每四个汉字持续0.7秒
+    duration_per_other_char = 0.2           # 每个其他字符持续0.2秒
+    
+    current_time = start_time
+    for index, sentence in enumerate(sentences, start=1):
+        chinese_char_count = len(re.findall(r'[\u4e00-\u9fa5]', sentence))
+
+        other_char_count = len(sentence) - chinese_char_count
+        
+        # 确保汉字的总持续时间按每四个汉字0.7秒计算
+        total_chinese_duration = math.ceil(chinese_char_count / 4) * duration_per_four_chinese_chars
+        # 计算非汉字字符的总持续时间
+        total_other_duration = other_char_count * duration_per_other_char
+        
+        # 总持续时间
+        total_duration = total_chinese_duration + total_other_duration
+        
+        # 确保总持续时间不会导致时间过长（例如超过1分钟）
+        if total_duration > 60:
+            total_duration = 60
+        
+        # 获取总秒数
+        total_seconds_start = current_time
+        total_seconds_end = min(current_time + total_duration, current_time + 60)
+
+        # 分离秒和毫秒
+        start_seconds = int(total_seconds_start)
+        start_milliseconds = int((total_seconds_start - start_seconds) * 1000)
+        end_seconds = int(total_seconds_end)
+        end_milliseconds = int((total_seconds_end - end_seconds) * 1000)
+
+        # 计算开始时间的小时、分钟、秒和毫秒
+        hours, remainder = divmod(start_seconds, 3600)  # 一小时有3600秒
+        minutes, seconds = divmod(remainder, 60)
+        milliseconds = start_milliseconds
+
+        start = '{:02d}:{:02d}:{:02d},{:03d}'.format(hours, minutes, seconds, milliseconds)
+
+        # 计算结束时间的小时、分钟、秒和毫秒
+        hours, remainder = divmod(end_seconds, 3600)
+        minutes, seconds = divmod(remainder, 60)
+        milliseconds = end_milliseconds
+
+        end = '{:02d}:{:02d}:{:02d},{:03d}'.format(hours, minutes, seconds, milliseconds)
+ 
+        # 构建SRT格式的单条记录
+        srt_line = f"{index}\n{start} --> {end}\n{sentence}\n"
+        srt_content.append(srt_line)
+        
+        # 更新当前时间以供下一句使用
+        current_time += total_duration
+    
+    return srt_content
+
+
+
+
+def txt_to_srt(txt_file_path, output_srt_file_path):
+    """
+    将TXT文件转换为SRT字幕文件。
+
+    :param txt_file_path: 输入TXT文件的路径
+    :param output_srt_file_path: 输出SRT文件的路径
+    :param start_time: 字幕开始的时间（秒），默认为2秒
+    """
+    with open(txt_file_path, 'r', encoding='utf-8') as file:
+        text = file.read()
+
+    sentences = split_text_into_sentences(text)
+    srt_content = generate_srt_content(sentences, start_time=2)
+
+    srt_content_str = '\n'.join(srt_content)
+
+    file_name = 'output_with_audio.srt'
+
+
+    with open(os.path.join(output_srt_file_path, file_name), 'w', encoding='utf-8') as file:
+        file.write(srt_content_str)
+
+    print("SRT文件已生成。")